@copilotkit/runtime 1.50.0-beta.8 → 1.50.0

package/dist/langserve-9fc76ce5.d.ts

@@ -0,0 +1,243 @@
+import { T as TextMessage, A as ActionExecutionMessage, R as ResultMessage, b as ActionInputAvailability, M as Message } from './index-adbd78f1.js';
+import { ReplaySubject } from 'rxjs';
+import { Parameter, Action } from '@copilotkit/shared';
+
+/**
+ * The extensions response is used to receive additional information from the copilot runtime, specific to a
+ * service adapter or agent framework.
+ *
+ * Next time a request to the runtime is made, the extensions response will be included in the request as input.
+ */
+declare class ExtensionsResponse {
+    openaiAssistantAPI?: OpenAIApiAssistantAPIResponse;
+}
+declare class OpenAIApiAssistantAPIResponse {
+    runId?: string;
+    threadId?: string;
+}
+
+declare enum RuntimeEventTypes {
+    TextMessageStart = "TextMessageStart",
+    TextMessageContent = "TextMessageContent",
+    TextMessageEnd = "TextMessageEnd",
+    ActionExecutionStart = "ActionExecutionStart",
+    ActionExecutionArgs = "ActionExecutionArgs",
+    ActionExecutionEnd = "ActionExecutionEnd",
+    ActionExecutionResult = "ActionExecutionResult",
+    AgentStateMessage = "AgentStateMessage",
+    MetaEvent = "MetaEvent",
+    RunError = "RunError"
+}
+declare enum RuntimeMetaEventName {
+    LangGraphInterruptEvent = "LangGraphInterruptEvent",
+    LangGraphInterruptResumeEvent = "LangGraphInterruptResumeEvent",
+    CopilotKitLangGraphInterruptEvent = "CopilotKitLangGraphInterruptEvent"
+}
+type RunTimeMetaEvent = {
+    type: RuntimeEventTypes.MetaEvent;
+    name: RuntimeMetaEventName.LangGraphInterruptEvent;
+    value: string;
+} | {
+    type: RuntimeEventTypes.MetaEvent;
+    name: RuntimeMetaEventName.CopilotKitLangGraphInterruptEvent;
+    data: {
+        value: string;
+        messages: (TextMessage | ActionExecutionMessage | ResultMessage)[];
+    };
+} | {
+    type: RuntimeEventTypes.MetaEvent;
+    name: RuntimeMetaEventName.LangGraphInterruptResumeEvent;
+    data: string;
+};
+type RuntimeErrorEvent = {
+    type: RuntimeEventTypes.RunError;
+    message: string;
+    code?: string;
+};
+type RuntimeEvent = {
+    type: RuntimeEventTypes.TextMessageStart;
+    messageId: string;
+    parentMessageId?: string;
+} | {
+    type: RuntimeEventTypes.TextMessageContent;
+    messageId: string;
+    content: string;
+} | {
+    type: RuntimeEventTypes.TextMessageEnd;
+    messageId: string;
+} | {
+    type: RuntimeEventTypes.ActionExecutionStart;
+    actionExecutionId: string;
+    actionName: string;
+    parentMessageId?: string;
+} | {
+    type: RuntimeEventTypes.ActionExecutionArgs;
+    actionExecutionId: string;
+    args: string;
+} | {
+    type: RuntimeEventTypes.ActionExecutionEnd;
+    actionExecutionId: string;
+} | {
+    type: RuntimeEventTypes.ActionExecutionResult;
+    actionName: string;
+    actionExecutionId: string;
+    result: string;
+} | {
+    type: RuntimeEventTypes.AgentStateMessage;
+    threadId: string;
+    agentName: string;
+    nodeName: string;
+    runId: string;
+    active: boolean;
+    role: string;
+    state: string;
+    running: boolean;
+} | RunTimeMetaEvent | RuntimeErrorEvent;
+type EventSourceCallback = (eventStream$: RuntimeEventSubject) => Promise<void>;
+declare class RuntimeEventSubject extends ReplaySubject<RuntimeEvent> {
+    constructor();
+    sendTextMessageStart({ messageId, parentMessageId, }: {
+        messageId: string;
+        parentMessageId?: string;
+    }): void;
+    sendTextMessageContent({ messageId, content }: {
+        messageId: string;
+        content: string;
+    }): void;
+    sendTextMessageEnd({ messageId }: {
+        messageId: string;
+    }): void;
+    sendTextMessage(messageId: string, content: string): void;
+    sendActionExecutionStart({ actionExecutionId, actionName, parentMessageId, }: {
+        actionExecutionId: string;
+        actionName: string;
+        parentMessageId?: string;
+    }): void;
+    sendActionExecutionArgs({ actionExecutionId, args, }: {
+        actionExecutionId: string;
+        args: string;
+    }): void;
+    sendActionExecutionEnd({ actionExecutionId }: {
+        actionExecutionId: string;
+    }): void;
+    sendActionExecution({ actionExecutionId, actionName, args, parentMessageId, }: {
+        actionExecutionId: string;
+        actionName: string;
+        args: string;
+        parentMessageId?: string;
+    }): void;
+    sendActionExecutionResult({ actionExecutionId, actionName, result, error, }: {
+        actionExecutionId: string;
+        actionName: string;
+        result?: string;
+        error?: {
+            code: string;
+            message: string;
+        };
+    }): void;
+    sendAgentStateMessage({ threadId, agentName, nodeName, runId, active, role, state, running, }: {
+        threadId: string;
+        agentName: string;
+        nodeName: string;
+        runId: string;
+        active: boolean;
+        role: string;
+        state: string;
+        running: boolean;
+    }): void;
+}
+declare class RuntimeEventSource {
+    private eventStream$;
+    private callback;
+    private errorHandler?;
+    private errorContext?;
+    constructor(params?: {
+        errorHandler?: (error: any, context: any) => Promise<void>;
+        errorContext?: any;
+    });
+    stream(callback: EventSourceCallback): Promise<void>;
+}
+
+declare class ActionInput {
+    name: string;
+    description: string;
+    jsonSchema: string;
+    available?: ActionInputAvailability;
+}
+
+declare class ForwardedParametersInput {
+    model?: string;
+    maxTokens?: number;
+    stop?: string[];
+    toolChoice?: String;
+    toolChoiceFunctionName?: string;
+    temperature?: number;
+}
+
+/**
+ * The extensions input is used to pass additional information to the copilot runtime, specific to a
+ * service adapter or agent framework.
+ */
+declare class ExtensionsInput {
+    openaiAssistantAPI?: OpenAIApiAssistantAPIInput;
+}
+declare class OpenAIApiAssistantAPIInput {
+    runId?: string;
+    threadId?: string;
+}
+
+declare class AgentSessionInput {
+    agentName: string;
+    threadId?: string;
+    nodeName?: string;
+}
+
+declare class AgentStateInput {
+    agentName: string;
+    state: string;
+    config?: string;
+}
+
+interface CopilotRuntimeChatCompletionRequest {
+    eventSource: RuntimeEventSource;
+    messages: Message[];
+    actions: ActionInput[];
+    model?: string;
+    threadId?: string;
+    runId?: string;
+    forwardedParameters?: ForwardedParametersInput;
+    extensions?: ExtensionsInput;
+    agentSession?: AgentSessionInput;
+    agentStates?: AgentStateInput[];
+}
+interface CopilotRuntimeChatCompletionResponse {
+    threadId: string;
+    runId?: string;
+    extensions?: ExtensionsResponse;
+}
+interface CopilotServiceAdapter {
+    provider?: string;
+    model?: string;
+    process(request: CopilotRuntimeChatCompletionRequest): Promise<CopilotRuntimeChatCompletionResponse>;
+    name?: string;
+}
+
+interface RemoteChainParameters {
+    name: string;
+    description: string;
+    chainUrl: string;
+    parameters?: Parameter[];
+    parameterType?: "single" | "multi";
+}
+declare class RemoteChain {
+    name: string;
+    description: string;
+    chainUrl: string;
+    parameters?: Parameter[];
+    parameterType: "single" | "multi";
+    constructor(options: RemoteChainParameters);
+    toAction(): Promise<Action<any>>;
+    inferLangServeParameters(): Promise<void>;
+}
+
+export { ActionInput as A, CopilotRuntimeChatCompletionRequest as C, ExtensionsInput as E, ForwardedParametersInput as F, RemoteChainParameters as R, CopilotRuntimeChatCompletionResponse as a, CopilotServiceAdapter as b, RemoteChain as c, AgentSessionInput as d, AgentStateInput as e };

