@copilotkit/runtime 0.0.0-fix-debug-infosys-20251107151227 → 0.0.0-fix-restore-handle-method-node-http-20251222114321

package/dist/utils/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/index.ts","../../src/graphql/types/response-status.type.ts","../../src/utils/failed-response-status-reasons.ts"],"sourcesContent":["export * from \"./failed-response-status-reasons\";\n","import { GraphQLJSON } from \"graphql-scalars\";\nimport { Field, InterfaceType, ObjectType, createUnionType, registerEnumType } from \"type-graphql\";\n\nexport enum ResponseStatusCode {\n  Pending = \"pending\",\n  Success = \"success\",\n  Failed = \"failed\",\n}\n\nregisterEnumType(ResponseStatusCode, {\n  name: \"ResponseStatusCode\",\n});\n\n@InterfaceType({\n  resolveType(value) {\n    if (value.code === ResponseStatusCode.Success) {\n      return SuccessResponseStatus;\n    } else if (value.code === ResponseStatusCode.Failed) {\n      return FailedResponseStatus;\n    } else if (value.code === ResponseStatusCode.Pending) {\n      return PendingResponseStatus;\n    }\n    return undefined;\n  },\n})\n@ObjectType()\nabstract class BaseResponseStatus {\n  @Field(() => ResponseStatusCode)\n  code: ResponseStatusCode;\n}\n\n@ObjectType({ implements: BaseResponseStatus })\nexport class PendingResponseStatus extends BaseResponseStatus {\n  code: ResponseStatusCode = ResponseStatusCode.Pending;\n}\n\n@ObjectType({ implements: BaseResponseStatus })\nexport class SuccessResponseStatus extends BaseResponseStatus {\n  code: ResponseStatusCode = ResponseStatusCode.Success;\n}\n\nexport enum FailedResponseStatusReason {\n  GUARDRAILS_VALIDATION_FAILED = \"GUARDRAILS_VALIDATION_FAILED\",\n  MESSAGE_STREAM_INTERRUPTED = \"MESSAGE_STREAM_INTERRUPTED\",\n  UNKNOWN_ERROR = \"UNKNOWN_ERROR\",\n}\n\nregisterEnumType(FailedResponseStatusReason, {\n  name: \"FailedResponseStatusReason\",\n});\n\n@ObjectType({ implements: BaseResponseStatus })\nexport class FailedResponseStatus extends BaseResponseStatus {\n  code: ResponseStatusCode = ResponseStatusCode.Failed;\n\n  @Field(() => FailedResponseStatusReason)\n  reason: FailedResponseStatusReason;\n\n  @Field(() => GraphQLJSON, { nullable: true })\n  details?: Record<string, any> = null;\n}\n\nexport const ResponseStatusUnion = createUnionType({\n  name: \"ResponseStatus\",\n  types: () => [PendingResponseStatus, SuccessResponseStatus, FailedResponseStatus] as const,\n});\n","import {\n  FailedResponseStatus,\n  FailedResponseStatusReason,\n} from \"../graphql/types/response-status.type\";\n\nexport class GuardrailsValidationFailureResponse extends FailedResponseStatus {\n  reason = FailedResponseStatusReason.GUARDRAILS_VALIDATION_FAILED;\n  declare details: {\n    guardrailsReason: string;\n  };\n\n  constructor({ guardrailsReason }) {\n    super();\n    this.details = {\n      guardrailsReason,\n    };\n  }\n}\n\nexport class MessageStreamInterruptedResponse extends FailedResponseStatus {\n  reason = FailedResponseStatusReason.MESSAGE_STREAM_INTERRUPTED;\n  declare details: {\n    messageId: string;\n    description: string;\n  };\n\n  constructor({ messageId }: { messageId: string }) {\n    super();\n    this.details = {\n      messageId,\n      description: \"Check the message for mode details\",\n    };\n  }\n}\n\nexport class UnknownErrorResponse extends FailedResponseStatus {\n  reason = FailedResponseStatusReason.UNKNOWN_ERROR;\n  declare details: {\n    description?: string;\n    originalError?: {\n      code?: string;\n      statusCode?: number;\n      severity?: string;\n      visibility?: string;\n      originalErrorType?: string;\n      extensions?: any;\n    };\n  };\n\n  constructor({\n    description,\n    originalError,\n  }: {\n    description?: string;\n    originalError?: {\n      code?: string;\n      statusCode?: number;\n      severity?: string;\n      visibility?: string;\n      originalErrorType?: string;\n      extensions?: any;\n    };\n  }) {\n    super();\n    this.details = {\n      description,\n      originalError,\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;ACAA,6BAA4B;AAC5B,0BAAoF;;;;;;;;;;;;;;;;;;UAExEA,qBAAAA;;;;GAAAA,uBAAAA,qBAAAA,CAAAA,EAAAA;IAMZC,sCAAiBD,oBAAoB;EACnCE,MAAM;AACR,CAAA;AAeA,IAAeC,qBAAf,6BAAeA,oBAAAA;EAEbC;AACF,GAHA;;MACGC,2BAAM,MAAML,kBAAAA;;GADAG,mBAAAA,WAAAA,QAAAA,MAAAA;AAAAA,qBAAAA,aAAAA;MAbdG,mCAAc;IACbC,YAAYC,OAAK;AACf,UAAIA,MAAMJ,SAAI,WAAiC;AAC7C,eAAOK;MACT,WAAWD,MAAMJ,SAAI,UAAgC;AACnD,eAAOM;MACT,WAAWF,MAAMJ,SAAI,WAAiC;AACpD,eAAOO;MACT;AACA,aAAOC;IACT;EACF,CAAA;MACCC,gCAAAA;GACcV,kBAAAA;AAMR,IAAMQ,wBAAN,cAAoCR,mBAAAA;EACzCC,OAAAA;AACF;AAFaO;AAAAA,wBAAAA,aAAAA;MADZE,gCAAW;IAAEC,YAAYX;EAAmB,CAAA;GAChCQ,qBAAAA;AAKN,IAAMF,wBAAN,cAAoCN,mBAAAA;EACzCC,OAAAA;AACF;AAFaK;AAAAA,wBAAAA,aAAAA;MADZI,gCAAW;IAAEC,YAAYX;EAAmB,CAAA;GAChCM,qBAAAA;;UAIDM,6BAAAA;;;;GAAAA,+BAAAA,6BAAAA,CAAAA,EAAAA;IAMZd,sCAAiBc,4BAA4B;EAC3Cb,MAAM;AACR,CAAA;AAGO,IAAMQ,uBAAN,cAAmCP,mBAAAA;EACxCC,OAAAA;EAGAY;EAGAC,UAAgC;AAClC;AARaP;;MAGVL,2BAAM,MAAMU,0BAAAA;;GAHFL,qBAAAA,WAAAA,UAAAA,MAAAA;;MAMVL,2BAAM,MAAMa,oCAAa;IAAEC,UAAU;EAAK,CAAA;qCACjC,WAAA,cAAA,SAAA,MAAA;GAPCT,qBAAAA,WAAAA,WAAAA,MAAAA;AAAAA,uBAAAA,aAAAA;MADZG,gCAAW;IAAEC,YAAYX;EAAmB,CAAA;GAChCO,oBAAAA;AAUN,IAAMU,0BAAsBC,qCAAgB;EACjDnB,MAAM;EACNoB,OAAO,MAAM;IAACX;IAAuBF;IAAuBC;;AAC9D,CAAA;;;AC5DO,IAAMa,sCAAN,cAAkDC,qBAAAA;EACvDC,SAASC,2BAA2BC;EAKpCC,YAAY,EAAEC,iBAAgB,GAAI;AAChC,UAAK;AACL,SAAKC,UAAU;MACbD;IACF;EACF;AACF;AAZaN;AAcN,IAAMQ,mCAAN,cAA+CP,qBAAAA;EACpDC,SAASC,2BAA2BM;EAMpCJ,YAAY,EAAEK,UAAS,GAA2B;AAChD,UAAK;AACL,SAAKH,UAAU;MACbG;MACAC,aAAa;IACf;EACF;AACF;AAdaH;AAgBN,IAAMI,uBAAN,cAAmCX,qBAAAA;EACxCC,SAASC,2BAA2BU;EAapCR,YAAY,EACVM,aACAG,cAAa,GAWZ;AACD,UAAK;AACL,SAAKP,UAAU;MACbI;MACAG;IACF;EACF;AACF;AAlCaF;","names":["ResponseStatusCode","registerEnumType","name","BaseResponseStatus","code","Field","InterfaceType","resolveType","value","SuccessResponseStatus","FailedResponseStatus","PendingResponseStatus","undefined","ObjectType","implements","FailedResponseStatusReason","reason","details","GraphQLJSON","nullable","ResponseStatusUnion","createUnionType","types","GuardrailsValidationFailureResponse","FailedResponseStatus","reason","FailedResponseStatusReason","GUARDRAILS_VALIDATION_FAILED","constructor","guardrailsReason","details","MessageStreamInterruptedResponse","MESSAGE_STREAM_INTERRUPTED","messageId","description","UnknownErrorResponse","UNKNOWN_ERROR","originalError"]}

