@copilotkit/runtime 1.57.3 → 1.58.0-canary.thread-id-propagation

package/src/service-adapters/openai/utils.ts

@@ -1,305 +0,0 @@
-import type OpenAI from "openai";
-import { Message } from "../../graphql/types/converted";
-import { ActionInput } from "../../graphql/inputs/action.input";
-import {
-  ChatCompletionAssistantMessageParam,
-  ChatCompletionMessageParam,
-  ChatCompletionSystemMessageParam,
-  ChatCompletionTool,
-  ChatCompletionUserMessageParam,
-  ChatCompletionDeveloperMessageParam,
-} from "openai/resources/chat";
-import { parseJson } from "@copilotkit/shared";
-
-/**
- * OpenAI v4 exposes streaming completions under `beta.chat.completions`.
- * v5 removed `beta.chat` and promoted streaming to `chat.completions`.
- * These interfaces model the v4-specific shape so we can detect and access
- * the beta namespace safely without `as any`.
- */
-interface OpenAIV4BetaChat {
-  chat: {
-    completions: OpenAI["chat"]["completions"];
-  };
-}
-
-interface OpenAIV4Beta extends OpenAI.Beta {
-  chat: OpenAIV4BetaChat["chat"];
-}
-
-/**
- * Type guard: checks whether the OpenAI client has the v4-era `beta.chat`
- * namespace. Returns `false` for v5+ clients where `beta.chat` was removed.
- */
-function hasV4BetaChat(beta: OpenAI["beta"] | undefined): beta is OpenAIV4Beta {
-  return beta != null && "chat" in beta && (beta as OpenAIV4Beta).chat != null;
-}
-
-/**
- * Detects whether the provided OpenAI client is v5+ by checking for the
- * removal of the `beta.chat` namespace (which was promoted to `chat` in v5).
- */
-export function isOpenAIV5(openai: OpenAI): boolean {
-  return !hasV4BetaChat(openai.beta);
-}
-
-/**
- * Returns the chat completions object that supports `.stream()`.
- * In v4 this lives under `openai.beta.chat.completions`;
- * in v5 it was promoted to `openai.chat.completions`.
- */
-export function getChatCompletionsForStreaming(
-  openai: OpenAI,
-): OpenAI["chat"]["completions"] {
-  if (hasV4BetaChat(openai.beta)) {
-    return openai.beta.chat.completions;
-  }
-  return openai.chat.completions;
-}
-
-/**
- * Retrieves a thread run, handling the v4→v5 API signature change.
- * v4: retrieve(threadId, runId)
- * v5: retrieve(runId, { thread_id: threadId })
- */
-export async function retrieveThreadRun(
-  openai: OpenAI,
-  threadId: string,
-  runId: string,
-): Promise<OpenAI.Beta.Threads.Runs.Run> {
-  if (isOpenAIV5(openai)) {
-    // v5 switched to named path params. The type definitions from whichever
-    // SDK version is installed won't match both signatures, so we call through
-    // a generic function reference. This is the one unavoidable boundary
-    // between two incompatible SDK type surfaces.
-    const retrieve = openai.beta.threads.runs.retrieve as {
-      (...args: unknown[]): Promise<OpenAI.Beta.Threads.Runs.Run>;
-    };
-    return retrieve(runId, { thread_id: threadId });
-  }
-  return openai.beta.threads.runs.retrieve(threadId, runId);
-}
-
-/**
- * Submits tool outputs as a stream, handling the v4→v5 API signature change.
- * v4: submitToolOutputsStream(threadId, runId, body)
- * v5: submitToolOutputsStream(runId, { thread_id, ...body })
- */
-export function submitToolOutputsStream(
-  openai: OpenAI,
-  threadId: string,
-  runId: string,
-  body: {
-    tool_outputs: Array<{ tool_call_id: string; output: string }>;
-    parallel_tool_calls?: false;
-  },
-) {
-  if (isOpenAIV5(openai)) {
-    // Same boundary as retrieveThreadRun — v5 uses named path params.
-    const submit = openai.beta.threads.runs.submitToolOutputsStream as {
-      (
-        ...args: unknown[]
-      ): ReturnType<typeof openai.beta.threads.runs.submitToolOutputsStream>;
-    };
-    return submit(runId, { thread_id: threadId, ...body });
-  }
-  return openai.beta.threads.runs.submitToolOutputsStream(
-    threadId,
-    runId,
-    body,
-  );
-}
-
-export function limitMessagesToTokenCount(
-  messages: any[],
-  tools: any[],
-  model: string,
-  maxTokens?: number,
-): any[] {
-  maxTokens ||= maxTokensForOpenAIModel(model);
-
-  const result: any[] = [];
-  const toolsNumTokens = countToolsTokens(model, tools);
-  if (toolsNumTokens > maxTokens) {
-    throw new Error(
-      `Too many tokens in function definitions: ${toolsNumTokens} > ${maxTokens}`,
-    );
-  }
-  maxTokens -= toolsNumTokens;
-
-  for (const message of messages) {
-    if (["system", "developer"].includes(message.role)) {
-      const numTokens = countMessageTokens(model, message);
-      maxTokens -= numTokens;
-
-      if (maxTokens < 0) {
-        throw new Error("Not enough tokens for system message.");
-      }
-    }
-  }
-
-  let cutoff: boolean = false;
-
-  const reversedMessages = [...messages].toReversed();
-  for (const message of reversedMessages) {
-    if (["system", "developer"].includes(message.role)) {
-      result.unshift(message);
-      continue;
-    } else if (cutoff) {
-      continue;
-    }
-    let numTokens = countMessageTokens(model, message);
-    if (maxTokens < numTokens) {
-      cutoff = true;
-      continue;
-    }
-    result.unshift(message);
-    maxTokens -= numTokens;
-  }
-
-  return result;
-}
-
-export function maxTokensForOpenAIModel(model: string): number {
-  return maxTokensByModel[model] || DEFAULT_MAX_TOKENS;
-}
-
-const DEFAULT_MAX_TOKENS = 128000;
-
-const maxTokensByModel: { [key: string]: number } = {
-  // o1
-  o1: 200000,
-  "o1-2024-12-17": 200000,
-  "o1-mini": 128000,
-  "o1-mini-2024-09-12": 128000,
-  "o1-preview": 128000,
-  "o1-preview-2024-09-12": 128000,
-  // o3-mini
-  "o3-mini": 200000,
-  "o3-mini-2025-01-31": 200000,
-  // GPT-4
-  "gpt-4o": 128000,
-  "chatgpt-4o-latest": 128000,
-  "gpt-4o-2024-08-06": 128000,
-  "gpt-4o-2024-05-13": 128000,
-  "gpt-4o-mini": 128000,
-  "gpt-4o-mini-2024-07-18": 128000,
-  "gpt-4-turbo": 128000,
-  "gpt-4-turbo-2024-04-09": 128000,
-  "gpt-4-0125-preview": 128000,
-  "gpt-4-turbo-preview": 128000,
-  "gpt-4-1106-preview": 128000,
-  "gpt-4-vision-preview": 128000,
-  "gpt-4-1106-vision-preview": 128000,
-  "gpt-4-32k": 32768,
-  "gpt-4-32k-0613": 32768,
-  "gpt-4-32k-0314": 32768,
-  "gpt-4": 8192,
-  "gpt-4-0613": 8192,
-  "gpt-4-0314": 8192,
-
-  // GPT-3.5
-  "gpt-3.5-turbo-0125": 16385,
-  "gpt-3.5-turbo": 16385,
-  "gpt-3.5-turbo-1106": 16385,
-  "gpt-3.5-turbo-instruct": 4096,
-  "gpt-3.5-turbo-16k": 16385,
-  "gpt-3.5-turbo-0613": 4096,
-  "gpt-3.5-turbo-16k-0613": 16385,
-  "gpt-3.5-turbo-0301": 4097,
-};
-
-function countToolsTokens(model: string, tools: any[]): number {
-  if (tools.length === 0) {
-    return 0;
-  }
-  const json = JSON.stringify(tools);
-  return countTokens(model, json);
-}
-
-function countMessageTokens(model: string, message: any): number {
-  return countTokens(model, message.content || "");
-}
-
-function countTokens(model: string, text: string): number {
-  return text.length / 3;
-}
-
-export function convertActionInputToOpenAITool(
-  action: ActionInput,
-): ChatCompletionTool {
-  return {
-    type: "function",
-    function: {
-      name: action.name,
-      description: action.description,
-      parameters: parseJson(action.jsonSchema, {}),
-    },
-  };
-}
-
-type UsedMessageParams =
-  | ChatCompletionUserMessageParam
-  | ChatCompletionAssistantMessageParam
-  | ChatCompletionDeveloperMessageParam
-  | ChatCompletionSystemMessageParam;
-export function convertMessageToOpenAIMessage(
-  message: Message,
-  options?: { keepSystemRole: boolean },
-): ChatCompletionMessageParam {
-  const { keepSystemRole } = options || { keepSystemRole: false };
-  if (message.isTextMessage()) {
-    let role = message.role as UsedMessageParams["role"];
-    if (message.role === "system" && !keepSystemRole) {
-      role = "developer";
-    }
-    return {
-      role,
-      content: message.content,
-    } satisfies UsedMessageParams;
-  } else if (message.isImageMessage()) {
-    return {
-      role: "user",
-      content: [
-        {
-          type: "image_url",
-          image_url: {
-            url: `data:image/${message.format};base64,${message.bytes}`,
-          },
-        },
-      ],
-    } satisfies UsedMessageParams;
-  } else if (message.isActionExecutionMessage()) {
-    return {
-      role: "assistant",
-      tool_calls: [
-        {
-          id: message.id,
-          type: "function",
-          function: {
-            name: message.name,
-            arguments: JSON.stringify(message.arguments),
-          },
-        },
-      ],
-    };
-  } else if (message.isResultMessage()) {
-    return {
-      role: "tool",
-      content: message.result,
-      tool_call_id: message.actionExecutionId,
-    };
-  }
-}
-
-export function convertSystemMessageToAssistantAPI(
-  message: ChatCompletionMessageParam,
-) {
-  return {
-    ...message,
-    ...(["system", "developer"].includes(message.role) && {
-      role: "assistant",
-      content: "THE FOLLOWING MESSAGE IS A SYSTEM MESSAGE: " + message.content,
-    }),
-  };
-}

