@copilotkit/runtime 1.50.0-beta.9 → 1.50.0

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.d.ts

@@ -9,7 +9,7 @@ import Anthropic from '@anthropic-ai/sdk';
 import * as graphql from 'graphql';
 import * as pino from 'pino';
 import { YogaInitialContext, createYoga } from 'graphql-yoga';
-import { CopilotRuntimeOptions, CopilotRuntime as CopilotRuntime$1 } from '@copilotkitnext/runtime';
+import { CopilotRuntimeOptions, CopilotRuntime as CopilotRuntime$1, AgentRunner } from '@copilotkitnext/runtime';
 import { AbstractAgent } from '@ag-ui/client';
 import * as http from 'http';
 import { ServerResponse, IncomingMessage } from 'http';
@@ -1370,31 +1370,90 @@ declare function copilotRuntimeNestEndpoint(options: CreateCopilotRuntimeServerO
 }, res: http.ServerResponse) => Promise<void>;
 
 /**
- * @deprecated LangGraphAgent import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead
+ * TelemetryAgentRunner - A wrapper around AgentRunner that adds telemetry
+ * for agent execution streams.
+ *
+ * This captures the following telemetry events:
+ * - oss.runtime.agent_execution_stream_started - when an agent execution starts
+ * - oss.runtime.agent_execution_stream_ended - when an agent execution completes
+ * - oss.runtime.agent_execution_stream_errored - when an agent execution fails
+ */
+
+/**
+ * Configuration options for TelemetryAgentRunner
+ */
+interface TelemetryAgentRunnerConfig {
+    /**
+     * The underlying runner to delegate to
+     * If not provided, defaults to InMemoryAgentRunner
+     */
+    runner?: AgentRunner;
+    /**
+     * Optional LangSmith API key (will be hashed for telemetry)
+     */
+    langsmithApiKey?: string;
+}
+/**
+ * An AgentRunner wrapper that adds telemetry tracking for agent executions.
+ *
+ * Usage:
+ * ```ts
+ * const runtime = new CopilotRuntime({
+ *   runner: new TelemetryAgentRunner(),
+ *   // or with custom runner:
+ *   runner: new TelemetryAgentRunner({ runner: customRunner }),
+ * });
+ * ```
+ */
+declare class TelemetryAgentRunner implements AgentRunner {
+    private readonly _runner;
+    private readonly hashedLgcKey;
+    constructor(config?: TelemetryAgentRunnerConfig);
+    /**
+     * Runs an agent with telemetry tracking.
+     * Wraps the underlying runner's Observable stream with telemetry events.
+     */
+    run(...args: Parameters<AgentRunner["run"]>): ReturnType<AgentRunner["run"]>;
+    /**
+     * Delegates to the underlying runner's connect method
+     */
+    connect(...args: Parameters<AgentRunner["connect"]>): ReturnType<AgentRunner["connect"]>;
+    /**
+     * Delegates to the underlying runner's isRunning method
+     */
+    isRunning(...args: Parameters<AgentRunner["isRunning"]>): ReturnType<AgentRunner["isRunning"]>;
+    /**
+     * Delegates to the underlying runner's stop method
+     */
+    stop(...args: Parameters<AgentRunner["stop"]>): ReturnType<AgentRunner["stop"]>;
+}
+
+/**
+ * @deprecated LangGraphAgent import from `@copilotkit/runtime` is deprecated. Please import it from `@copilotkit/runtime/langgraph` instead
  */
 declare class LangGraphAgent {
     constructor();
 }
 /**
- * @deprecated LangGraphHttpAgent import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead
+ * @deprecated LangGraphHttpAgent import from `@copilotkit/runtime` is deprecated. Please import it from `@copilotkit/runtime/langgraph` instead
  */
 declare class LangGraphHttpAgent {
     constructor();
 }
 /**
- * @deprecated TextMessageEvents import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead
+ * @deprecated TextMessageEvents import from `@copilotkit/runtime` is deprecated. Please import it from `@copilotkit/runtime/langgraph` instead
  */
 type TextMessageEvents = any;
 /**
- * @deprecated ToolCallEvents import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead
+ * @deprecated ToolCallEvents import from `@copilotkit/runtime` is deprecated. Please import it from `@copilotkit/runtime/langgraph` instead
  */
 type ToolCallEvents = any;
 /**
- * @deprecated CustomEventNames import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead
+ * @deprecated CustomEventNames import from `@copilotkit/runtime` is deprecated. Please import it from `@copilotkit/runtime/langgraph` instead
  */
 type CustomEventNames = any;
 /**
- * @deprecated PredictStateTool import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead
+ * @deprecated PredictStateTool import from `@copilotkit/runtime` is deprecated. Please import it from `@copilotkit/runtime/langgraph` instead
  */
 type PredictStateTool = any;
 