package/dist/utils/index.mjs

@@ -1,12 +0,0 @@
-import {
-  GuardrailsValidationFailureResponse,
-  MessageStreamInterruptedResponse,
-  UnknownErrorResponse
-} from "../chunk-XWBDEXDA.mjs";
-import "../chunk-FHD4JECV.mjs";
-export {
-  GuardrailsValidationFailureResponse,
-  MessageStreamInterruptedResponse,
-  UnknownErrorResponse
-};
-//# sourceMappingURL=index.mjs.map

package/dist/utils/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

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

@@ -1,246 +0,0 @@
-import "reflect-metadata";
-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";
-import { ReplaySubject } from "rxjs";
-
-// 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 remoteAgentHandler 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 remoteAgentHandler
-      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.remoteAgentHandler({
-        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 () => {
-      const json = {
-        agents: [
-          {
-            name: "agent2",
-            description: "agent desc",
-            type: "langgraph", // Add type to match RemoteAgentType.LangGraph
-          },
-        ],
-        actions: [
-          {
-            name: "action1",
-            description: "action desc",
-            parameters: { param: "value" },
-          },
-        ],
-      };
-
-      const dummyEncodedAgentEvent = new TextEncoder().encode('{"type":"data","content":"test"}\n');
-
-      const mockResponse = new Response(
-        new ReadableStream({
-          start(controller) {
-            controller.enqueue(dummyEncodedAgentEvent);
-            controller.close();
-          },
-        }),
-        {
-          status: 200,
-          statusText: "OK",
-          headers: new Headers({
-            "content-type": "application/json",
-          }),
-        },
-      );
-
-      global.fetch = jest.fn().mockResolvedValue(mockResponse);
-
-      const processLangGraphEventsMock = jest.fn().mockResolvedValue("agent events processed");
-      (RemoteLangGraphEventSource as jest.Mock).mockImplementation(() => ({
-        eventStream$: new ReplaySubject(),
-        processLangGraphEvents: processLangGraphEventsMock,
-      }));
-
-      const actionsArray = constructRemoteActions({
-        json,
-        url,
-        onBeforeRequest,
-        graphqlContext,
-        logger,
-        messages: [],
-        agentStates,
-      });
-
-      const remoteAgentHandler = (actionsArray[1] as any).remoteAgentHandler;
-      const result = await remoteAgentHandler({
-        name: "agent2",
-        actionInputsWithoutAgents: [],
-        threadId: "thread2",
-        nodeName: "node2",
-      });
-
-      expect(processLangGraphEventsMock).toHaveBeenCalled();
-      expect(result).toBe("agent events processed");
-    });
-  });
-
-  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/agui-action.ts