package/src/service-adapters/service-adapter.ts

@@ -1,50 +0,0 @@
-import type { LanguageModel } from "ai";
-import { Message } from "../graphql/types/converted";
-import { RuntimeEventSource } from "./events";
-import { ActionInput } from "../graphql/inputs/action.input";
-import { ForwardedParametersInput } from "../graphql/inputs/forwarded-parameters.input";
-import { ExtensionsInput } from "../graphql/inputs/extensions.input";
-import { ExtensionsResponse } from "../graphql/types/extensions-response.type";
-import { AgentSessionInput } from "../graphql/inputs/agent-session.input";
-import { AgentStateInput } from "../graphql/inputs/agent-state.input";
-
-export interface CopilotKitResponse {
-  stream: ReadableStream;
-  headers?: Record<string, string>;
-}
-
-export interface CopilotRuntimeChatCompletionRequest {
-  eventSource: RuntimeEventSource;
-  messages: Message[];
-  actions: ActionInput[];
-  model?: string;
-  threadId?: string;
-  runId?: string;
-  forwardedParameters?: ForwardedParametersInput;
-  extensions?: ExtensionsInput;
-  agentSession?: AgentSessionInput;
-  agentStates?: AgentStateInput[];
-}
-
-export interface CopilotRuntimeChatCompletionResponse {
-  threadId: string;
-  runId?: string;
-  extensions?: ExtensionsResponse;
-}
-
-export interface CopilotServiceAdapter {
-  provider?: string;
-  model?: string;
-  process(
-    request: CopilotRuntimeChatCompletionRequest,
-  ): Promise<CopilotRuntimeChatCompletionResponse>;
-  name?: string;
-
-  /**
-   * Returns a pre-configured LanguageModel for use with BuiltInAgent.
-   * Adapters that support custom provider configurations (e.g., Azure OpenAI
-   * with custom baseURL/apiKey) should implement this to ensure the
-   * configuration is propagated to the agent layer.
-   */
-  getLanguageModel?(): LanguageModel;
-}

