@copilotkit/runtime 0.0.0-0.0.0-max-changeset-10101010101010-20260109191632

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

@@ -0,0 +1,151 @@
+/**
+ * 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

@@ -0,0 +1,70 @@
+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

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

package/src/v2/index.ts

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

package/tests/global.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,226 @@
+/**
+ * @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);
+  });
+});