@copilotkit/runtime 1.50.0-beta.10 → 1.50.0-beta.12

package/dist/groq-adapter-c8aec5c5.d.ts

@@ -0,0 +1,321 @@
+import OpenAI from 'openai';
+import { b as CopilotServiceAdapter, C as CopilotRuntimeChatCompletionRequest, a as CopilotRuntimeChatCompletionResponse } from './langserve-0c6100e3.js';
+import { BaseMessageChunk, AIMessage, AIMessageChunk, BaseMessage } from '@langchain/core/messages';
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { IterableReadableStream, IterableReadableStreamInterface } from '@langchain/core/utils/stream';
+import { Groq } from 'groq-sdk';
+
+/**
+ * Copilot Runtime adapter for OpenAI.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { CopilotRuntime, OpenAIAdapter } from "@copilotkit/runtime";
+ * import OpenAI from "openai";
+ *
+ * const copilotKit = new CopilotRuntime();
+ *
+ * const openai = new OpenAI({
+ *   organization: "<your-organization-id>", // optional
+ *   apiKey: "<your-api-key>",
+ * });
+ *
+ * return new OpenAIAdapter({ openai });
+ * ```
+ *
+ * ## Example with Azure OpenAI
+ *
+ * ```ts
+ * import { CopilotRuntime, OpenAIAdapter } from "@copilotkit/runtime";
+ * import OpenAI from "openai";
+ *
+ * // The name of your Azure OpenAI Instance.
+ * // https://learn.microsoft.com/en-us/azure/cognitive-services/openai/how-to/create-resource?pivots=web-portal#create-a-resource
+ * const instance = "<your instance name>";
+ *
+ * // Corresponds to your Model deployment within your OpenAI resource, e.g. my-gpt35-16k-deployment
+ * // Navigate to the Azure OpenAI Studio to deploy a model.
+ * const model = "<your model>";
+ *
+ * const apiKey = process.env["AZURE_OPENAI_API_KEY"];
+ * if (!apiKey) {
+ *   throw new Error("The AZURE_OPENAI_API_KEY environment variable is missing or empty.");
+ * }
+ *
+ * const copilotKit = new CopilotRuntime();
+ *
+ * const openai = new OpenAI({
+ *   apiKey,
+ *   baseURL: `https://${instance}.openai.azure.com/openai/deployments/${model}`,
+ *   defaultQuery: { "api-version": "2024-04-01-preview" },
+ *   defaultHeaders: { "api-key": apiKey },
+ * });
+ *
+ * return new OpenAIAdapter({ openai });
+ * ```
+ */
+
+interface OpenAIAdapterParams {
+    /**
+     * An optional OpenAI instance to use.  If not provided, a new instance will be
+     * created.
+     */
+    openai?: OpenAI;
+    /**
+     * The model to use.
+     */
+    model?: string;
+    /**
+     * Whether to disable parallel tool calls.
+     * You can disable parallel tool calls to force the model to execute tool calls sequentially.
+     * This is useful if you want to execute tool calls in a specific order so that the state changes
+     * introduced by one tool call are visible to the next tool call. (i.e. new actions or readables)
+     *
+     * @default false
+     */
+    disableParallelToolCalls?: boolean;
+    /**
+     * Whether to keep the role in system messages as "System".
+     * By default, it is converted to "developer", which is used by newer OpenAI models
+     *
+     * @default false
+     */
+    keepSystemRole?: boolean;
+}
+declare class OpenAIAdapter implements CopilotServiceAdapter {
+    private model;
+    private disableParallelToolCalls;
+    private _openai;
+    private keepSystemRole;
+    get openai(): OpenAI;
+    constructor(params?: OpenAIAdapterParams);
+    process(request: CopilotRuntimeChatCompletionRequest): Promise<CopilotRuntimeChatCompletionResponse>;
+}
+
+type LangChainBaseMessageChunkStream = IterableReadableStream<BaseMessageChunk>;
+type LangChainAIMessageChunkStream = IterableReadableStreamInterface<AIMessageChunk>;
+type LangChainReturnType = LangChainBaseMessageChunkStream | LangChainAIMessageChunkStream | BaseMessageChunk | string | AIMessage;
+
+/**
+ * Copilot Runtime adapter for LangChain.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { CopilotRuntime, LangChainAdapter } from "@copilotkit/runtime";
+ * import { ChatOpenAI } from "@langchain/openai";
+ *
+ * const copilotKit = new CopilotRuntime();
+ *
+ * const model = new ChatOpenAI({
+ *   model: "gpt-4o",
+ *   apiKey: "<your-api-key>",
+ * });
+ *
+ * return new LangChainAdapter({
+ *   chainFn: async ({ messages, tools }) => {
+ *     return model.bindTools(tools).stream(messages);
+ *     // or optionally enable strict mode
+ *     // return model.bindTools(tools, { strict: true }).stream(messages);
+ *   }
+ * });
+ * ```
+ *
+ * The asynchronous handler function (`chainFn`) can return any of the following:
+ *
+ * - A simple `string` response
+ * - A LangChain stream (`IterableReadableStream`)
+ * - A LangChain `BaseMessageChunk` object
+ * - A LangChain `AIMessage` object
+ */
+
+interface ChainFnParameters {
+    model: string;
+    messages: BaseMessage[];
+    tools: DynamicStructuredTool[];
+    threadId?: string;
+    runId?: string;
+}
+interface LangChainAdapterOptions {
+    /**
+     * A function that uses the LangChain API to generate a response.
+     */
+    chainFn: (parameters: ChainFnParameters) => Promise<LangChainReturnType>;
+}
+declare class LangChainAdapter implements CopilotServiceAdapter {
+    private options;
+    /**
+     * To use LangChain as a backend, provide a handler function to the adapter with your custom LangChain logic.
+     */
+    constructor(options: LangChainAdapterOptions);
+    process(request: CopilotRuntimeChatCompletionRequest): Promise<CopilotRuntimeChatCompletionResponse>;
+}
+
+interface GoogleGenerativeAIAdapterOptions {
+    /**
+     * A custom Google Generative AI model to use.
+     */
+    model?: string;
+    /**
+     * The API key to use.
+     */
+    apiKey?: string;
+}
+declare class GoogleGenerativeAIAdapter extends LangChainAdapter {
+    constructor(options?: GoogleGenerativeAIAdapterOptions);
+}
+
+/**
+ * Copilot Runtime adapter for the OpenAI Assistant API.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { CopilotRuntime, OpenAIAssistantAdapter } from "@copilotkit/runtime";
+ * import OpenAI from "openai";
+ *
+ * const copilotKit = new CopilotRuntime();
+ *
+ * const openai = new OpenAI({
+ *   organization: "<your-organization-id>",
+ *   apiKey: "<your-api-key>",
+ * });
+ *
+ * return new OpenAIAssistantAdapter({
+ *   openai,
+ *   assistantId: "<your-assistant-id>",
+ *   codeInterpreterEnabled: true,
+ *   fileSearchEnabled: true,
+ * });
+ * ```
+ */
+
+interface OpenAIAssistantAdapterParams {
+    /**
+     * The ID of the assistant to use.
+     */
+    assistantId: string;
+    /**
+     * An optional OpenAI instance to use. If not provided, a new instance will be created.
+     */
+    openai?: OpenAI;
+    /**
+     * Whether to enable code interpretation.
+     * @default true
+     */
+    codeInterpreterEnabled?: boolean;
+    /**
+     * Whether to enable file search.
+     * @default true
+     */
+    fileSearchEnabled?: boolean;
+    /**
+     * Whether to disable parallel tool calls.
+     * You can disable parallel tool calls to force the model to execute tool calls sequentially.
+     * This is useful if you want to execute tool calls in a specific order so that the state changes
+     * introduced by one tool call are visible to the next tool call. (i.e. new actions or readables)
+     *
+     * @default false
+     */
+    disableParallelToolCalls?: boolean;
+    /**
+     * Whether to keep the role in system messages as "System".
+     * By default, it is converted to "developer", which is used by newer OpenAI models
+     *
+     * @default false
+     */
+    keepSystemRole?: boolean;
+}
+declare class OpenAIAssistantAdapter implements CopilotServiceAdapter {
+    private openai;
+    private codeInterpreterEnabled;
+    private assistantId;
+    private fileSearchEnabled;
+    private disableParallelToolCalls;
+    private keepSystemRole;
+    constructor(params: OpenAIAssistantAdapterParams);
+    process(request: CopilotRuntimeChatCompletionRequest): Promise<CopilotRuntimeChatCompletionResponse>;
+    private submitToolOutputs;
+    private submitUserMessage;
+    private streamResponse;
+}
+
+/**
+ * CopilotKit Adapter for Unify
+ *
+ * <RequestExample>
+ * ```jsx CopilotRuntime Example
+ * const copilotKit = new CopilotRuntime();
+ * return copilotKit.response(req, new UnifyAdapter());
+ * ```
+ * </RequestExample>
+ *
+ * You can easily set the model to use by passing it to the constructor.
+ * ```jsx
+ * const copilotKit = new CopilotRuntime();
+ * return copilotKit.response(
+ *   req,
+ *   new UnifyAdapter({ model: "llama-3-8b-chat@fireworks-ai" }),
+ * );
+ * ```
+ */
+
+interface UnifyAdapterParams {
+    apiKey?: string;
+    model: string;
+}
+declare class UnifyAdapter implements CopilotServiceAdapter {
+    private apiKey;
+    private model;
+    private start;
+    constructor(options?: UnifyAdapterParams);
+    process(request: CopilotRuntimeChatCompletionRequest): Promise<CopilotRuntimeChatCompletionResponse>;
+}
+
+/**
+ * Copilot Runtime adapter for Groq.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { CopilotRuntime, GroqAdapter } from "@copilotkit/runtime";
+ * import { Groq } from "groq-sdk";
+ *
+ * const groq = new Groq({ apiKey: process.env["GROQ_API_KEY"] });
+ *
+ * const copilotKit = new CopilotRuntime();
+ *
+ * return new GroqAdapter({ groq, model: "<model-name>" });
+ * ```
+ */
+
+interface GroqAdapterParams {
+    /**
+     * An optional Groq instance to use.
+     */
+    groq?: Groq;
+    /**
+     * The model to use.
+     */
+    model?: string;
+    /**
+     * Whether to disable parallel tool calls.
+     * You can disable parallel tool calls to force the model to execute tool calls sequentially.
+     * This is useful if you want to execute tool calls in a specific order so that the state changes
+     * introduced by one tool call are visible to the next tool call. (i.e. new actions or readables)
+     *
+     * @default false
+     */
+    disableParallelToolCalls?: boolean;
+}
+declare class GroqAdapter implements CopilotServiceAdapter {
+    private model;
+    private disableParallelToolCalls;
+    private _groq;
+    get groq(): Groq;
+    constructor(params?: GroqAdapterParams);
+    process(request: CopilotRuntimeChatCompletionRequest): Promise<CopilotRuntimeChatCompletionResponse>;
+}
+
+export { GoogleGenerativeAIAdapter as G, LangChainAdapter as L, OpenAIAdapterParams as O, UnifyAdapterParams as U, OpenAIAdapter as a, OpenAIAssistantAdapterParams as b, OpenAIAssistantAdapter as c, UnifyAdapter as d, GroqAdapterParams as e, GroqAdapter as f };

