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

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

@@ -1,219 +0,0 @@
-import { Anthropic } from "@anthropic-ai/sdk";
-import { ActionInput } from "../../graphql/inputs/action.input";
-import { Message } from "../../graphql/types/converted";
-
-export function limitMessagesToTokenCount(
-  messages: any[],
-  tools: any[],
-  model: string,
-  maxTokens?: number,
-): any[] {
-  maxTokens ||= MAX_TOKENS;
-
-  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 (message.role === "system") {
-      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 (message.role === "system") {
-      result.unshift(message);
-      continue;
-    } else if (cutoff) {
-      continue;
-    }
-    let numTokens = countMessageTokens(model, message);
-    if (maxTokens < numTokens) {
-      cutoff = true;
-      continue;
-    }
-    result.unshift(message);
-    maxTokens -= numTokens;
-  }
-
-  // Post-process: remove orphaned tool_result and tool_use blocks.
-  // Token trimming may have removed the assistant message containing tool_use
-  // while keeping the user message with tool_result (or vice versa),
-  // which Anthropic rejects.
-
-  // Collect all tool_use IDs from assistant messages
-  const toolUseIds = new Set<string>();
-  for (const msg of result) {
-    if (msg.role === "assistant" && Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        if (block.type === "tool_use") {
-          toolUseIds.add(block.id);
-        }
-      }
-    }
-  }
-
-  // Collect all tool_result IDs from user messages
-  const toolResultIds = new Set<string>();
-  for (const msg of result) {
-    if (msg.role === "user" && Array.isArray(msg.content)) {
-      for (const block of msg.content) {
-        if (block.type === "tool_result") {
-          toolResultIds.add(block.tool_use_id);
-        }
-      }
-    }
-  }
-
-  // Filter orphaned blocks without mutating the original messages
-  const filtered: any[] = [];
-  for (const msg of result) {
-    if (msg.role === "user" && Array.isArray(msg.content)) {
-      const remaining = msg.content.filter(
-        (block: any) =>
-          block.type !== "tool_result" || toolUseIds.has(block.tool_use_id),
-      );
-      if (remaining.length === 0) continue;
-      if (remaining.length !== msg.content.length) {
-        filtered.push({ ...msg, content: remaining });
-      } else {
-        filtered.push(msg);
-      }
-    } else if (msg.role === "assistant" && Array.isArray(msg.content)) {
-      const remaining = msg.content.filter(
-        (block: any) =>
-          block.type !== "tool_use" || toolResultIds.has(block.id),
-      );
-      if (remaining.length === 0) continue;
-      if (remaining.length !== msg.content.length) {
-        filtered.push({ ...msg, content: remaining });
-      } else {
-        filtered.push(msg);
-      }
-    } else {
-      filtered.push(msg);
-    }
-  }
-
-  return filtered;
-}
-
-const MAX_TOKENS = 128000;
-
-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, JSON.stringify(message.content) || "");
-}
-
-function countTokens(model: string, text: string): number {
-  return text.length / 3;
-}
-
-export function convertActionInputToAnthropicTool(
-  action: ActionInput,
-): Anthropic.Messages.Tool {
-  return {
-    name: action.name,
-    description: action.description,
-    input_schema: JSON.parse(action.jsonSchema),
-  };
-}
-
-export function convertMessageToAnthropicMessage(
-  message: Message,
-): Anthropic.Messages.MessageParam {
-  if (message.isTextMessage()) {
-    if (message.role === "system") {
-      return {
-        role: "assistant",
-        content: [
-          {
-            type: "text",
-            text:
-              "THE FOLLOWING MESSAGE IS A SYSTEM MESSAGE: " + message.content,
-          },
-        ],
-      };
-    } else {
-      return {
-        role: message.role === "user" ? "user" : "assistant",
-        content: [{ type: "text", text: message.content }],
-      };
-    }
-  } else if (message.isImageMessage()) {
-    let mediaType: "image/jpeg" | "image/png" | "image/webp" | "image/gif";
-    switch (message.format) {
-      case "jpeg":
-        mediaType = "image/jpeg";
-        break;
-      case "png":
-        mediaType = "image/png";
-        break;
-      case "webp":
-        mediaType = "image/webp";
-        break;
-      case "gif":
-        mediaType = "image/gif";
-        break;
-      default:
-        throw new Error(`Unsupported image format: ${message.format}`);
-    }
-
-    return {
-      role: "user",
-      content: [
-        {
-          type: "image",
-          source: {
-            type: "base64",
-            media_type: mediaType,
-            data: message.bytes,
-          },
-        },
-      ],
-    };
-  } else if (message.isActionExecutionMessage()) {
-    return {
-      role: "assistant",
-      content: [
-        {
-          id: message.id,
-          type: "tool_use",
-          input: message.arguments,
-          name: message.name,
-        },
-      ],
-    };
-  } else if (message.isResultMessage()) {
-    return {
-      role: "user",
-      content: [
-        {
-          type: "tool_result",
-          content: message.result || "Action completed successfully",
-          tool_use_id: message.actionExecutionId,
-        },
-      ],
-    };
-  }
-}

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

