@copilotkit/runtime 1.5.9 → 1.5.10-next.0

package/dist/index.mjs

@@ -0,0 +1,76 @@
+import "./chunk-DFOKBSIS.mjs";
+import {
+  config,
+  copilotRuntimeNextJSAppRouterEndpoint,
+  copilotRuntimeNextJSPagesRouterEndpoint
+} from "./chunk-YTXDY7ZM.mjs";
+import {
+  copilotRuntimeNestEndpoint
+} from "./chunk-T4EYPND5.mjs";
+import {
+  copilotRuntimeNodeExpressEndpoint
+} from "./chunk-OZLXON7T.mjs";
+import {
+  CopilotRuntime,
+  buildSchema,
+  copilotKitEndpoint,
+  copilotRuntimeNodeHttpEndpoint,
+  createContext,
+  flattenToolCallsNoDuplicates,
+  getCommonConfig,
+  langGraphPlatformEndpoint,
+  resolveEndpointType
+} from "./chunk-5SDH2PVU.mjs";
+import {
+  AnthropicAdapter,
+  ExperimentalEmptyAdapter,
+  ExperimentalOllamaAdapter,
+  GoogleGenerativeAIAdapter,
+  GroqAdapter,
+  LangChainAdapter,
+  OpenAIAdapter,
+  OpenAIAssistantAdapter,
+  RemoteChain,
+  UnifyAdapter
+} from "./chunk-CLGKEUOA.mjs";
+import {
+  GuardrailsValidationFailureResponse,
+  MessageStreamInterruptedResponse,
+  UnknownErrorResponse
+} from "./chunk-U3V2BCGI.mjs";
+import "./chunk-RFF5IIZJ.mjs";
+import "./chunk-D2WLFQS6.mjs";
+import "./chunk-44O2JGUY.mjs";
+
+// src/index.ts
+import "reflect-metadata";
+export {
+  AnthropicAdapter,
+  CopilotRuntime,
+  ExperimentalEmptyAdapter,
+  ExperimentalOllamaAdapter,
+  GoogleGenerativeAIAdapter,
+  GroqAdapter,
+  GuardrailsValidationFailureResponse,
+  LangChainAdapter,
+  MessageStreamInterruptedResponse,
+  OpenAIAdapter,
+  OpenAIAssistantAdapter,
+  RemoteChain,
+  UnifyAdapter,
+  UnknownErrorResponse,
+  buildSchema,
+  config,
+  copilotKitEndpoint,
+  copilotRuntimeNestEndpoint,
+  copilotRuntimeNextJSAppRouterEndpoint,
+  copilotRuntimeNextJSPagesRouterEndpoint,
+  copilotRuntimeNodeExpressEndpoint,
+  copilotRuntimeNodeHttpEndpoint,
+  createContext,
+  flattenToolCallsNoDuplicates,
+  getCommonConfig,
+  langGraphPlatformEndpoint,
+  resolveEndpointType
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import \"reflect-metadata\";\nexport * from \"./lib\";\nexport * from \"./utils\";\nexport * from \"./service-adapters\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO;","names":[]}

package/dist/langserve-9125a12e.d.ts

@@ -0,0 +1,176 @@
+import { A as ActionInputAvailability, M as Message } from './index-cc2b17be.js';
+import * as rxjs from 'rxjs';
+import { Subject, ReplaySubject } from 'rxjs';
+import { Action, Parameter } from '@copilotkit/shared';
+
+declare enum GuardrailsResultStatus {
+    ALLOWED = "allowed",
+    DENIED = "denied"
+}
+declare class GuardrailsResult {
+    status: GuardrailsResultStatus;
+    reason?: string;
+}
+
+declare class ActionInput {
+    name: string;
+    description: string;
+    jsonSchema: string;
+    available?: ActionInputAvailability;
+}
+
+declare enum RuntimeEventTypes {
+    TextMessageStart = "TextMessageStart",
+    TextMessageContent = "TextMessageContent",
+    TextMessageEnd = "TextMessageEnd",
+    ActionExecutionStart = "ActionExecutionStart",
+    ActionExecutionArgs = "ActionExecutionArgs",
+    ActionExecutionEnd = "ActionExecutionEnd",
+    ActionExecutionResult = "ActionExecutionResult",
+    AgentStateMessage = "AgentStateMessage"
+}
+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;
+};
+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, }: {
+        actionExecutionId: string;
+        actionName: string;
+        result: 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;
+    stream(callback: EventSourceCallback): Promise<void>;
+    sendErrorMessageToChat(message?: string): void;
+    processRuntimeEvents({ serverSideActions, guardrailsResult$, actionInputsWithoutAgents, }: {
+        serverSideActions: Action<any>[];
+        guardrailsResult$?: Subject<GuardrailsResult>;
+        actionInputsWithoutAgents: ActionInput[];
+    }): rxjs.Observable<RuntimeEvent>;
+}
+
+declare class ForwardedParametersInput {
+    model?: string;
+    maxTokens?: number;
+    stop?: string[];
+    toolChoice?: String;
+    toolChoiceFunctionName?: string;
+    temperature?: number;
+}
+
+interface CopilotRuntimeChatCompletionRequest {
+    eventSource: RuntimeEventSource;
+    messages: Message[];
+    actions: ActionInput[];
+    model?: string;
+    threadId?: string;
+    runId?: string;
+    forwardedParameters?: ForwardedParametersInput;
+}
+interface CopilotRuntimeChatCompletionResponse {
+    threadId: string;
+    runId?: string;
+}
+interface CopilotServiceAdapter {
+    process(request: CopilotRuntimeChatCompletionRequest): Promise<CopilotRuntimeChatCompletionResponse>;
+}
+
+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, ForwardedParametersInput as F, RemoteChainParameters as R, CopilotRuntimeChatCompletionResponse as a, CopilotServiceAdapter as b, RemoteChain as c, RuntimeEventSource as d };

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,20 @@
+export { h as CommonConfig, b as CopilotRequestContextProperties, a as CopilotRuntime, C as CopilotRuntimeConstructorParams, d as CreateCopilotRuntimeServerOptions, G as GraphQLContext, g as buildSchema, c as copilotKitEndpoint, e as createContext, f as flattenToolCallsNoDuplicates, i as getCommonConfig, l as langGraphPlatformEndpoint, r as resolveEndpointType } from '../copilot-runtime-36700e00.js';
+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-696b5d29.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 '@copilotkit/shared';
+import '../langserve-9125a12e.js';
+import '../index-cc2b17be.js';
+import '../graphql/types/base/index.js';
+import 'rxjs';
+import 'graphql';
+import 'pino';
+import 'graphql-yoga';
+import './cloud/index.js';
+import 'openai';
+import '@langchain/core/messages';
+import '@langchain/core/tools';
+import '@langchain/core/utils/stream';
+import 'groq-sdk';