fix: use Context._create_internal to get InternalContext in breakpoint wrapper

the step config patching approach failed because the llama_index
instrumentation dispatcher validates kwargs against the original function
signature via inspect.signature().bind(), rejecting the injected param.

instead, create an InternalContext directly via Context._create_internal(workflow).
this works because the wrapper runs inside the step worker where
StepWorkerStateContextVar is already set by the framework.

Author: radu-mocanu

packages/uipath-llamaindex/src/uipath_llamaindex/runtime/breakpoints.py

@@ -64,55 +64,40 @@ def inject_breakpoints(workflow: Workflow) -> None:
             cls._step_functions[name] = wrapped
 
 
-_BP_CTX_PARAM = "__bp_ctx__"
-
-
 def make_wrapper(
     step_name: str,
     original: StepFunction[..., Any],
 ) -> StepFunction[..., Any]:
     """
     Return a wrapped step function that pauses on breakpoints.
 
-    The workflows framework only passes the internal Context to a step when
-    the step's ``StepConfig.context_parameter`` is set. Many steps don't
-    declare a ``ctx`` parameter, so we patch the config to request one under
-    a private name (``__bp_ctx__``). The ``partial()`` helper inside the
-    framework will then bind the per-step InternalContext into kwargs for us.
+    The wrapper creates an InternalContext via ``Context._create_internal``
+    to call ``wait_for_event``. This works because the wrapper executes
+    inside the step worker where the framework has already set the
+    ``StepWorkerStateContextVar``.
     """
 
     @functools.wraps(original)
     async def wrapper(self, *args: Any, **kwargs: Any) -> Any:
-        # Pop the injected internal context so it doesn't leak to the original step.
-        ctx: Context | None = kwargs.pop(_BP_CTX_PARAM, None)
-
-        if isinstance(ctx, Context):
-            bp_event = BreakpointEvent(
-                breakpoint_node=step_name,
-                prefix=f"Breakpoint at {step_name}",
-            )
-            # Suspend until debugger resumes
-            await ctx.wait_for_event(
-                BreakpointResumeEvent,
-                waiter_event=bp_event,
-                waiter_id=f"bp_{step_name}",
-                timeout=None,
-            )
+        ctx = Context._create_internal(workflow=self)
+
+        bp_event = BreakpointEvent(
+            breakpoint_node=step_name,
+            prefix=f"Breakpoint at {step_name}",
+        )
+        # Suspend until debugger resumes
+        await ctx.wait_for_event(
+            BreakpointResumeEvent,
+            waiter_event=bp_event,
+            waiter_id=f"bp_{step_name}",
+            timeout=None,
+        )
 
         # Continue original step logic
         return await original(self, *args, **kwargs)
 
     wrapped = cast(StepFunction[..., Any], wrapper)
-
-    # Clone the step config and ensure context_parameter is set so the
-    # framework passes the InternalContext to our wrapper.
-    original_config = original._step_config
-    if original_config and not original_config.context_parameter:
-        wrapped._step_config = original_config.model_copy(
-            update={"context_parameter": _BP_CTX_PARAM}
-        )
-    else:
-        wrapped._step_config = original_config
+    wrapped._step_config = original._step_config
 
     return wrapped