package/src/service-adapters/shared/error-utils.ts

@@ -1,64 +0,0 @@
-import {
-  CopilotKitLowLevelError,
-  CopilotKitErrorCode,
-} from "@copilotkit/shared";
-
-/**
- * Converts service adapter errors to structured CopilotKitError format using HTTP status codes.
- * This provides consistent error classification across all service adapters.
- */
-export function convertServiceAdapterError(
-  error: any,
-  adapterName: string,
-): CopilotKitLowLevelError {
-  const errorName = error?.constructor?.name || error.name;
-  const errorMessage = error?.message || String(error);
-  const statusCode = error.status || error.statusCode || error.response?.status;
-  const responseData = error.error || error.response?.data || error.data;
-
-  // Create the base error with the constructor signature
-  const structuredError = new CopilotKitLowLevelError({
-    error: error instanceof Error ? error : new Error(errorMessage),
-    url: `${adapterName} service adapter`,
-    message: `${adapterName} API error: ${errorMessage}`,
-  });
-
-  // Add additional properties after construction
-  if (statusCode) {
-    (structuredError as any).statusCode = statusCode;
-  }
-  if (responseData) {
-    (structuredError as any).responseData = responseData;
-  }
-  if (errorName) {
-    (structuredError as any).originalErrorType = errorName;
-  }
-
-  // Classify error based on HTTP status codes (reliable and provider-agnostic)
-  let newCode: CopilotKitErrorCode;
-
-  if (statusCode === 401) {
-    // 401 = Authentication/API key issues
-    newCode = CopilotKitErrorCode.AUTHENTICATION_ERROR;
-  } else if (statusCode >= 400 && statusCode < 500) {
-    // 4xx = Client errors (bad request, invalid params, etc.) - these are configuration issues
-    newCode = CopilotKitErrorCode.CONFIGURATION_ERROR;
-  } else if (statusCode >= 500) {
-    // 5xx = Server errors - keep as NETWORK_ERROR since it's infrastructure related
-    newCode = CopilotKitErrorCode.NETWORK_ERROR;
-  } else if (statusCode) {
-    // Any other HTTP status with an error - likely configuration
-    newCode = CopilotKitErrorCode.CONFIGURATION_ERROR;
-  } else {
-    // No status code - likely a genuine network/connection error
-    newCode = CopilotKitErrorCode.NETWORK_ERROR;
-  }
-
-  // Update both the instance property and the extensions
-  (structuredError as any).code = newCode;
-  if ((structuredError as any).extensions) {
-    (structuredError as any).extensions.code = newCode;
-  }
-
-  return structuredError;
-}