package/dist/lib/cloud/index.d.ts

@@ -0,0 +1,6 @@
+interface CopilotCloudOptions {
+    baseUrl?: string;
+    publicApiKey?: string;
+}
+
+export { CopilotCloudOptions };

package/dist/lib/cloud/index.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/cloud/index.ts
+var cloud_exports = {};
+module.exports = __toCommonJS(cloud_exports);
+//# sourceMappingURL=index.js.map

package/dist/lib/cloud/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/cloud/index.ts"],"sourcesContent":["export interface CopilotCloudOptions {\n  baseUrl?: string;\n  publicApiKey?: string;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAAA;;","names":[]}

package/dist/lib/cloud/index.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=index.mjs.map

package/dist/lib/cloud/index.mjs.map

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

package/dist/lib/index.d.ts

@@ -0,0 +1,212 @@
+export { G as GoogleGenerativeAIAdapter, f as GroqAdapter, e as GroqAdapterParams, L as LangChainAdapter, a as OpenAIAdapter, O as OpenAIAdapterParams, c as OpenAIAssistantAdapter, b as OpenAIAssistantAdapterParams, d as UnifyAdapter, U as UnifyAdapterParams } from '../groq-adapter-c8aec5c5.js';
+export { e as CommonConfig, C as CopilotRequestContextProperties, k as CopilotRuntime, j as CopilotRuntimeConstructorParams, f as CopilotRuntimeLogger, i as CopilotRuntimeRequest, b as CreateCopilotRuntimeServerOptions, G as GraphQLContext, L as LogLevel, o as MCPClient, p as MCPEndpointConfig, M as MCPTool, a as addCustomHeaderPlugin, d as buildSchema, s as convertMCPToolsToActions, m as copilotKitEndpoint, c as createContext, h as createLogger, q as extractParametersFromSchema, l as flattenToolCallsNoDuplicates, t as generateMcpToolInstructions, g as getCommonConfig, n as langGraphPlatformEndpoint, r as resolveEndpointType } from '../shared-0a7346ce.js';
+export { CopilotRuntimeServerInstance, config, copilotRuntimeNextJSAppRouterEndpoint, copilotRuntimeNextJSPagesRouterEndpoint } from './integrations/index.js';
+export { copilotRuntimeNodeHttpEndpoint } from './integrations/node-http/index.js';
+export { copilotRuntimeNodeExpressEndpoint } from './integrations/node-express/index.js';
+export { copilotRuntimeNestEndpoint } from './integrations/nest/index.js';
+import * as rxjs from 'rxjs';
+import { TextMessageStartEvent, TextMessageContentEvent, TextMessageEndEvent, ToolCallStartEvent, ToolCallArgsEvent, ToolCallEndEvent, RunAgentInput, EventType } from '@ag-ui/client';
+import { LangGraphAgent as LangGraphAgent$1, LangGraphAgentConfig, ProcessedEvents, State, StateEnrichment, SchemaKeys } from '@ag-ui/langgraph';
+export { LangGraphHttpAgent } from '@ag-ui/langgraph';
+import { Message } from '@langchain/langgraph-sdk/dist/types.messages';
+import 'openai';
+import '../langserve-0c6100e3.js';
+import '../index-96b330da.js';
+import '../graphql/types/base/index.js';
+import '@copilotkit/shared';
+import '@langchain/core/messages';
+import '@langchain/core/tools';
+import '@langchain/core/utils/stream';
+import 'groq-sdk';
+import 'graphql';
+import 'pino';
+import 'graphql-yoga';
+import './cloud/index.js';
+
+interface CopilotKitStateEnrichment {
+    copilotkit: {
+        actions: StateEnrichment["ag-ui"]["tools"];
+        context: StateEnrichment["ag-ui"]["context"];
+    };
+}
+interface PredictStateTool {
+    tool: string;
+    state_key: string;
+    tool_argument: string;
+}
+type TextMessageEvents = TextMessageStartEvent | TextMessageContentEvent | TextMessageEndEvent;
+type ToolCallEvents = ToolCallStartEvent | ToolCallArgsEvent | ToolCallEndEvent;
+declare enum CustomEventNames {
+    CopilotKitManuallyEmitMessage = "copilotkit_manually_emit_message",
+    CopilotKitManuallyEmitToolCall = "copilotkit_manually_emit_tool_call",
+    CopilotKitManuallyEmitIntermediateState = "copilotkit_manually_emit_intermediate_state",
+    CopilotKitExit = "copilotkit_exit"
+}
+declare class LangGraphAgent extends LangGraphAgent$1 {
+    constructor(config: LangGraphAgentConfig);
+    dispatchEvent(event: ProcessedEvents): boolean;
+    run(input: RunAgentInput): rxjs.Observable<{
+        type: EventType.TEXT_MESSAGE_START;
+        role: "developer" | "system" | "assistant" | "user";
+        messageId: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.TEXT_MESSAGE_CONTENT;
+        messageId: string;
+        delta: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.TEXT_MESSAGE_END;
+        messageId: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.TOOL_CALL_START;
+        toolCallId: string;
+        toolCallName: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+        parentMessageId?: string | undefined;
+    } | {
+        type: EventType.TOOL_CALL_ARGS;
+        toolCallId: string;
+        delta: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.TOOL_CALL_END;
+        toolCallId: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.THINKING_TEXT_MESSAGE_START;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.THINKING_TEXT_MESSAGE_CONTENT;
+        delta: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.THINKING_TEXT_MESSAGE_END;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.TOOL_CALL_RESULT;
+        content: string;
+        toolCallId: string;
+        messageId: string;
+        role?: "tool" | undefined;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.THINKING_START;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+        title?: string | undefined;
+    } | {
+        type: EventType.THINKING_END;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.STATE_SNAPSHOT;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+        snapshot?: any;
+    } | {
+        type: EventType.STATE_DELTA;
+        delta: any[];
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.MESSAGES_SNAPSHOT;
+        messages: ({
+            id: string;
+            role: "developer";
+            content: string;
+            name?: string | undefined;
+        } | {
+            id: string;
+            role: "system";
+            content: string;
+            name?: string | undefined;
+        } | {
+            id: string;
+            role: "assistant";
+            name?: string | undefined;
+            content?: string | undefined;
+            toolCalls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        } | {
+            id: string;
+            role: "user";
+            content: string;
+            name?: string | undefined;
+        } | {
+            id: string;
+            role: "tool";
+            content: string;
+            toolCallId: string;
+            error?: string | undefined;
+        })[];
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.RAW;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+        event?: any;
+        source?: string | undefined;
+    } | {
+        name: string;
+        type: EventType.CUSTOM;
+        value?: any;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.RUN_STARTED;
+        threadId: string;
+        runId: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.RUN_FINISHED;
+        threadId: string;
+        runId: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+        result?: any;
+    } | {
+        message: string;
+        type: EventType.RUN_ERROR;
+        code?: string | undefined;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.STEP_STARTED;
+        stepName: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.STEP_FINISHED;
+        stepName: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType;
+        name: string;
+        value: any;
+    }>;
+    langGraphDefaultMergeState(state: State, messages: Message[], input: RunAgentInput): State<StateEnrichment & CopilotKitStateEnrichment>;
+    getSchemaKeys(): Promise<SchemaKeys>;
+}
+
+export { CustomEventNames, LangGraphAgent, PredictStateTool, TextMessageEvents, ToolCallEvents };