refactor: extract get_call_args to eliminate duplicate parameter matching (#448)

* refactor: extract get_call_args to eliminate duplicate parameter matching

Reduces 18 lines of duplicated sync/async parameter matching logic to 4 lines.
The helper function centralize signature inspection and argument selection.

* test: add call-args flow to cover all main function signature types

Add comprehensive test coverage for the get_call_args refactor:
- no_params: def main()
- context_only: def main(context: Context)
- inputs_only: def main(inputs)
- two_params: def main(inputs, context: Context)
- async_two_params: async def main(inputs, context: Context)

Author: leavesster

.gitignore

@@ -163,3 +163,4 @@ cython_debug/
 .pdm-python
 
 node_modules
+.claude/

executor/python_executor/block.py

@@ -78,6 +78,25 @@ def output_return_object(obj, context: Context):
     else:
         context.finish(error=f"return object needs to be a dictionary, but get type: {type(obj)}")
 
+
+def get_call_args(fn, context: Context) -> tuple:
+    """
+    Determine the arguments to pass to a block function based on its signature.
+    Returns a tuple of positional arguments.
+    """
+    signature = inspect.signature(fn)
+    params_count = len(signature.parameters)
+
+    if params_count == 0:
+        return ()
+    elif params_count == 1:
+        first_param = list(signature.parameters.values())[0]
+        if first_param.annotation is Context:
+            return (context,)
+        return (context.inputs,)
+    else:
+        return (context.inputs, context)
+
 logger = logging.getLogger(EXECUTOR_NAME)
 
 async def run_block(message, mainframe: Mainframe, session_dir: str, tmp_dir: str, package_name: str, pkg_dir: str):
@@ -145,28 +164,15 @@ async def run_block(message, mainframe: Mainframe, session_dir: str, tmp_dir: st
         return
 
     try:
-        signature = inspect.signature(fn)
-        params_count = len(signature.parameters)
+        args = get_call_args(fn, context)
         result = None
         traceback_str = None
 
         try:
             if inspect.iscoroutinefunction(fn):
-                if params_count == 0:
-                    result = await fn()
-                elif params_count == 1:
-                    only_context_param = list(signature.parameters.values())[0].annotation is Context
-                    result = await fn(context) if only_context_param else await fn(context.inputs)
-                else:
-                    result = await fn(context.inputs, context)
+                result = await fn(*args)
             else:
-                if params_count == 0:
-                    result = fn()
-                elif params_count == 1:
-                    only_context_param = list(signature.parameters.values())[0].annotation is Context
-                    result = fn(context) if only_context_param else fn(context.inputs)
-                else:
-                    result = fn(context.inputs, context)
+                result = fn(*args)
         except ExitFunctionException as e:
             if e.args[0] is not None:
                 context.finish(error="block call exit with message: " + str(e.args[0]))

flow-examples/test/flow.test.ts

@@ -259,6 +259,19 @@ describe(
       expect(latestFinished?.data.result?.output).toBe(9);
     });
 
+    it("run call-args flow", async () => {
+      files.delete("call-args");
+      const { code, events } = await run("call-args");
+      expect(code).toBe(0);
+
+      const finishedEvents = events.filter(e => e.event === "BlockFinished");
+      expect(finishedEvents.length).toBe(5);
+
+      // Verify the chain executed in order
+      const lastFinished = finishedEvents[finishedEvents.length - 1];
+      expect(lastFinished?.data.stacks?.[0].node_id).toBe("async_two_params");
+    });
+
     it("run additional-block flow", async () => {
       files.delete("additional-block");
       const { code, events } = await run("additional-block");

flow-examples/workspace/blocks/async_two_params/__init__.py

@@ -0,0 +1,7 @@
+from oocana import Context
+
+
+async def main(inputs, context: Context):
+    value = inputs.get("input", "default")
+    context.send_message(f"async_two_params received: {value}")
+    return {"output": f"async_two_params:{value}"}

flow-examples/workspace/blocks/async_two_params/block.oo.yaml

@@ -0,0 +1,8 @@
+executor:
+  name: python
+  options:
+    entry: __init__.py
+inputs_def:
+  - handle: input
+outputs_def:
+  - handle: output

flow-examples/workspace/blocks/context_only/__init__.py

@@ -0,0 +1,6 @@
+from oocana import Context
+
+
+def main(context: Context):
+    value = context.inputs.get("input", "default")
+    return {"output": f"context_only:{value}"}

flow-examples/workspace/blocks/context_only/block.oo.yaml

@@ -0,0 +1,8 @@
+executor:
+  name: python
+  options:
+    entry: __init__.py
+inputs_def:
+  - handle: input
+outputs_def:
+  - handle: output

flow-examples/workspace/blocks/inputs_only/__init__.py

@@ -0,0 +1,3 @@
+def main(inputs):
+    value = inputs.get("input", "default")
+    return {"output": f"inputs_only:{value}"}

flow-examples/workspace/blocks/inputs_only/block.oo.yaml

@@ -0,0 +1,8 @@
+executor:
+  name: python
+  options:
+    entry: __init__.py
+inputs_def:
+  - handle: input
+outputs_def:
+  - handle: output

flow-examples/workspace/blocks/no_params/__init__.py

@@ -0,0 +1,2 @@
+def main():
+    return {"output": "no_params_ok"}