@copilotkit/runtime 1.56.0 → 1.56.2-canary.pin-to-send

package/src/v2/runtime/intelligence-platform/client.ts

@@ -42,7 +42,6 @@ export class PlatformRequestError extends Error {
  *   apiUrl: "https://api.copilotkit.ai",
  *   wsUrl: "wss://api.copilotkit.ai",
  *   apiKey: process.env.COPILOTKIT_API_KEY!,
- *   organizationId: process.env.COPILOTKIT_ORGANIZATION_ID!,
  * });
  *
  * const runtime = new CopilotRuntime({
@@ -66,8 +65,6 @@ export interface CopilotKitIntelligenceConfig {
   wsUrl: string;
   /** API key for authenticating with the intelligence platform */
   apiKey: string;
-  /** Organization identifier used for self-hosted Intelligence instances */
-  organizationId: string;
   /**
    * Initial listener invoked after a thread is created.
    * Prefer {@link CopilotKitIntelligence.onThreadCreated} for multiple listeners.
@@ -248,7 +245,6 @@ export class CopilotKitIntelligence {
   #runnerWsUrl: string;
   #clientWsUrl: string;
   #apiKey: string;
-  #organizationId: string;
   #threadCreatedListeners = new Set<(thread: ThreadSummary) => void>();
   #threadUpdatedListeners = new Set<(thread: ThreadSummary) => void>();
   #threadDeletedListeners = new Set<(params: ThreadDeletedPayload) => void>();
@@ -260,7 +256,6 @@ export class CopilotKitIntelligence {
     this.#runnerWsUrl = deriveRunnerWsUrl(intelligenceWsUrl);
     this.#clientWsUrl = deriveClientWsUrl(intelligenceWsUrl);
     this.#apiKey = config.apiKey;
-    this.#organizationId = config.organizationId;
 
     if (config.onThreadCreated) {
       this.onThreadCreated(config.onThreadCreated);
@@ -345,10 +340,6 @@ export class CopilotKitIntelligence {
     return this.#clientWsUrl;
   }
 
-  ɵgetOrganizationId(): string {
-    return this.#organizationId;
-  }
-
   ɵgetRunnerAuthToken(): string {
     return this.#apiKey;
   }
@@ -359,7 +350,6 @@ export class CopilotKitIntelligence {
     const headers: Record<string, string> = {
       Authorization: `Bearer ${this.#apiKey}`,
       "Content-Type": "application/json",
-      "X-Organization-Id": this.#organizationId,
     };
 
     const response = await fetch(url, {
@@ -400,7 +390,7 @@ export class CopilotKitIntelligence {
 
     for (const callback of listeners) {
       try {
-        void (callback as (p: typeof payload) => void)(payload);
+        (callback as (p: typeof payload) => void)(payload);
       } catch (error) {
         logger.error(
           { err: error, callbackName, payload },
@@ -663,12 +653,14 @@ export class CopilotKitIntelligence {
   async ɵconnectThread(params: {
     threadId: string;
     userId: string;
+    runId?: string;
     lastSeenEventId?: string | null;
   }): Promise<ConnectThreadResponse> {
     const result = await this.#request<
       ConnectThreadBootstrapResponse | ConnectThreadLiveResponse
     >("POST", `/api/threads/${encodeURIComponent(params.threadId)}/connect`, {
       userId: params.userId,
+      ...(params.runId !== undefined ? { runId: params.runId } : {}),
       ...(params.lastSeenEventId !== undefined
         ? { lastSeenEventId: params.lastSeenEventId }
         : {}),

package/src/v2/runtime/runner/__tests__/intelligence-runner.test.ts

@@ -286,6 +286,49 @@ describe("IntelligenceAgentRunner", () => {
       expect(ch.pushLog[2].payload.metadata.cpki_event_seq).toBe(3);
     });
 
+    it("overrides conflicting event thread and run ownership before pushing to the channel", async () => {
+      const threadId = "t-canonical";
+      const input = createRunInput({ threadId, runId: "r-canonical" });
+
+      const agent = new MockAgent([
+        {
+          type: EventType.RUN_STARTED,
+          threadId: "backend-thread",
+          runId: "backend-run",
+        } as RunStartedEvent,
+        {
+          type: EventType.RUN_FINISHED,
+          threadId: "backend-thread",
+          runId: "backend-run",
+        } as RunFinishedEvent,
+      ]);
+
+      const eventsPromise = collectEvents(
+        runner.run({ threadId, agent, input }),
+      );
+      const ch = mockChannels[0];
+      ch.triggerJoin("ok");
+
+      await eventsPromise;
+
+      expect(ch.pushLog.map((entry) => entry.payload)).toEqual([
+        expect.objectContaining({
+          type: EventType.RUN_STARTED,
+          threadId,
+          runId: input.runId,
+          thread_id: threadId,
+          run_id: input.runId,
+        }),
+        expect.objectContaining({
+          type: EventType.RUN_FINISHED,
+          threadId,
+          runId: input.runId,
+          thread_id: threadId,
+          run_id: input.runId,
+        }),
+      ]);
+    });
+
     it("rewrites RUN_STARTED input.messages to the unseen persisted subset", async () => {
       const threadId = "t-persisted-input";
       const input = createRunInput({
@@ -442,7 +485,14 @@ describe("IntelligenceAgentRunner", () => {
         (p) => p.payload?.type === EventType.RUN_ERROR,
       );
       expect(errorPush).toBeDefined();
-      expect(errorPush!.payload.message).toBe("Something went wrong");
+      expect(errorPush!.payload).toMatchObject({
+        type: EventType.RUN_ERROR,
+        message: "Something went wrong",
+        threadId,
+        runId: input.runId,
+        thread_id: threadId,
+        run_id: input.runId,
+      });
     });
 
     it("finalizes open message streams before completing", async () => {

package/src/v2/runtime/runner/intelligence.ts

@@ -95,22 +95,33 @@ export class IntelligenceAgentRunner extends AgentRunner {
     request: AgentRunnerRunRequest,
     state: ThreadState,
   ): Record<string, unknown> {
-    const canonicalEvent = this.stampRunnerMetadata(event, state);
+    const canonicalEvent = this.stampRunnerMetadata(
+      this.stampCanonicalRunOwnership(event, request),
+      state,
+    );
     const payload = {
       ...(canonicalEvent as Record<string, unknown>),
     };
 
-    payload.thread_id ??= request.threadId;
-
-    const runId = payload.runId ?? payload.run_id ?? request.input.runId;
-
-    if (runId) {
-      payload.run_id = runId;
-    }
+    payload.threadId = request.threadId;
+    payload.runId = request.input.runId;
+    payload.thread_id = request.threadId;
+    payload.run_id = request.input.runId;
 
     return payload;
   }
 
+  private stampCanonicalRunOwnership(
+    event: BaseEvent,
+    request: AgentRunnerRunRequest,
+  ): BaseEvent {
+    return {
+      ...(event as BaseEvent & Record<string, unknown>),
+      threadId: request.threadId,
+      runId: request.input.runId,
+    } as BaseEvent;
+  }
+
   private stampRunnerMetadata(event: BaseEvent, state: ThreadState): BaseEvent {
     const eventRecord = event as BaseEvent & {
       metadata?: Record<string, unknown>;
@@ -327,7 +338,10 @@ export class IntelligenceAgentRunner extends AgentRunner {
   ): Observable<void> {
     const { currentEvents, channel } = state;
     const pushCanonicalEvent = (event: BaseEvent): void => {
-      const canonicalEvent = this.stampRunnerMetadata(event, state);
+      const canonicalEvent = this.stampRunnerMetadata(
+        this.stampCanonicalRunOwnership(event, request),
+        state,
+      );
       currentEvents.push(canonicalEvent);
 
       if (canonicalEvent.type === EventType.RUN_STARTED) {
@@ -355,8 +369,12 @@ export class IntelligenceAgentRunner extends AgentRunner {
           threadId: request.threadId,
           runId: request.input.runId,
         }),
+        threadId: request.threadId,
+        runId: request.input.runId,
         input: {
           ...baseInput,
+          threadId: request.threadId,
+          runId: request.input.runId,
           ...(persistedInputMessages !== undefined
             ? { messages: persistedInputMessages }
             : {}),

package/tests/service-adapters/anthropic/anthropic-adapter.test.ts

@@ -374,4 +374,272 @@ describe("AnthropicAdapter", () => {
       });
     });
   });
+
+  describe("Unknown Tool Use Handling", () => {
+    it("should skip unknown tool_use blocks without crashing", async () => {
+      const systemMessage = new TextMessage("system", "System message");
+      const userMessage = new TextMessage("user", "Do something");
+
+      // Mock Anthropic to return a stream with an unknown tool_use block
+      mockAnthropicCreate.mockResolvedValue({
+        [Symbol.asyncIterator]: async function* () {
+          yield { type: "message_start", message: { id: "msg-1" } };
+          // Unknown tool_use block — tool name not in the actions list
+          yield {
+            type: "content_block_start",
+            content_block: {
+              type: "tool_use",
+              id: "tool-unknown",
+              name: "nonexistent_tool",
+            },
+          };
+          yield {
+            type: "content_block_delta",
+            delta: { type: "input_json_delta", partial_json: '{"query":' },
+          };
+          yield {
+            type: "content_block_delta",
+            delta: { type: "input_json_delta", partial_json: '"test"}' },
+          };
+          yield { type: "content_block_stop" };
+          // Then a normal text block
+          yield {
+            type: "content_block_start",
+            content_block: { type: "text" },
+          };
+          yield {
+            type: "content_block_delta",
+            delta: { type: "text_delta", text: "Here is the result." },
+          };
+          yield { type: "content_block_stop" };
+        },
+      });
+
+      const mockStream = {
+        sendTextMessageStart: vi.fn(),
+        sendTextMessageContent: vi.fn(),
+        sendTextMessageEnd: vi.fn(),
+        sendActionExecutionStart: vi.fn(),
+        sendActionExecutionArgs: vi.fn(),
+        sendActionExecutionEnd: vi.fn(),
+        complete: vi.fn(),
+      };
+
+      let streamCallbackDone: Promise<void>;
+      mockEventSource.stream.mockImplementation((callback: any) => {
+        streamCallbackDone = callback(mockStream);
+      });
+
+      await adapter.process({
+        threadId: "test-thread",
+        messages: [systemMessage, userMessage],
+        actions: [
+          {
+            name: "known_tool",
+            description: "A known tool",
+            parameters: [],
+            jsonSchema: '{"type":"object","properties":{}}',
+          },
+        ],
+        eventSource: mockEventSource,
+        forwardedParameters: {},
+      });
+
+      // Wait for async stream processing to complete
+      await streamCallbackDone!;
+
+      // Should NOT have sent action execution events for the unknown tool
+      expect(mockStream.sendActionExecutionStart).not.toHaveBeenCalled();
+      expect(mockStream.sendActionExecutionArgs).not.toHaveBeenCalled();
+      expect(mockStream.sendActionExecutionEnd).not.toHaveBeenCalled();
+
+      // Should still process the text block normally
+      expect(mockStream.sendTextMessageStart).toHaveBeenCalled();
+      expect(mockStream.sendTextMessageContent).toHaveBeenCalledWith({
+        messageId: "msg-1",
+        content: "Here is the result.",
+      });
+      expect(mockStream.sendTextMessageEnd).toHaveBeenCalled();
+      expect(mockStream.complete).toHaveBeenCalled();
+    });
+
+    it("should trigger fallback when only unknown tool_use blocks are returned", async () => {
+      const systemMessage = new TextMessage("system", "System message");
+      const userMessage = new TextMessage("user", "Do something");
+
+      const toolExecution = new ActionExecutionMessage({
+        id: "tool-prev",
+        name: "someAction",
+        arguments: "{}",
+      });
+
+      const toolResult = new ResultMessage({
+        actionExecutionId: "tool-prev",
+        result: "Previous result",
+      });
+
+      // Mock Anthropic to return ONLY an unknown tool_use block
+      mockAnthropicCreate.mockResolvedValue({
+        [Symbol.asyncIterator]: async function* () {
+          yield { type: "message_start", message: { id: "msg-1" } };
+          yield {
+            type: "content_block_start",
+            content_block: {
+              type: "tool_use",
+              id: "tool-unknown",
+              name: "nonexistent_tool",
+            },
+          };
+          yield {
+            type: "content_block_delta",
+            delta: { type: "input_json_delta", partial_json: "{}" },
+          };
+          yield { type: "content_block_stop" };
+        },
+      });
+
+      const mockStream = {
+        sendTextMessageStart: vi.fn(),
+        sendTextMessageContent: vi.fn(),
+        sendTextMessageEnd: vi.fn(),
+        sendActionExecutionStart: vi.fn(),
+        sendActionExecutionArgs: vi.fn(),
+        sendActionExecutionEnd: vi.fn(),
+        complete: vi.fn(),
+      };
+
+      let streamCallbackDone: Promise<void>;
+      mockEventSource.stream.mockImplementation((callback: any) => {
+        streamCallbackDone = callback(mockStream);
+      });
+
+      await adapter.process({
+        threadId: "test-thread",
+        messages: [systemMessage, userMessage, toolExecution, toolResult],
+        actions: [
+          {
+            name: "known_tool",
+            description: "A known tool",
+            parameters: [],
+            jsonSchema: '{"type":"object","properties":{}}',
+          },
+        ],
+        eventSource: mockEventSource,
+        forwardedParameters: {},
+      });
+
+      // Wait for async stream processing to complete
+      await streamCallbackDone!;
+
+      // Should NOT have sent action execution events
+      expect(mockStream.sendActionExecutionStart).not.toHaveBeenCalled();
+
+      // Should trigger fallback since hasReceivedContent should be false
+      expect(mockStream.sendTextMessageStart).toHaveBeenCalled();
+      expect(mockStream.sendTextMessageContent).toHaveBeenCalledWith({
+        messageId: expect.any(String),
+        content: "Previous result",
+      });
+      expect(mockStream.sendTextMessageEnd).toHaveBeenCalled();
+    });
+  });
+});
+
+describe("AnthropicAdapter max_tokens default", () => {
+  let mockAnthropicCreate: any;
+  let mockEventSource: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should default max_tokens to 4096 when not specified", async () => {
+    const mockAnthropic = {
+      messages: {
+        create: vi.fn(),
+      },
+    };
+
+    const adapter = new AnthropicAdapter({ anthropic: mockAnthropic as any });
+    mockAnthropicCreate = mockAnthropic.messages.create;
+
+    mockAnthropicCreate.mockResolvedValue({
+      [Symbol.asyncIterator]: async function* () {},
+    });
+
+    mockEventSource = {
+      stream: vi.fn((callback) => {
+        const mockStream = {
+          sendTextMessageStart: vi.fn(),
+          sendTextMessageContent: vi.fn(),
+          sendTextMessageEnd: vi.fn(),
+          sendActionExecutionStart: vi.fn(),
+          sendActionExecutionArgs: vi.fn(),
+          sendActionExecutionEnd: vi.fn(),
+          complete: vi.fn(),
+        };
+        callback(mockStream);
+        return Promise.resolve();
+      }),
+    };
+
+    const systemMessage = new TextMessage("system", "System message");
+    const userMessage = new TextMessage("user", "Hello");
+
+    await adapter.process({
+      threadId: "test-thread",
+      messages: [systemMessage, userMessage],
+      actions: [],
+      eventSource: mockEventSource,
+      forwardedParameters: {},
+    });
+
+    const createCallArgs = mockAnthropicCreate.mock.calls[0][0];
+    expect(createCallArgs.max_tokens).toBe(4096);
+  });
+
+  it("should use provided maxTokens when specified", async () => {
+    const mockAnthropic = {
+      messages: {
+        create: vi.fn(),
+      },
+    };
+
+    const adapter = new AnthropicAdapter({ anthropic: mockAnthropic as any });
+    mockAnthropicCreate = mockAnthropic.messages.create;
+
+    mockAnthropicCreate.mockResolvedValue({
+      [Symbol.asyncIterator]: async function* () {},
+    });
+
+    mockEventSource = {
+      stream: vi.fn((callback) => {
+        const mockStream = {
+          sendTextMessageStart: vi.fn(),
+          sendTextMessageContent: vi.fn(),
+          sendTextMessageEnd: vi.fn(),
+          sendActionExecutionStart: vi.fn(),
+          sendActionExecutionArgs: vi.fn(),
+          sendActionExecutionEnd: vi.fn(),
+          complete: vi.fn(),
+        };
+        callback(mockStream);
+        return Promise.resolve();
+      }),
+    };
+
+    const systemMessage = new TextMessage("system", "System message");
+    const userMessage = new TextMessage("user", "Hello");
+
+    await adapter.process({
+      threadId: "test-thread",
+      messages: [systemMessage, userMessage],
+      actions: [],
+      eventSource: mockEventSource,
+      forwardedParameters: { maxTokens: 8192 },
+    });
+
+    const createCallArgs = mockAnthropicCreate.mock.calls[0][0];
+    expect(createCallArgs.max_tokens).toBe(8192);
+  });
 });