@@ -1,73 +0,0 @@
-/**
- * Copilot Runtime adapter for AWS Bedrock.
- *
- * ## Example
- *
- * ```ts
- * import { CopilotRuntime, BedrockAdapter } from "@copilotkit/runtime";
- *
- * const copilotKit = new CopilotRuntime();
- *
- * return new BedrockAdapter({
- *   model: "amazon.nova-lite-v1:0",
- *   region: "us-east-1",
- *   credentials: {
- *     accessKeyId: process.env.AWS_ACCESS_KEY_ID,
- *     secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
- *   }
- * });
- * ```
- */
-
-import { LangChainAdapter } from "../langchain/langchain-adapter";
-
-export interface BedrockAdapterParams {
-  /**
-   * AWS Bedrock model ID to use.
-   * @default "amazon.nova-lite-v1:0"
-   */
-  model?: string;
-
-  /**
-   * AWS region where Bedrock is available.
-   * @default "us-east-1"
-   */
-  region?: string;
-
-  /**
-   * AWS credentials for Bedrock access.
-   */
-  credentials?: {
-    accessKeyId?: string;
-    secretAccessKey?: string;
-  };
-}
-
-const DEFAULT_MODEL = "amazon.nova-lite-v1:0";
-
-export class BedrockAdapter extends LangChainAdapter {
-  public provider = "bedrock";
-  public model: string = DEFAULT_MODEL;
-  constructor(options?: BedrockAdapterParams) {
-    super({
-      chainFn: async ({ messages, tools, threadId }) => {
-        // Lazy require for optional peer dependency
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { ChatBedrockConverse } = require("@langchain/aws");
-
-        this.model = options?.model ?? "amazon.nova-lite-v1:0";
-        const model = new ChatBedrockConverse({
-          model: this.model,
-          region: options?.region ?? "us-east-1",
-          credentials: options?.credentials
-            ? {
-                accessKeyId: options.credentials.accessKeyId,
-                secretAccessKey: options.credentials.secretAccessKey,
-              }
-            : undefined,
-        }).bindTools(tools);
-        return model.stream(messages);
-      },
-    });
-  }
-}

package/src/service-adapters/conversion.test.ts

@@ -1,56 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-/**
- * safeParseToolArgs is a private (non-exported) function in conversion.ts.
- * We duplicate its logic here to unit-test the algorithm in isolation.
- * This mirrors the shared safeParseToolArgs in @copilotkit/shared.
- */
-function safeParseToolArgs(raw: string): Record<string, unknown> {
-  try {
-    const parsed = JSON.parse(raw);
-    if (
-      typeof parsed === "object" &&
-      parsed !== null &&
-      !Array.isArray(parsed)
-    ) {
-      return parsed as Record<string, unknown>;
-    }
-    return {};
-  } catch {
-    return {};
-  }
-}
-
-describe("safeParseToolArgs (v1 conversion)", () => {
-  it("parses a valid JSON object string", () => {
-    expect(safeParseToolArgs('{"key": "value"}')).toEqual({ key: "value" });
-  });
-
-  it("returns {} for a JSON string value", () => {
-    expect(safeParseToolArgs('"hello"')).toEqual({});
-  });
-
-  it("returns {} for a JSON number", () => {
-    expect(safeParseToolArgs("42")).toEqual({});
-  });
-
-  it("returns {} for a JSON array", () => {
-    expect(safeParseToolArgs("[1, 2, 3]")).toEqual({});
-  });
-
-  it("returns {} for malformed JSON", () => {
-    expect(safeParseToolArgs("{broken")).toEqual({});
-  });
-
-  it("returns {} for a JSON null", () => {
-    expect(safeParseToolArgs("null")).toEqual({});
-  });
-
-  it("returns {} for a JSON boolean", () => {
-    expect(safeParseToolArgs("true")).toEqual({});
-  });
-
-  it("returns {} for an empty string", () => {
-    expect(safeParseToolArgs("")).toEqual({});
-  });
-});