package/dist/index-96b330da.d.ts

@@ -0,0 +1,119 @@
+import { BaseMessageInput } from './graphql/types/base/index.js';
+
+declare enum MessageRole {
+    user = "user",
+    assistant = "assistant",
+    system = "system",
+    tool = "tool",
+    developer = "developer"
+}
+declare enum ActionInputAvailability {
+    disabled = "disabled",
+    enabled = "enabled",
+    remote = "remote"
+}
+
+declare class MessageInput extends BaseMessageInput {
+    textMessage?: TextMessageInput;
+    actionExecutionMessage?: ActionExecutionMessageInput;
+    resultMessage?: ResultMessageInput;
+    agentStateMessage?: AgentStateMessageInput;
+    imageMessage?: ImageMessageInput;
+}
+declare class TextMessageInput {
+    content: string;
+    parentMessageId?: string;
+    role: MessageRole;
+}
+declare class ActionExecutionMessageInput {
+    name: string;
+    arguments: string;
+    parentMessageId?: string;
+    scope?: String;
+}
+declare class ResultMessageInput {
+    actionExecutionId: string;
+    actionName: string;
+    parentMessageId?: string;
+    result: string;
+}
+declare class AgentStateMessageInput {
+    threadId: string;
+    agentName: string;
+    role: MessageRole;
+    state: string;
+    running: boolean;
+    nodeName: string;
+    runId: string;
+    active: boolean;
+}
+declare class ImageMessageInput {
+    format: string;
+    bytes: string;
+    parentMessageId?: string;
+    role: MessageRole;
+}
+
+type MessageType = "TextMessage" | "ActionExecutionMessage" | "ResultMessage" | "AgentStateMessage" | "ImageMessage";
+declare class Message extends BaseMessageInput {
+    type: MessageType;
+    isTextMessage(): this is TextMessage;
+    isActionExecutionMessage(): this is ActionExecutionMessage;
+    isResultMessage(): this is ResultMessage;
+    isAgentStateMessage(): this is AgentStateMessage;
+    isImageMessage(): this is ImageMessage;
+}
+declare class TextMessage extends Message implements TextMessageInput {
+    type: MessageType;
+    content: string;
+    role: MessageRole;
+    parentMessageId?: string;
+}
+declare class ActionExecutionMessage extends Message implements Omit<ActionExecutionMessageInput, "arguments" | "scope"> {
+    type: MessageType;
+    name: string;
+    arguments: Record<string, any>;
+    parentMessageId?: string;
+}
+declare class ResultMessage extends Message implements ResultMessageInput {
+    type: MessageType;
+    actionExecutionId: string;
+    actionName: string;
+    result: string;
+    static encodeResult(result: any, error?: {
+        code: string;
+        message: string;
+    } | string | Error): string;
+    static decodeResult(result: string): {
+        error?: {
+            code: string;
+            message: string;
+        };
+        result: string;
+    };
+    hasError(): boolean;
+    getError(): {
+        code: string;
+        message: string;
+    } | undefined;
+}
+declare class AgentStateMessage extends Message implements Omit<AgentStateMessageInput, "state"> {
+    type: MessageType;
+    threadId: string;
+    agentName: string;
+    nodeName: string;
+    runId: string;
+    active: boolean;
+    role: MessageRole;
+    state: any;
+    running: boolean;
+}
+declare class ImageMessage extends Message implements ImageMessageInput {
+    type: MessageType;
+    format: string;
+    bytes: string;
+    role: MessageRole;
+    parentMessageId?: string;
+}
+
+export { ActionInputAvailability as A, ImageMessage as I, Message as M, ResultMessage as R, TextMessage as T, ActionExecutionMessage as a, MessageInput as b, MessageType as c, AgentStateMessage as d };

