@copilotkit/runtime 1.6.0-next.3 → 1.6.0-next.4

package/src/lib/runtime/__tests__/remote-action-constructors.test.ts

@@ -0,0 +1,236 @@
+import { TextEncoder } from "util";
+import { RemoteLangGraphEventSource } from "../../../agents/langgraph/event-source";
+import telemetry from "../../telemetry-client";
+import {
+  constructLGCRemoteAction,
+  constructRemoteActions,
+  createHeaders,
+} from "../remote-action-constructors";
+import { execute } from "../remote-lg-action";
+
+// Mock external dependencies
+jest.mock("../remote-lg-action", () => ({
+  execute: jest.fn(),
+}));
+
+jest.mock("../../telemetry-client", () => ({
+  capture: jest.fn(),
+}));
+
+jest.mock("../../../agents/langgraph/event-source", () => ({
+  RemoteLangGraphEventSource: jest.fn(),
+}));
+
+// Dummy logger
+const logger = {
+  debug: jest.fn(),
+  error: jest.fn(),
+  child: jest.fn(() => logger),
+};
+
+// Dummy graphqlContext
+const graphqlContext = { properties: { dummyProp: "value" } } as any;
+
+// Dummy agent state
+const agentStates = [{ agentName: "agent1", state: "{}", configurable: "{}" }];
+
+// Dummy agent used in constructLGCRemoteAction
+const dummyAgent = { name: "agent1", description: "test agent" };
+const endpoint = {
+  agents: [dummyAgent],
+  deploymentUrl: "http://dummy.deployment",
+  langsmithApiKey: "dummykey",
+};
+
+// Clear mocks before each test
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("remote action constructors", () => {
+  describe("constructLGCRemoteAction", () => {
+    it("should create an agent with langGraphAgentHandler that processes events", async () => {
+      // Arrange: simulate execute returning a dummy ReadableStream
+      const dummyEncodedEvent = new TextEncoder().encode(JSON.stringify({ event: "test" }) + "\n");
+      const readerMock = {
+        read: jest
+          .fn()
+          .mockResolvedValueOnce({ done: false, value: dummyEncodedEvent })
+          .mockResolvedValueOnce({ done: true, value: new Uint8Array() }),
+      };
+
+      const dummyResponse = {
+        getReader: () => readerMock,
+      };
+
+      (execute as jest.Mock).mockResolvedValue(dummyResponse);
+
+      // Mock RemoteLangGraphEventSource to return a dummy processed result
+      const processLangGraphEventsMock = jest.fn(() => "processed events");
+      (RemoteLangGraphEventSource as jest.Mock).mockImplementation(() => ({
+        eventStream$: { next: jest.fn(), complete: jest.fn(), error: jest.fn() },
+        processLangGraphEvents: processLangGraphEventsMock,
+      }));
+
+      // Act: build the action and call langGraphAgentHandler
+      const actions = constructLGCRemoteAction({
+        endpoint,
+        graphqlContext,
+        logger,
+        messages: [],
+        agentStates,
+      });
+      expect(actions).toHaveLength(1);
+      const action = actions[0];
+      expect(action.name).toEqual(dummyAgent.name);
+
+      const result = await action.langGraphAgentHandler({
+        name: dummyAgent.name,
+        actionInputsWithoutAgents: [],
+        threadId: "thread1",
+        nodeName: "node1",
+        additionalMessages: [],
+        metaEvents: [],
+      });
+
+      // Assert: processLangGraphEvents is called and result returned
+      expect(processLangGraphEventsMock).toHaveBeenCalled();
+      expect(result).toBe("processed events");
+
+      // Check telemetry.capture was called with agentExecution true
+      expect(telemetry.capture).toHaveBeenCalledWith(
+        "oss.runtime.remote_action_executed",
+        expect.objectContaining({
+          agentExecution: true,
+          type: "langgraph-platform",
+          agentsAmount: 1,
+        }),
+      );
+    });
+  });
+
+  describe("constructRemoteActions", () => {
+    const json = {
+      agents: [{ name: "agent2", description: "agent desc" }],
+      actions: [
+        {
+          name: "action1",
+          description: "action desc",
+          parameters: { param: "value" },
+        },
+      ],
+    };
+    const url = "http://dummy.api";
+    const onBeforeRequest = jest.fn(() => ({ headers: { Authorization: "Bearer token" } }));
+
+    it("should create remote action handler that calls fetch and returns the result", async () => {
+      // Arrange: mock fetch for action handler
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: jest.fn().mockResolvedValue({ result: "action result" }),
+      });
+
+      const actionsArray = constructRemoteActions({
+        json,
+        url,
+        onBeforeRequest,
+        graphqlContext,
+        logger,
+        messages: [],
+        agentStates,
+      });
+      // There should be one action (from json.actions) and one agent (from json.agents)
+      expect(actionsArray).toHaveLength(2);
+      const actionHandler = actionsArray[0].handler;
+
+      const result = await actionHandler({ foo: "bar" });
+      expect(result).toEqual("action result");
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        `${url}/actions/execute`,
+        expect.objectContaining({
+          method: "POST",
+          headers: expect.objectContaining({
+            "Content-Type": "application/json",
+            Authorization: "Bearer token",
+          }),
+          body: expect.any(String),
+        }),
+      );
+    });
+
+    it("should create remote agent handler that processes events", async () => {
+      // Arrange: mock fetch for agent handler to return a dummy stream
+      const dummyEncodedAgentEvent = new TextEncoder().encode('{"event":"data"}\n');
+      const agentReaderMock = {
+        read: jest
+          .fn()
+          .mockResolvedValueOnce({ done: false, value: dummyEncodedAgentEvent })
+          .mockResolvedValueOnce({ done: true, value: new Uint8Array() }),
+      };
+      const dummyStreamResponse = {
+        getReader: () => agentReaderMock,
+      };
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        text: jest.fn().mockResolvedValue("ok"),
+        body: dummyStreamResponse,
+      });
+
+      const processLangGraphEventsMock = jest.fn(() => "agent events processed");
+      (RemoteLangGraphEventSource as jest.Mock).mockImplementation(() => ({
+        eventStream$: { next: jest.fn(), complete: jest.fn(), error: jest.fn() },
+        processLangGraphEvents: processLangGraphEventsMock,
+      }));
+
+      const actionsArray = constructRemoteActions({
+        json,
+        url,
+        onBeforeRequest,
+        graphqlContext,
+        logger,
+        messages: [],
+        agentStates,
+      });
+      // The remote agent is the second item in the array
+      expect(actionsArray).toHaveLength(2);
+      const remoteAgentHandler = (actionsArray[1] as any).langGraphAgentHandler;
+      const result = await remoteAgentHandler({
+        name: "agent2",
+        actionInputsWithoutAgents: [],
+        threadId: "thread2",
+        nodeName: "node2",
+        additionalMessages: [],
+        metaEvents: [],
+      });
+      expect(processLangGraphEventsMock).toHaveBeenCalled();
+      expect(result).toBe("agent events processed");
+
+      // Check telemetry.capture for agent execution
+      expect(telemetry.capture).toHaveBeenCalledWith(
+        "oss.runtime.remote_action_executed",
+        expect.objectContaining({
+          agentExecution: true,
+          type: "self-hosted",
+          agentsAmount: 1,
+        }),
+      );
+    });
+  });
+
+  describe("createHeaders", () => {
+    it("should merge headers from onBeforeRequest", () => {
+      const onBeforeRequest = jest.fn(() => ({ headers: { "X-Test": "123" } }));
+      const headers = createHeaders(onBeforeRequest, graphqlContext);
+      expect(headers).toEqual({
+        "Content-Type": "application/json",
+        "X-Test": "123",
+      });
+    });
+
+    it("should return only Content-Type if no additional headers", () => {
+      const headers = createHeaders(undefined, graphqlContext);
+      expect(headers).toEqual({ "Content-Type": "application/json" });
+    });
+  });
+});