package/src/service-adapters/conversion.ts

@@ -1,69 +0,0 @@
-import {
-  ActionExecutionMessage,
-  Message,
-  ResultMessage,
-  TextMessage,
-  AgentStateMessage,
-  ImageMessage,
-} from "../graphql/types/converted";
-import { MessageInput } from "../graphql/inputs/message.input";
-import { plainToInstance } from "class-transformer";
-import { tryMap, safeParseToolArgs } from "@copilotkit/shared";
-
-export function convertGqlInputToMessages(
-  inputMessages: MessageInput[],
-): Message[] {
-  const messages = tryMap(inputMessages, (message) => {
-    if (message.textMessage) {
-      return plainToInstance(TextMessage, {
-        id: message.id,
-        createdAt: message.createdAt,
-        role: message.textMessage.role,
-        content: message.textMessage.content,
-        parentMessageId: message.textMessage.parentMessageId,
-      });
-    } else if (message.imageMessage) {
-      return plainToInstance(ImageMessage, {
-        id: message.id,
-        createdAt: message.createdAt,
-        role: message.imageMessage.role,
-        bytes: message.imageMessage.bytes,
-        format: message.imageMessage.format,
-        parentMessageId: message.imageMessage.parentMessageId,
-      });
-    } else if (message.actionExecutionMessage) {
-      return plainToInstance(ActionExecutionMessage, {
-        id: message.id,
-        createdAt: message.createdAt,
-        name: message.actionExecutionMessage.name,
-        arguments: safeParseToolArgs(message.actionExecutionMessage.arguments),
-        parentMessageId: message.actionExecutionMessage.parentMessageId,
-      });
-    } else if (message.resultMessage) {
-      return plainToInstance(ResultMessage, {
-        id: message.id,
-        createdAt: message.createdAt,
-        actionExecutionId: message.resultMessage.actionExecutionId,
-        actionName: message.resultMessage.actionName,
-        result: message.resultMessage.result,
-      });
-    } else if (message.agentStateMessage) {
-      return plainToInstance(AgentStateMessage, {
-        id: message.id,
-        threadId: message.agentStateMessage.threadId,
-        createdAt: message.createdAt,
-        agentName: message.agentStateMessage.agentName,
-        nodeName: message.agentStateMessage.nodeName,
-        runId: message.agentStateMessage.runId,
-        active: message.agentStateMessage.active,
-        role: message.agentStateMessage.role,
-        state: JSON.parse(message.agentStateMessage.state),
-        running: message.agentStateMessage.running,
-      });
-    } else {
-      return null;
-    }
-  });
-
-  return messages.filter((m) => m);
-}

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

@@ -1,38 +0,0 @@
-/**
- * CopilotKit Empty Adapter
- *
- * This adapter is meant to preserve adherence to runtime requirements, while doing nothing
- * Ideal if you don't want to connect an LLM the to the runtime, and only use your LangGraph agent.
- * Be aware that Copilot Suggestions will not work if you use this adapter
- *
- * ## Example
- *
- * ```ts
- * import { CopilotRuntime, EmptyAdapter } from "@copilotkit/runtime";
- *
- * const copilotKit = new CopilotRuntime();
- *
- * return new EmptyAdapter();
- * ```
- */
-import {
-  CopilotServiceAdapter,
-  CopilotRuntimeChatCompletionRequest,
-  CopilotRuntimeChatCompletionResponse,
-} from "../service-adapter";
-import { randomUUID } from "@copilotkit/shared";
-
-export class EmptyAdapter implements CopilotServiceAdapter {
-  async process(
-    request: CopilotRuntimeChatCompletionRequest,
-  ): Promise<CopilotRuntimeChatCompletionResponse> {
-    return {
-      threadId: request.threadId || randomUUID(),
-    };
-  }
-  public get name() {
-    return "EmptyAdapter";
-  }
-}
-
-export const ExperimentalEmptyAdapter = EmptyAdapter;