@copilotkit/runtime 2.0.0-next.1 → 2.0.0-rc.1

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

@@ -1,151 +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/index.ts

@@ -1,3 +0,0 @@
-import "reflect-metadata";
-export * from "@copilotkitnext/runtime";
-export * from "@copilotkitnext/agent";

package/tests/global.d.ts

@@ -1,13 +0,0 @@
-import "@jest/globals";
-
-declare global {
-  const jest: (typeof import("@jest/globals"))["jest"];
-  const expect: (typeof import("@jest/globals"))["expect"];
-  const test: (typeof import("@jest/globals"))["test"];
-  const describe: (typeof import("@jest/globals"))["describe"];
-  const beforeEach: (typeof import("@jest/globals"))["beforeEach"];
-  const afterEach: (typeof import("@jest/globals"))["afterEach"];
-  const beforeAll: (typeof import("@jest/globals"))["beforeAll"];
-  const afterAll: (typeof import("@jest/globals"))["afterAll"];
-  const it: (typeof import("@jest/globals"))["it"];
-}

package/tests/service-adapters/anthropic/allowlist-approach.test.ts

@@ -1,226 +0,0 @@
-/**
- * @jest-environment node
- */
-
-import { describe, it, expect } from "@jest/globals";
-
-describe("Anthropic Adapter - Allowlist Approach", () => {
-  it("should filter out tool_result messages with no corresponding tool_use ID", () => {
-    // Setup test data
-    const validToolUseIds = new Set<string>(["valid-id-1", "valid-id-2"]);
-
-    // Messages to filter - valid and invalid ones
-    const messages = [
-      { type: "text", role: "user", content: "Hello" },
-      { type: "tool_result", actionExecutionId: "valid-id-1", result: "result1" },
-      { type: "tool_result", actionExecutionId: "invalid-id", result: "invalid" },
-      { type: "tool_result", actionExecutionId: "valid-id-2", result: "result2" },
-      { type: "tool_result", actionExecutionId: "valid-id-1", result: "duplicate" }, // Duplicate ID
-    ];
-
-    // Apply the allowlist filter approach
-    const filteredMessages = [];
-    const processedIds = new Set<string>();
-
-    for (const message of messages) {
-      if (message.type === "tool_result") {
-        // Skip if no corresponding valid tool_use ID
-        if (!validToolUseIds.has(message.actionExecutionId)) {
-          continue;
-        }
-
-        // Skip if we've already processed this ID
-        if (processedIds.has(message.actionExecutionId)) {
-          continue;
-        }
-
-        // Mark this ID as processed
-        processedIds.add(message.actionExecutionId);
-      }
-
-      // Include all non-tool-result messages and valid tool results
-      filteredMessages.push(message);
-    }
-
-    // Verify results
-    expect(filteredMessages.length).toBe(3); // text + 2 valid tool results (no duplicates or invalid)
-
-    // Valid results should be included
-    expect(
-      filteredMessages.some(
-        (m) => m.type === "tool_result" && m.actionExecutionId === "valid-id-1",
-      ),
-    ).toBe(true);
-
-    expect(
-      filteredMessages.some(
-        (m) => m.type === "tool_result" && m.actionExecutionId === "valid-id-2",
-      ),
-    ).toBe(true);
-
-    // Invalid result should be excluded
-    expect(
-      filteredMessages.some(
-        (m) => m.type === "tool_result" && m.actionExecutionId === "invalid-id",
-      ),
-    ).toBe(false);
-
-    // Duplicate should be excluded
-    const validId1Count = filteredMessages.filter(
-      (m) => m.type === "tool_result" && m.actionExecutionId === "valid-id-1",
-    ).length;
-
-    expect(validId1Count).toBe(1);
-  });
-
-  it("should maintain correct order of messages when filtering", () => {
-    // Setup test data with specific ordering
-    const validToolUseIds = new Set<string>(["tool-1", "tool-2", "tool-3"]);
-
-    // Messages in a specific order, with some invalid/duplicate results
-    const messages = [
-      { type: "text", role: "user", content: "Initial message" },
-      { type: "text", role: "assistant", content: "I'll help with that" },
-      { type: "tool_use", id: "tool-1", name: "firstTool" },
-      { type: "tool_result", actionExecutionId: "tool-1", result: "result1" },
-      { type: "text", role: "assistant", content: "Got the first result" },
-      { type: "tool_use", id: "tool-2", name: "secondTool" },
-      { type: "tool_result", actionExecutionId: "tool-2", result: "result2" },
-      { type: "tool_result", actionExecutionId: "invalid-id", result: "invalid-result" },
-      { type: "tool_use", id: "tool-3", name: "thirdTool" },
-      { type: "tool_result", actionExecutionId: "tool-1", result: "duplicate-result" }, // Duplicate
-      { type: "tool_result", actionExecutionId: "tool-3", result: "result3" },
-      { type: "text", role: "user", content: "Final message" },
-    ];
-
-    // Apply the allowlist filter approach
-    const filteredMessages = [];
-    const processedIds = new Set<string>();
-
-    for (const message of messages) {
-      if (message.type === "tool_result") {
-        // Skip if no corresponding valid tool_use ID
-        if (!validToolUseIds.has(message.actionExecutionId)) {
-          continue;
-        }
-
-        // Skip if we've already processed this ID
-        if (processedIds.has(message.actionExecutionId)) {
-          continue;
-        }
-
-        // Mark this ID as processed
-        processedIds.add(message.actionExecutionId);
-      }
-
-      // Include all non-tool-result messages and valid tool results
-      filteredMessages.push(message);
-    }
-
-    // Verify results
-    expect(filteredMessages.length).toBe(10); // 12 original - 2 filtered out
-
-    // Check that the order is preserved
-    expect(filteredMessages[0].type).toBe("text"); // Initial user message
-    expect(filteredMessages[1].type).toBe("text"); // Assistant response
-    expect(filteredMessages[2].type).toBe("tool_use"); // First tool
-    expect(filteredMessages[3].type).toBe("tool_result"); // First result
-    expect(filteredMessages[3].actionExecutionId).toBe("tool-1"); // First result
-    expect(filteredMessages[4].type).toBe("text"); // Assistant comment
-    expect(filteredMessages[5].type).toBe("tool_use"); // Second tool
-    expect(filteredMessages[6].type).toBe("tool_result"); // Second result
-    expect(filteredMessages[6].actionExecutionId).toBe("tool-2"); // Second result
-    expect(filteredMessages[7].type).toBe("tool_use"); // Third tool
-    expect(filteredMessages[8].type).toBe("tool_result"); // Third result
-    expect(filteredMessages[8].actionExecutionId).toBe("tool-3"); // Third result
-    expect(filteredMessages[9].type).toBe("text"); // Final user message
-
-    // Each valid tool ID should appear exactly once in the results
-    const toolResultCounts = {
-      "tool-1": 0,
-      "tool-2": 0,
-      "tool-3": 0,
-    };
-
-    filteredMessages.forEach((message) => {
-      if (message.type === "tool_result" && message.actionExecutionId in toolResultCounts) {
-        toolResultCounts[message.actionExecutionId]++;
-      }
-    });
-
-    expect(toolResultCounts["tool-1"]).toBe(1);
-    expect(toolResultCounts["tool-2"]).toBe(1);
-    expect(toolResultCounts["tool-3"]).toBe(1);
-  });
-
-  it("should handle an empty message array", () => {
-    const validToolUseIds = new Set<string>(["valid-id-1", "valid-id-2"]);
-    const messages = [];
-
-    // Apply the filtering logic
-    const filteredMessages = [];
-    const processedIds = new Set<string>();
-
-    for (const message of messages) {
-      if (message.type === "tool_result") {
-        if (
-          !validToolUseIds.has(message.actionExecutionId) ||
-          processedIds.has(message.actionExecutionId)
-        ) {
-          continue;
-        }
-        processedIds.add(message.actionExecutionId);
-      }
-      filteredMessages.push(message);
-    }
-
-    expect(filteredMessages.length).toBe(0);
-  });
-
-  it("should handle edge cases with mixed message types", () => {
-    // Setup with mixed message types
-    const validToolUseIds = new Set<string>(["valid-id-1"]);
-
-    const messages = [
-      { type: "text", role: "user", content: "Hello" },
-      { type: "image", url: "https://example.com/image.jpg" }, // Non-tool message type
-      { type: "tool_result", actionExecutionId: "valid-id-1", result: "result1" },
-      { type: "custom", data: { key: "value" } }, // Another custom type
-      { type: "tool_result", actionExecutionId: "valid-id-1", result: "duplicate" }, // Duplicate
-      { type: "null", value: null }, // Edge case
-      { type: "undefined" }, // Edge case
-    ];
-
-    // Apply the filtering logic
-    const filteredMessages = [];
-    const processedIds = new Set<string>();
-
-    for (const message of messages) {
-      if (message.type === "tool_result") {
-        if (
-          !validToolUseIds.has(message.actionExecutionId) ||
-          processedIds.has(message.actionExecutionId)
-        ) {
-          continue;
-        }
-        processedIds.add(message.actionExecutionId);
-      }
-      filteredMessages.push(message);
-    }
-
-    // Should have all non-tool_result messages + 1 valid tool_result
-    expect(filteredMessages.length).toBe(6); // 7 original - 1 duplicate
-
-    // Valid tool_result should be included exactly once
-    const toolResults = filteredMessages.filter((m) => m.type === "tool_result");
-    expect(toolResults.length).toBe(1);
-    expect(toolResults[0].actionExecutionId).toBe("valid-id-1");
-
-    // All other message types should be preserved
-    expect(filteredMessages.filter((m) => m.type === "text").length).toBe(1);
-    expect(filteredMessages.filter((m) => m.type === "image").length).toBe(1);
-    expect(filteredMessages.filter((m) => m.type === "custom").length).toBe(1);
-    expect(filteredMessages.filter((m) => m.type === "null").length).toBe(1);
-    expect(filteredMessages.filter((m) => m.type === "undefined").length).toBe(1);
-  });
-});