RDBC-944 Simplify handle method overloads in AiConversation by consolidating logic and removing redundant branches.

Author: M4xymm

src/Documents/Operations/AI/AiConversation.ts

@@ -80,9 +80,44 @@ export class AiConversation {
         this._userPrompt = userPrompt;
     }
 
-    public handle<TArgs = any>(actionName: string, action: (request: AiAgentActionRequest, args: TArgs) => Promise<object> | object, aiHandleError: AiHandleErrorStrategy = AiHandleErrorStrategy.SendErrorsToModel): void {
+    public handle<TArgs = any>(
+        actionName: string,
+        action: (args: TArgs) => Promise<object>,
+        aiHandleError?: AiHandleErrorStrategy
+    ): void;
+
+    public handle<TArgs = any>(
+        actionName: string,
+        action: (args: TArgs) => object,
+        aiHandleError?: AiHandleErrorStrategy
+    ): void;
+
+    public handle<TArgs = any>(
+        actionName: string,
+        action: (request: AiAgentActionRequest, args: TArgs) => Promise<object>,
+        aiHandleError?: AiHandleErrorStrategy
+    ): void;
+
+    public handle<TArgs = any>(
+        actionName: string,
+        action: (request: AiAgentActionRequest, args: TArgs) => object,
+        aiHandleError?: AiHandleErrorStrategy
+    ): void
+
+    // Implementation
+    public handle<TArgs = any>(
+        actionName: string,
+        action: ((args: TArgs) => Promise<object> | object) |
+            ((request: AiAgentActionRequest, args: TArgs) => Promise<object> | object),
+        aiHandleError: AiHandleErrorStrategy = AiHandleErrorStrategy.SendErrorsToModel
+    ) {
+        const wrappedAction = action.length === 1
+            ? (_request: AiAgentActionRequest, args: TArgs) =>
+                (action as (args: TArgs) => Promise<object> | object)(args)
+            : action as (request: AiAgentActionRequest, args: TArgs) => Promise<object> | object;
+
         this.receive<TArgs>(actionName, async (req, args) => {
-            const result = await action(req, args);
+            const result = await wrappedAction(req, args);
             this.addActionResponse(req.toolId, result as any);
         }, aiHandleError);
     }

test/Ported/Documents/Operations/AiConversationTest.ts

@@ -151,4 +151,133 @@ import { AiHandleErrorStrategy } from "../../../../src/Documents/Operations/AI/A
         assertThat(receivedArgs.action.name).isSameAs("custom-action");
         assertThat(receivedArgs.action.toolId).isSameAs("tool-789");
     });
+
+    it("handle method works without request parameter (backward compat, async)", async () => {
+        const conv = store.ai.conversation("agents/1-A", "conversations/12|") as any;
+
+        let handlerCalled = false;
+        let capturedArgs: any = null;
+
+        // Register handler without request parameter (single arg)
+        conv.handle("simple-action", async (args: any) => {
+            handlerCalled = true;
+            capturedArgs = args;
+            return { result: "success", data: args.value };
+        });
+
+        // Verify handler was registered
+        assertThat(conv._invocations.has("simple-action")).isTrue();
+
+        // Simulate calling the handler via the internal invocation
+        const invocation = conv._invocations.get("simple-action");
+        await invocation({
+            name: "simple-action",
+            toolId: "tool-100",
+            arguments: '{"value":"test-data"}'
+        });
+
+        assertThat(handlerCalled).isTrue();
+        assertThat(capturedArgs).isNotNull();
+        assertThat(capturedArgs.value).isSameAs("test-data");
+
+        // Verify response was added
+        assertThat(conv._actionResponses.length).isGreaterThan(0);
+    });
+
+    it("handle method works without request parameter (backward compat, sync)", async () => {
+        const conv = store.ai.conversation("agents/1-A", "conversations/13|") as any;
+
+        let handlerCalled = false;
+
+        // Register sync handler without request parameter
+        conv.handle("sync-action", (args: any) => {
+            handlerCalled = true;
+            return { processed: true, input: args.input };
+        });
+
+        assertThat(conv._invocations.has("sync-action")).isTrue();
+
+        const invocation = conv._invocations.get("sync-action");
+        await invocation({
+            name: "sync-action",
+            toolId: "tool-101",
+            arguments: '{"input":"test"}'
+        });
+
+        assertThat(handlerCalled).isTrue();
+        assertThat(conv._actionResponses.length).isGreaterThan(0);
+    });
+
+    it("handle method works with request parameter (with metadata, async)", async () => {
+        const conv = store.ai.conversation("agents/1-A", "conversations/14|") as any;
+
+        let handlerCalled = false;
+        let capturedRequest: any = null;
+        let capturedArgs: any = null;
+
+        // Register handler with request parameter (two args)
+        conv.handle("action-with-request", async (request: any, args: any) => {
+            handlerCalled = true;
+            capturedRequest = request;
+            capturedArgs = args;
+            return { toolId: request.toolId, data: args.data };
+        });
+
+        assertThat(conv._invocations.has("action-with-request")).isTrue();
+
+        const invocation = conv._invocations.get("action-with-request");
+        const testRequest = {
+            name: "action-with-request",
+            toolId: "tool-102",
+            arguments: '{"data":"metadata-test"}'
+        };
+
+        await invocation(testRequest);
+
+        assertThat(handlerCalled).isTrue();
+        assertThat(capturedRequest).isNotNull();
+        assertThat(capturedRequest.toolId).isSameAs("tool-102");
+        assertThat(capturedArgs.data).isSameAs("metadata-test");
+    });
+
+    it("handle method works with request parameter (with metadata, sync)", async () => {
+        const conv = store.ai.conversation("agents/1-A", "conversations/15|") as any;
+
+        let capturedToolId: string = null;
+
+        // Register sync handler with request parameter
+        conv.handle("sync-with-request", (request: any, args: any) => {
+            capturedToolId = request.toolId;
+            return { success: true };
+        });
+
+        const invocation = conv._invocations.get("sync-with-request");
+        await invocation({
+            name: "sync-with-request",
+            toolId: "tool-103",
+            arguments: "{}"
+        });
+
+        assertThat(capturedToolId).isSameAs("tool-103");
+    });
+
+    it("handle method arity detection works correctly", async () => {
+        const conv = store.ai.conversation("agents/1-A", "conversations/16|") as any;
+
+        // Single parameter function (args only)
+        const singleParamHandler = (args: any) => ({ result: args });
+        assertThat(singleParamHandler.length).isSameAs(1);
+
+        // Two parameter function (request, args)
+        const twoParamHandler = (request: any, args: any) => ({ result: args });
+        assertThat(twoParamHandler.length).isSameAs(2);
+
+        // Register both
+        conv.handle("single-param", singleParamHandler);
+        conv.handle("two-param", twoParamHandler);
+
+        // Both should be registered
+        assertThat(conv._invocations.has("single-param")).isTrue();
+        assertThat(conv._invocations.has("two-param")).isTrue();
+    });
 });