@@ -1443,4 +1502,4 @@ declare class UnknownErrorResponse extends FailedResponseStatus {
     });
 }
 
-export { AnthropicAdapter, AnthropicAdapterParams, AnthropicPromptCachingConfig, BedrockAdapter, BedrockAdapterParams, CommonConfig, CopilotRequestContextProperties, CopilotRuntime, CopilotRuntimeChatCompletionRequest, CopilotRuntimeChatCompletionResponse, CopilotRuntimeConstructorParams_BASE, CopilotRuntimeLogger, CopilotServiceAdapter, CreateCopilotRuntimeServerOptions, CustomEventNames, EmptyAdapter, ExperimentalEmptyAdapter, ExperimentalOllamaAdapter, GoogleGenerativeAIAdapter, GraphQLContext, GroqAdapter, GroqAdapterParams, GuardrailsValidationFailureResponse, LangChainAdapter, LangGraphAgent, LangGraphHttpAgent, LogLevel, MCPClient, MCPEndpointConfig, MCPTool, MessageStreamInterruptedResponse, OpenAIAdapter, OpenAIAdapterParams, OpenAIAssistantAdapter, OpenAIAssistantAdapterParams, PredictStateTool, RemoteChain, RemoteChainParameters, TextMessageEvents, ToolCallEvents, UnifyAdapter, UnifyAdapterParams, UnknownErrorResponse, addCustomHeaderPlugin, buildSchema, config, convertMCPToolsToActions, convertServiceAdapterError, copilotKitEndpoint, copilotRuntimeNestEndpoint, copilotRuntimeNextJSAppRouterEndpoint, copilotRuntimeNextJSPagesRouterEndpoint, copilotRuntimeNodeExpressEndpoint, copilotRuntimeNodeHttpEndpoint, createContext, createLogger, extractParametersFromSchema, generateMcpToolInstructions, getCommonConfig, langGraphPlatformEndpoint, readableStreamToNodeStream, resolveEndpointType };
+export { AnthropicAdapter, AnthropicAdapterParams, AnthropicPromptCachingConfig, BedrockAdapter, BedrockAdapterParams, CommonConfig, CopilotRequestContextProperties, CopilotRuntime, CopilotRuntimeChatCompletionRequest, CopilotRuntimeChatCompletionResponse, CopilotRuntimeConstructorParams_BASE, CopilotRuntimeLogger, CopilotServiceAdapter, CreateCopilotRuntimeServerOptions, CustomEventNames, EmptyAdapter, ExperimentalEmptyAdapter, ExperimentalOllamaAdapter, GoogleGenerativeAIAdapter, GraphQLContext, GroqAdapter, GroqAdapterParams, GuardrailsValidationFailureResponse, LangChainAdapter, LangGraphAgent, LangGraphHttpAgent, LogLevel, MCPClient, MCPEndpointConfig, MCPTool, MessageStreamInterruptedResponse, OpenAIAdapter, OpenAIAdapterParams, OpenAIAssistantAdapter, OpenAIAssistantAdapterParams, PredictStateTool, RemoteChain, RemoteChainParameters, TelemetryAgentRunner, TelemetryAgentRunnerConfig, TextMessageEvents, ToolCallEvents, UnifyAdapter, UnifyAdapterParams, UnknownErrorResponse, addCustomHeaderPlugin, buildSchema, config, convertMCPToolsToActions, convertServiceAdapterError, copilotKitEndpoint, copilotRuntimeNestEndpoint, copilotRuntimeNextJSAppRouterEndpoint, copilotRuntimeNextJSPagesRouterEndpoint, copilotRuntimeNodeExpressEndpoint, copilotRuntimeNodeHttpEndpoint, createContext, createLogger, extractParametersFromSchema, generateMcpToolInstructions, getCommonConfig, langGraphPlatformEndpoint, readableStreamToNodeStream, resolveEndpointType };