package/src/lib/runtime/remote-action-constructors.ts

@@ -18,6 +18,7 @@ import { LangGraphEvent } from "../../agents/langgraph/events";
 import { execute } from "./remote-lg-action";
 import { CopilotKitError, CopilotKitLowLevelError } from "@copilotkit/shared";
 import { CopilotKitApiDiscoveryError, ResolvedCopilotKitError } from "@copilotkit/shared";
+import { parseJson } from "@copilotkit/shared";
 
 export function constructLGCRemoteAction({
   endpoint,
@@ -59,8 +60,8 @@ export function constructLGCRemoteAction({
       if (agentStates) {
         const jsonState = agentStates.find((state) => state.agentName === name);
         if (jsonState) {
-          state = JSON.parse(jsonState.state);
-          configurable = JSON.parse(jsonState.configurable);
+          state = parseJson(jsonState.state, {});
+          configurable = parseJson(jsonState.configurable, {});
         }
       }
 
@@ -79,7 +80,7 @@ export function constructLGCRemoteAction({
           actions: actionInputsWithoutAgents.map((action) => ({
             name: action.name,
             description: action.description,
-            parameters: JSON.parse(action.jsonSchema) as string,
+            parameters: parseJson(action.jsonSchema, "") as string,
           })),
           metaEvents,
         });
@@ -203,8 +204,8 @@ export function constructRemoteActions({
           if (agentStates) {
             const jsonState = agentStates.find((state) => state.agentName === name);
             if (jsonState) {
-              state = JSON.parse(jsonState.state);
-              configurable = JSON.parse(jsonState.configurable);
+              state = parseJson(jsonState.state, {});
+              configurable = parseJson(jsonState.configurable, {});
             }
           }
 
@@ -224,7 +225,7 @@ export function constructRemoteActions({
                 actions: actionInputsWithoutAgents.map((action) => ({
                   name: action.name,
                   description: action.description,
-                  parameters: JSON.parse(action.jsonSchema),
+                  parameters: parseJson(action.jsonSchema, {}),
                 })),
                 metaEvents,
               }),

package/src/lib/runtime/remote-lg-action.ts

@@ -13,6 +13,7 @@ import telemetry from "../telemetry-client";
 import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
 import { MetaEventName } from "../../graphql/types/meta-events.type";
 import { RunsStreamPayload } from "@langchain/langgraph-sdk/dist/types";
+import { parseJson } from "@copilotkit/shared";
 
 type State = Record<string, any>;
 
@@ -164,12 +165,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   }
   if (lgInterruptMetaEvent?.response) {
     let response = lgInterruptMetaEvent.response;
-    try {
-      payload.command = { resume: JSON.parse(response) };
-      // In case of unparsable string, we keep the event as is
-    } catch (e) {
-      payload.command = { resume: response };
-    }
+    payload.command = { resume: parseJson(response, response) };
   }
 
   if (mode === "continue" && !activeInterruptEvent) {

package/src/service-adapters/conversion.ts

@@ -7,6 +7,7 @@ import {
 } from "../graphql/types/converted";
 import { MessageInput } from "../graphql/inputs/message.input";
 import { plainToInstance } from "class-transformer";
+import { parseJson } from "@copilotkit/shared";
 
 export function convertGqlInputToMessages(inputMessages: MessageInput[]): Message[] {
   const messages: Message[] = [];
@@ -28,7 +29,7 @@ export function convertGqlInputToMessages(inputMessages: MessageInput[]): Messag
           id: message.id,
           createdAt: message.createdAt,
           name: message.actionExecutionMessage.name,
-          arguments: JSON.parse(message.actionExecutionMessage.arguments),
+          arguments: parseJson(message.actionExecutionMessage.arguments, {}),
           parentMessageId: message.actionExecutionMessage.parentMessageId,
         }),
       );
@@ -53,7 +54,7 @@ export function convertGqlInputToMessages(inputMessages: MessageInput[]): Messag
           runId: message.agentStateMessage.runId,
           active: message.agentStateMessage.active,
           role: message.agentStateMessage.role,
-          state: JSON.parse(message.agentStateMessage.state),
+          state: parseJson(message.agentStateMessage.state, {}),
           running: message.agentStateMessage.running,
         }),
       );

package/src/service-adapters/openai/utils.ts

@@ -7,6 +7,7 @@ import {
   ChatCompletionAssistantMessageParam,
   ChatCompletionSystemMessageParam,
 } from "openai/resources";
+import { parseJson } from "@copilotkit/shared";
 
 export function limitMessagesToTokenCount(
   messages: any[],
@@ -113,7 +114,7 @@ export function convertActionInputToOpenAITool(action: ActionInput): ChatComplet
     function: {
       name: action.name,
       description: action.description,
-      parameters: JSON.parse(action.jsonSchema),
+      parameters: parseJson(action.jsonSchema, {}),
     },
   };
 }

package/tsconfig.json

@@ -1,12 +1,13 @@
 {
   "extends": "../../utilities/tsconfig/base.json",
   "compilerOptions": {
+    "types": ["node", "jest"],
     "lib": ["es2017", "dom"],
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,
     "strict": false,
     "resolveJsonModule": true
   },
-  "include": ["./src/**/*.ts"],
-  "exclude": ["dist", "build", "node_modules", "**/*.test.ts", "**/*.test.tsx", "**/__tests__/*"]
+  "include": ["./src/**/*.ts", "./src/**/*.test.ts", "./src/**/__tests__/*"],
+  "exclude": ["dist", "build", "node_modules"]
 }