package/src/service-adapters/shared/index.ts

@@ -1,2 +0,0 @@
-export * from "./error-utils";
-export * from "./sdk-client-utils";

package/src/service-adapters/shared/sdk-client-utils.ts

@@ -1,19 +0,0 @@
-/**
- * SDK clients (OpenAI, Anthropic, Groq) store constructor options like
- * `defaultHeaders` and `fetch` in a private/protected `_options` field
- * with no public accessor. This extracts them with a narrow type assertion.
- */
-export function getSdkClientOptions(client: object): {
-  defaultHeaders?: Record<string, string>;
-  fetch?: typeof globalThis.fetch;
-} {
-  const rec = client as Record<string, unknown>;
-  const options = rec._options;
-  if (options != null && typeof options === "object") {
-    return options as {
-      defaultHeaders?: Record<string, string>;
-      fetch?: typeof globalThis.fetch;
-    };
-  }
-  return {};
-}

package/src/service-adapters/unify/unify-adapter.ts

@@ -1,165 +0,0 @@
-/**
- * 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" }),
- * );
- * ```
- */
-import {
-  CopilotRuntimeChatCompletionRequest,
-  CopilotRuntimeChatCompletionResponse,
-  CopilotServiceAdapter,
-} from "../service-adapter";
-import { randomId, randomUUID } from "@copilotkit/shared";
-import {
-  convertActionInputToOpenAITool,
-  convertMessageToOpenAIMessage,
-} from "../openai/utils";
-
-export interface UnifyAdapterParams {
-  apiKey?: string;
-  model: string;
-}
-
-export class UnifyAdapter implements CopilotServiceAdapter {
-  private apiKey: string;
-  public model: string;
-  private start: boolean;
-  public provider = "unify";
-
-  public get name() {
-    return "UnifyAdapter";
-  }
-
-  constructor(options?: UnifyAdapterParams) {
-    if (options?.apiKey) {
-      this.apiKey = options.apiKey;
-    } else {
-      this.apiKey = "UNIFY_API_KEY";
-    }
-    this.model = options?.model;
-    this.start = true;
-  }
-
-  async process(
-    request: CopilotRuntimeChatCompletionRequest,
-  ): Promise<CopilotRuntimeChatCompletionResponse> {
-    const tools = request.actions.map(convertActionInputToOpenAITool);
-    // Lazy require for optional peer dependency
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const OpenAI = require("openai").default;
-    const openai = new OpenAI({
-      apiKey: this.apiKey,
-      baseURL: "https://api.unify.ai/v0/",
-    });
-    const forwardedParameters = request.forwardedParameters;
-
-    const messages = request.messages.map((m) =>
-      convertMessageToOpenAIMessage(m),
-    );
-
-    const stream = await openai.chat.completions.create({
-      model: this.model,
-      messages: messages,
-      stream: true,
-      ...(tools.length > 0 && { tools }),
-      ...(forwardedParameters?.temperature && {
-        temperature: forwardedParameters.temperature,
-      }),
-    });
-
-    let model = null;
-    let currentMessageId: string;
-    let currentToolCallId: string;
-    request.eventSource.stream(async (eventStream$) => {
-      let mode: "function" | "message" | null = null;
-      for await (const chunk of stream) {
-        if (this.start) {
-          model = chunk.model;
-          currentMessageId = randomId();
-          eventStream$.sendTextMessageStart({ messageId: currentMessageId });
-          eventStream$.sendTextMessageContent({
-            messageId: currentMessageId,
-            content: `Model used: ${model}\n`,
-          });
-          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
-          this.start = false;
-        }
-        const toolCall = chunk.choices[0].delta.tool_calls?.[0];
-        const content = chunk.choices[0].delta.content;
-
-        // When switching from message to function or vice versa,
-        // send the respective end event.
-        // If toolCall?.id is defined, it means a new tool call starts.
-        if (mode === "message" && toolCall?.id) {
-          mode = null;
-          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
-        } else if (
-          mode === "function" &&
-          (toolCall === undefined || toolCall?.id)
-        ) {
-          mode = null;
-          eventStream$.sendActionExecutionEnd({
-            actionExecutionId: currentToolCallId,
-          });
-        }
-
-        // If we send a new message type, send the appropriate start event.
-        if (mode === null) {
-          if (toolCall?.id) {
-            mode = "function";
-            currentToolCallId = toolCall!.id;
-            eventStream$.sendActionExecutionStart({
-              actionExecutionId: currentToolCallId,
-              actionName: toolCall!.function!.name,
-            });
-          } else if (content) {
-            mode = "message";
-            currentMessageId = chunk.id;
-            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
-          }
-        }
-
-        // send the content events
-        if (mode === "message" && content) {
-          eventStream$.sendTextMessageContent({
-            messageId: currentMessageId,
-            content: content,
-          });
-        } else if (mode === "function" && toolCall?.function?.arguments) {
-          eventStream$.sendActionExecutionArgs({
-            actionExecutionId: currentToolCallId,
-            args: toolCall.function.arguments,
-          });
-        }
-      }
-
-      // send the end events
-      if (mode === "message") {
-        eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
-      } else if (mode === "function") {
-        eventStream$.sendActionExecutionEnd({
-          actionExecutionId: currentToolCallId,
-        });
-      }
-
-      eventStream$.complete();
-    });
-
-    return {
-      threadId: request.threadId || randomUUID(),
-    };
-  }
-}