package/dist/index.js

@@ -72,7 +72,7 @@ var require_package = __commonJS({
       publishConfig: {
         access: "public"
       },
-      version: "1.50.0-beta.9",
+      version: "1.50.0-beta.12",
       sideEffects: false,
       main: "./dist/index.js",
       module: "./dist/index.mjs",
@@ -124,8 +124,8 @@ var require_package = __commonJS({
       },
       dependencies: {
         "@copilotkit/shared": "workspace:*",
-        "@copilotkitnext/agent": "0.0.28",
-        "@copilotkitnext/runtime": "0.0.28",
+        "@copilotkitnext/agent": "0.0.29",
+        "@copilotkitnext/runtime": "0.0.29",
         "@graphql-yoga/plugin-defer-stream": "^3.3.1",
         "@hono/node-server": "^1.13.5",
         "@langchain/core": "^0.3.38",
@@ -3469,14 +3469,16 @@ var CopilotRuntime = class {
   constructor(params) {
     const agents = (params == null ? void 0 : params.agents) ?? {};
     const endpointAgents = this.assignEndpointsToAgents((params == null ? void 0 : params.remoteEndpoints) ?? []);
+    const baseRunner = (params == null ? void 0 : params.runner) ?? new runtime.InMemoryAgentRunner();
+    const runner = shared.isTelemetryDisabled() ? baseRunner : new TelemetryAgentRunner({
+      runner: baseRunner
+    });
     this.runtimeArgs = {
       agents: {
         ...endpointAgents,
         ...agents
       },
-      // Use TelemetryAgentRunner by default to track agent execution telemetry
-      // Users can pass their own runner which will be wrapped for telemetry
-      runner: (params == null ? void 0 : params.runner) ?? new TelemetryAgentRunner(),
+      runner,
       // TODO: add support for transcriptionService from CopilotRuntimeOptionsVNext once it is ready
       // transcriptionService: params?.transcriptionService,
       beforeRequestMiddleware: this.createOnBeforeRequestHandler(params).bind(this),
@@ -3569,11 +3571,24 @@ var CopilotRuntime = class {
   }
   createOnBeforeRequestHandler(params) {
     return async (hookParams) => {
-      var _a, _b;
-      (_a = params == null ? void 0 : params.beforeRequestMiddleware) == null ? void 0 : _a.call(params, hookParams);
-      if ((_b = params == null ? void 0 : params.middleware) == null ? void 0 : _b.onBeforeRequest) {
-        const { request, runtime, path } = hookParams;
-        const body = await shared.readBody(request);
+      var _a, _b, _c, _d;
+      const { request } = hookParams;
+      const publicApiKey = request.headers.get("x-copilotcloud-public-api-key");
+      const body = await shared.readBody(request);
+      const forwardedProps = body.forwardedProps;
+      const cloudBaseUrl = process.env.COPILOT_CLOUD_BASE_URL || "https://api.cloud.copilotkit.ai";
+      telemetry_client_default.capture("oss.runtime.copilot_request_created", {
+        "cloud.guardrails.enabled": ((_a = forwardedProps == null ? void 0 : forwardedProps.cloud) == null ? void 0 : _a.guardrails) !== void 0,
+        requestType: ((_b = forwardedProps == null ? void 0 : forwardedProps.metadata) == null ? void 0 : _b.requestType) ?? "unknown",
+        "cloud.api_key_provided": !!publicApiKey,
+        ...publicApiKey ? {
+          "cloud.public_api_key": publicApiKey
+        } : {},
+        "cloud.base_url": cloudBaseUrl
+      });
+      (_c = params == null ? void 0 : params.beforeRequestMiddleware) == null ? void 0 : _c.call(params, hookParams);
+      if ((_d = params == null ? void 0 : params.middleware) == null ? void 0 : _d.onBeforeRequest) {
+        const { request: request2, runtime, path } = hookParams;
         const gqlMessages = aguiToGQL(body.messages).reduce((acc, msg) => {
           if ("role" in msg && msg.role === "user") {
             acc.inputMessages.push(msg);
@@ -3591,7 +3606,7 @@ var CopilotRuntime = class {
           runId: body.runId,
           inputMessages,
           properties: body.forwardedProps,
-          url: request.url
+          url: request2.url
         });
       }
     };