@@ -1,180 +0,0 @@
-import { Logger } from "pino";
-import { catchError, mergeMap, Observable, of, throwError } from "rxjs";
-import { AgentStateInput } from "../../graphql/inputs/agent-state.input";
-import { Message } from "../../graphql/types/converted";
-import { RuntimeErrorEvent, RuntimeEvent, RuntimeEventTypes } from "../../service-adapters/events";
-import telemetry from "../telemetry-client";
-import { RemoteAgentHandlerParams } from "./remote-actions";
-
-import {
-  AssistantMessage as AGUIAssistantMessage,
-  Message as AGUIMessage,
-  ToolCall,
-} from "@ag-ui/client";
-
-import { AbstractAgent } from "@ag-ui/client";
-import { Action, CopilotKitError, CopilotKitErrorCode, parseJson } from "@copilotkit/shared";
-import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
-import { GraphQLContext } from "../integrations/shared";
-import { CopilotContextInput } from "../../graphql/inputs/copilot-context.input";
-
-export type RemoteAgentAction = Action<[]> & {
-  remoteAgentHandler: (params: RemoteAgentHandlerParams) => Promise<Observable<RuntimeEvent>>;
-};
-
-export function constructAGUIRemoteAction({
-  logger,
-  messages,
-  agentStates,
-  agent,
-  metaEvents,
-  threadMetadata,
-  nodeName,
-  context,
-  graphqlContext,
-}: {
-  logger: Logger;
-  messages: Message[];
-  agentStates?: AgentStateInput[];
-  agent: AbstractAgent;
-  metaEvents?: MetaEventInput[];
-  threadMetadata?: Record<string, any>;
-  nodeName?: string;
-  context?: CopilotContextInput[];
-  graphqlContext: GraphQLContext;
-}): RemoteAgentAction[] {
-  const action: RemoteAgentAction = {
-    name: agent.agentId,
-    description: agent.description,
-    parameters: [],
-    handler: async () => {},
-    remoteAgentHandler: async ({
-      actionInputsWithoutAgents,
-      threadId,
-    }: RemoteAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
-      graphqlContext.request.signal.addEventListener(
-        "abort",
-        () => {
-          agent.abortRun();
-        },
-        { once: true }, // optional: fire only once
-      );
-      logger.debug({ actionName: agent.agentId }, "Executing remote agent");
-
-      const agentWireMessages = convertMessagesToAGUIMessage(messages);
-      agent.messages = agentWireMessages;
-      agent.threadId = threadId;
-
-      telemetry.capture("oss.runtime.remote_action_executed", {
-        agentExecution: true,
-        type: "self-hosted",
-        agentsAmount: 1,
-      });
-
-      let state = {};
-      let config: Record<string, unknown> = {};
-      if (agentStates) {
-        const jsonState = agentStates.find((state) => state.agentName === agent.agentId);
-        if (jsonState) {
-          state = parseJson(jsonState.state, {});
-          config = parseJson(jsonState.config, {});
-        }
-      }
-      agent.state = state;
-
-      const tools = actionInputsWithoutAgents.map((input) => {
-        return {
-          name: input.name,
-          description: input.description,
-          parameters: JSON.parse(input.jsonSchema),
-        };
-      });
-
-      const { streamSubgraphs, ...restConfig } = config;
-
-      const forwardedProps = {
-        config: restConfig,
-        ...(metaEvents?.length ? { command: { resume: metaEvents[0]?.response } } : {}),
-        ...(threadMetadata ? { threadMetadata } : {}),
-        ...(nodeName ? { nodeName } : {}),
-        ...(streamSubgraphs ? { streamSubgraphs } : {}),
-        // Forward properties from the graphql context to the agent, e.g Authorization token
-        ...graphqlContext.properties,
-      };
-
-      return (
-        agent.legacy_to_be_removed_runAgentBridged({
-          tools,
-          forwardedProps,
-          context,
-        }) as Observable<RuntimeEvent>
-      ).pipe(
-        mergeMap((event) => {
-          if (event.type === RuntimeEventTypes.RunError) {
-            const { message } = event as RuntimeErrorEvent;
-            return throwError(
-              () => new CopilotKitError({ message, code: CopilotKitErrorCode.UNKNOWN }),
-            );
-          }
-          // pass through non-error events
-          return of(event);
-        }),
-        catchError((err) => {
-          throw new CopilotKitError({
-            message: err.message,
-            code: CopilotKitErrorCode.UNKNOWN,
-          });
-        }),
-      );
-    },
-  };
-  return [action];
-}
-
-export function convertMessagesToAGUIMessage(messages: Message[]): AGUIMessage[] {
-  const result: AGUIMessage[] = [];
-
-  for (const message of messages) {
-    if (message.isTextMessage()) {
-      result.push({
-        id: message.id,
-        role: message.role as any,
-        content: message.content,
-      });
-    } else if (message.isActionExecutionMessage()) {
-      const toolCall: ToolCall = {
-        id: message.id,
-        type: "function",
-        function: {
-          name: message.name,
-          arguments: JSON.stringify(message.arguments),
-        },
-      };
-
-      if (message.parentMessageId && result.some((m) => m.id === message.parentMessageId)) {
-        const parentMessage: AGUIAssistantMessage | undefined = result.find(
-          (m) => m.id === message.parentMessageId,
-        ) as AGUIAssistantMessage;
-        if (parentMessage.toolCalls === undefined) {
-          parentMessage.toolCalls = [];
-        }
-        parentMessage.toolCalls.push(toolCall);
-      } else {
-        result.push({
-          id: message.parentMessageId ?? message.id,
-          role: "assistant",
-          toolCalls: [toolCall],
-        });
-      }
-    } else if (message.isResultMessage()) {
-      result.push({
-        id: message.id,
-        role: "tool",
-        content: message.result,
-        toolCallId: message.actionExecutionId,
-      });
-    }
-  }
-
-  return result;
-}