package/src/utils/failed-response-status-reasons.ts

@@ -1,70 +0,0 @@
-import {
-  FailedResponseStatus,
-  FailedResponseStatusReason,
-} from "../graphql/types/response-status.type";
-
-export class GuardrailsValidationFailureResponse extends FailedResponseStatus {
-  reason = FailedResponseStatusReason.GUARDRAILS_VALIDATION_FAILED;
-  declare details: {
-    guardrailsReason: string;
-  };
-
-  constructor({ guardrailsReason }) {
-    super();
-    this.details = {
-      guardrailsReason,
-    };
-  }
-}
-
-export class MessageStreamInterruptedResponse extends FailedResponseStatus {
-  reason = FailedResponseStatusReason.MESSAGE_STREAM_INTERRUPTED;
-  declare details: {
-    messageId: string;
-    description: string;
-  };
-
-  constructor({ messageId }: { messageId: string }) {
-    super();
-    this.details = {
-      messageId,
-      description: "Check the message for mode details",
-    };
-  }
-}
-
-export class UnknownErrorResponse extends FailedResponseStatus {
-  reason = FailedResponseStatusReason.UNKNOWN_ERROR;
-  declare details: {
-    description?: string;
-    originalError?: {
-      code?: string;
-      statusCode?: number;
-      severity?: string;
-      visibility?: string;
-      originalErrorType?: string;
-      extensions?: any;
-    };
-  };
-
-  constructor({
-    description,
-    originalError,
-  }: {
-    description?: string;
-    originalError?: {
-      code?: string;
-      statusCode?: number;
-      severity?: string;
-      visibility?: string;
-      originalErrorType?: string;
-      extensions?: any;
-    };
-  }) {
-    super();
-    this.details = {
-      description,
-      originalError,
-    };
-  }
-}

package/src/utils/index.ts

@@ -1 +0,0 @@
-export * from "./failed-response-status-reasons";

package/src/v2/express.ts

@@ -1 +0,0 @@
-export * from "./runtime/express";

package/src/v2/hono.ts

@@ -1 +0,0 @@
-export * from "./runtime/hono";

package/src/v2/index.ts

@@ -1,5 +0,0 @@
-// V2 runtime (moved from @copilotkit/runtime/v2)
-export * from "./runtime";
-
-// Agent (merged into runtime)
-export * from "../agent";

package/src/v2/node.ts

@@ -1 +0,0 @@
-export * from "./runtime/node";