@copilotkit/runtime 1.55.1 → 1.55.2-canary.test-01

package/src/lib/runtime/copilot-runtime.ts

@@ -64,7 +64,7 @@ import {
   type MCPTool,
   extractParametersFromSchema,
 } from "./mcp-tools-utils";
-import { BuiltInAgent, type BuiltInAgentConfiguration } from "../../agent";
+import { BuiltInAgent, type BuiltInAgentClassicConfig } from "../../agent";
 // Define the function type alias here or import if defined elsewhere
 type CreateMCPClientFunction = (
   config: MCPEndpointConfig,
@@ -328,7 +328,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
   params?: CopilotRuntimeConstructorParams<T>;
   private observability?: CopilotObservabilityConfig;
   // Cache MCP tools per endpoint to avoid re-fetching repeatedly
-  private mcpToolsCache: Map<string, BuiltInAgentConfiguration["tools"]> =
+  private mcpToolsCache: Map<string, BuiltInAgentClassicConfig["tools"]> =
     new Map();
   private runtimeArgs: CopilotRuntimeOptions;
   private _instance: CopilotRuntimeVNext;
@@ -449,7 +449,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
   // Receive this.params.action and turn it into the AbstractAgent tools
   private getToolsFromActions(
     actions: ActionsConfiguration<any>,
-  ): BuiltInAgentConfiguration["tools"] {
+  ): BuiltInAgentClassicConfig["tools"] {
     // Resolve actions to an array (handle function case)
     const actionsArray =
       typeof actions === "function"
@@ -472,7 +472,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
 
   private assignToolsToAgents(
     agents: Record<string, AbstractAgent>,
-    tools: BuiltInAgentConfiguration["tools"],
+    tools: BuiltInAgentClassicConfig["tools"],
   ): Record<string, AbstractAgent> {
     if (!tools?.length) {
       return agents;
@@ -481,12 +481,21 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
     const enrichedAgents: Record<string, AbstractAgent> = { ...agents };
 
     for (const [agentId, agent] of Object.entries(enrichedAgents)) {
-      const existingConfig = (Reflect.get(agent, "config") ??
-        {}) as BuiltInAgentConfiguration;
-      const existingTools = existingConfig.tools ?? [];
+      const existingConfig = (Reflect.get(agent, "config") ?? {}) as Record<
+        string,
+        unknown
+      >;
 
-      const updatedConfig: BuiltInAgentConfiguration = {
-        ...existingConfig,
+      // Skip factory-mode agents — they don't have a tools property
+      if ("factory" in existingConfig) {
+        continue;
+      }
+
+      const classicConfig = existingConfig as BuiltInAgentClassicConfig;
+      const existingTools = classicConfig.tools ?? [];
+
+      const updatedConfig: BuiltInAgentClassicConfig = {
+        ...classicConfig,
         tools: [...existingTools, ...tools],
       };
 
@@ -657,7 +666,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
   // Optionally accepts request-scoped properties to merge request-provided mcpServers
   private async getToolsFromMCP(options?: {
     properties?: Record<string, unknown>;
-  }): Promise<BuiltInAgentConfiguration["tools"]> {
+  }): Promise<BuiltInAgentClassicConfig["tools"]> {
     const runtimeMcpServers = (this.params?.mcpServers ??
       []) as MCPEndpointConfig[];
     const createMCPClient = this.params?.createMCPClient as
@@ -702,7 +711,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       return Array.from(byUrl.values());
     })();
 
-    const allTools: BuiltInAgentConfiguration["tools"] = [];
+    const allTools: BuiltInAgentClassicConfig["tools"] = [];
 
     for (const config of effectiveEndpoints) {
       const endpointUrl = config.endpoint;
@@ -717,7 +726,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
         const client = await createMCPClient(config);
         const toolsMap = await client.tools();
 
-        const toolDefs: BuiltInAgentConfiguration["tools"] = Object.entries(
+        const toolDefs: BuiltInAgentClassicConfig["tools"] = Object.entries(
           toolsMap,
         ).map(([toolName, tool]: [string, MCPTool]) => {
           const params: Parameter[] = extractParametersFromSchema(tool);

package/src/lib/runtime/mcp-tools-utils.ts

@@ -145,7 +145,7 @@ export function convertMCPToolsToActions(
         throw new Error(
           `Execution failed for MCP tool '${toolName}': ${
             error instanceof Error ? error.message : String(error)
-          }`,
+          }`, { cause: error },
         );
       }
     };

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

@@ -32,7 +32,7 @@ export function limitMessagesToTokenCount(
 
   let cutoff: boolean = false;
 
-  const reversedMessages = [...messages].reverse();
+  const reversedMessages = [...messages].toReversed();
   for (const message of reversedMessages) {
     if (message.role === "system") {
       result.unshift(message);

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

@@ -40,7 +40,7 @@ export function limitMessagesToTokenCount(
 
   let cutoff: boolean = false;
 
-  const reversedMessages = [...messages].reverse();
+  const reversedMessages = [...messages].toReversed();
   for (const message of reversedMessages) {
     if (["system", "developer"].includes(message.role)) {
       result.unshift(message);

package/src/v2/runtime/__tests__/fetch-router.test.ts

@@ -50,6 +50,57 @@ describe("fetch-router", () => {
       expect(result).toBeNull();
     });
 
+    it("matches GET /threads", () => {
+      const result = matchRoute("/api/copilotkit/threads", basePath);
+      expect(result).toEqual({ method: "threads/list" });
+    });
+
+    it("matches POST /threads/subscribe", () => {
+      const result = matchRoute("/api/copilotkit/threads/subscribe", basePath);
+      expect(result).toEqual({ method: "threads/subscribe" });
+    });
+
+    it("matches PATCH /threads/:threadId", () => {
+      const result = matchRoute("/api/copilotkit/threads/thread-abc", basePath);
+      expect(result).toEqual({
+        method: "threads/update",
+        threadId: "thread-abc",
+      });
+    });
+
+    it("matches POST /threads/:threadId/archive", () => {
+      const result = matchRoute(
+        "/api/copilotkit/threads/thread-abc/archive",
+        basePath,
+      );
+      expect(result).toEqual({
+        method: "threads/archive",
+        threadId: "thread-abc",
+      });
+    });
+
+    it("matches GET /threads/:threadId/messages", () => {
+      const result = matchRoute(
+        "/api/copilotkit/threads/thread-abc/messages",
+        basePath,
+      );
+      expect(result).toEqual({
+        method: "threads/messages",
+        threadId: "thread-abc",
+      });
+    });
+
+    it("handles URL-encoded threadId in thread routes", () => {
+      const result = matchRoute(
+        "/api/copilotkit/threads/thread%2F123",
+        basePath,
+      );
+      expect(result).toEqual({
+        method: "threads/update",
+        threadId: "thread/123",
+      });
+    });
+
     it("returns null when basePath is a prefix but not a segment boundary", () => {
       const result = matchRoute("/api/copilotkitextra/info", basePath);
       expect(result).toBeNull();
@@ -124,6 +175,31 @@ describe("fetch-router", () => {
       expect(result).toBeNull();
     });
 
+    it("matches /threads suffix", () => {
+      const result = matchRoute("/anything/threads");
+      expect(result).toEqual({ method: "threads/list" });
+    });
+
+    it("matches /threads/subscribe suffix", () => {
+      const result = matchRoute("/anything/threads/subscribe");
+      expect(result).toEqual({ method: "threads/subscribe" });
+    });
+
+    it("matches /threads/:threadId suffix", () => {
+      const result = matchRoute("/anything/threads/t1");
+      expect(result).toEqual({ method: "threads/update", threadId: "t1" });
+    });
+
+    it("matches /threads/:threadId/archive suffix", () => {
+      const result = matchRoute("/anything/threads/t1/archive");
+      expect(result).toEqual({ method: "threads/archive", threadId: "t1" });
+    });
+
+    it("matches /threads/:threadId/messages suffix", () => {
+      const result = matchRoute("/anything/threads/t1/messages");
+      expect(result).toEqual({ method: "threads/messages", threadId: "t1" });
+    });
+
     it("works with deeply nested mount prefix", () => {
       const result = matchRoute("/api/v2/copilotkit/agent/a1/run");
       expect(result).toEqual({ method: "agent/run", agentId: "a1" });

package/src/v2/runtime/__tests__/mcp-apps-middleware-integration.test.ts

@@ -0,0 +1,275 @@
+import { describe, it, expect, afterEach, vi } from "vitest";
+import {
+  AbstractAgent,
+  RunAgentInput,
+  BaseEvent,
+  EventType,
+} from "@ag-ui/client";
+import { Observable } from "rxjs";
+import { LLMock, MCPMock } from "@copilotkit/aimock";
+import { MCPAppsMiddleware, getServerHash } from "@ag-ui/mcp-apps-middleware";
+
+/**
+ * A minimal next-agent that emits RUN_STARTED and RUN_FINISHED.
+ * Used as the downstream agent when the middleware should NOT delegate.
+ */
+class MockNextAgent extends AbstractAgent {
+  run(input: RunAgentInput): Observable<BaseEvent> {
+    return new Observable((subscriber) => {
+      subscriber.next({
+        type: EventType.RUN_STARTED,
+        threadId: input.threadId,
+        runId: input.runId,
+      } as BaseEvent);
+      subscriber.next({
+        type: EventType.RUN_FINISHED,
+        threadId: input.threadId,
+        runId: input.runId,
+      } as BaseEvent);
+      subscriber.complete();
+    });
+  }
+
+  clone(): AbstractAgent {
+    return new MockNextAgent();
+  }
+
+  protected connect(): ReturnType<AbstractAgent["connect"]> {
+    throw new Error("not used");
+  }
+}
+
+function createRunInput(overrides: Partial<RunAgentInput> = {}): RunAgentInput {
+  return {
+    threadId: "thread-1",
+    runId: "run-1",
+    state: {},
+    messages: [],
+    tools: [],
+    context: [],
+    forwardedProps: undefined,
+    ...overrides,
+  };
+}
+
+async function collectEvents(
+  observable: Observable<BaseEvent>,
+): Promise<BaseEvent[]> {
+  const events: BaseEvent[] = [];
+  await new Promise<void>((resolve, reject) => {
+    observable.subscribe({
+      next: (event) => events.push(event),
+      error: reject,
+      complete: resolve,
+    });
+  });
+  return events;
+}
+
+describe("MCPAppsMiddleware integration", () => {
+  let llm: LLMock;
+  let mcpMock: MCPMock;
+
+  afterEach(async () => {
+    if (llm) {
+      await llm.stop().catch(() => {});
+    }
+  });
+
+  async function startMcpServer(): Promise<string> {
+    mcpMock = new MCPMock();
+    mcpMock.addTool({
+      name: "get_weather",
+      description: "Get the weather",
+      inputSchema: {
+        type: "object",
+        properties: { city: { type: "string" } },
+      },
+    });
+    mcpMock.onToolCall("get_weather", (args: unknown) => {
+      const parsed = args as { city?: string };
+      return `Weather in ${parsed.city || "unknown"}: sunny`;
+    });
+    mcpMock.addResource(
+      {
+        uri: "app://dashboard",
+        name: "Dashboard",
+        mimeType: "text/plain",
+      },
+      { text: "Dashboard content here" },
+    );
+
+    llm = new LLMock({ port: 0 });
+    llm.mount("/mcp", mcpMock);
+    await llm.start();
+    return `${llm.url}/mcp`;
+  }
+
+  it("can be created with mcpServers config pointing at MCPMock URL", async () => {
+    const mcpUrl = await startMcpServer();
+
+    const middleware = new MCPAppsMiddleware({
+      mcpServers: [{ type: "http", url: mcpUrl }],
+    });
+
+    expect(middleware).toBeInstanceOf(MCPAppsMiddleware);
+  });
+
+  it("proxies tools/call through to MCPMock and returns results", async () => {
+    const mcpUrl = await startMcpServer();
+
+    const serverConfig = { type: "http" as const, url: mcpUrl };
+    const serverHash = getServerHash(serverConfig);
+
+    const middleware = new MCPAppsMiddleware({
+      mcpServers: [serverConfig],
+    });
+
+    const input = createRunInput({
+      forwardedProps: {
+        __proxiedMCPRequest: {
+          serverHash,
+          method: "tools/call",
+          params: {
+            name: "get_weather",
+            arguments: { city: "NYC" },
+          },
+        },
+      },
+    });
+
+    const mockAgent = new MockNextAgent();
+    const events = await collectEvents(middleware.run(input, mockAgent));
+
+    // Should have RUN_STARTED and RUN_FINISHED
+    const types = events.map((e) => e.type);
+    expect(types).toContain(EventType.RUN_STARTED);
+    expect(types).toContain(EventType.RUN_FINISHED);
+
+    // RUN_FINISHED should contain the MCP tool result
+    const runFinished = events.find(
+      (e) => e.type === EventType.RUN_FINISHED,
+    ) as BaseEvent & { result?: unknown };
+    expect(runFinished).toBeDefined();
+    expect(runFinished.result).toBeDefined();
+
+    // The result should contain the tool's text content
+    const result = runFinished.result as { content?: unknown[] };
+    expect(result.content).toBeDefined();
+    expect(Array.isArray(result.content)).toBe(true);
+
+    const textContent = (
+      result.content as Array<{ type: string; text?: string }>
+    ).find((c) => c.type === "text");
+    expect(textContent).toBeDefined();
+    expect(textContent!.text).toContain("sunny");
+  });
+
+  it("non-proxied request delegates to next agent", async () => {
+    const mcpUrl = await startMcpServer();
+
+    const middleware = new MCPAppsMiddleware({
+      mcpServers: [{ type: "http", url: mcpUrl }],
+    });
+
+    // Input WITHOUT __proxiedMCPRequest — should delegate to MockNextAgent
+    const input = createRunInput();
+
+    const mockAgent = new MockNextAgent();
+
+    const events = await collectEvents(middleware.run(input, mockAgent));
+
+    // MockNextAgent's run should have been called (delegation happened)
+    // The middleware calls runNextWithState which internally calls next.run,
+    // but since processStream wraps it, we check the output events instead
+    const types = events.map((e) => e.type);
+    expect(types).toContain(EventType.RUN_STARTED);
+    expect(types).toContain(EventType.RUN_FINISHED);
+  });
+
+  it("wrong serverHash returns error in RUN_FINISHED result", async () => {
+    const mcpUrl = await startMcpServer();
+
+    const middleware = new MCPAppsMiddleware({
+      mcpServers: [{ type: "http", url: mcpUrl }],
+    });
+
+    const input = createRunInput({
+      forwardedProps: {
+        __proxiedMCPRequest: {
+          serverHash: "nonexistent-hash-value",
+          method: "tools/call",
+          params: {
+            name: "get_weather",
+            arguments: { city: "NYC" },
+          },
+        },
+      },
+    });
+
+    const mockAgent = new MockNextAgent();
+    const events = await collectEvents(middleware.run(input, mockAgent));
+
+    // Should still get RUN_STARTED and RUN_FINISHED
+    const types = events.map((e) => e.type);
+    expect(types).toContain(EventType.RUN_STARTED);
+    expect(types).toContain(EventType.RUN_FINISHED);
+
+    // RUN_FINISHED should contain an error about unknown server
+    const runFinished = events.find(
+      (e) => e.type === EventType.RUN_FINISHED,
+    ) as BaseEvent & { result?: unknown };
+    expect(runFinished).toBeDefined();
+    const result = runFinished.result as { error?: string };
+    expect(result.error).toBeDefined();
+    expect(result.error).toContain("nonexistent-hash-value");
+  });
+
+  it("proxies resources/read through to MCPMock and returns results", async () => {
+    const mcpUrl = await startMcpServer();
+
+    const serverConfig = { type: "http" as const, url: mcpUrl };
+    const serverHash = getServerHash(serverConfig);
+
+    const middleware = new MCPAppsMiddleware({
+      mcpServers: [serverConfig],
+    });
+
+    const input = createRunInput({
+      forwardedProps: {
+        __proxiedMCPRequest: {
+          serverHash,
+          method: "resources/read",
+          params: { uri: "app://dashboard" },
+        },
+      },
+    });
+
+    const mockAgent = new MockNextAgent();
+    const events = await collectEvents(middleware.run(input, mockAgent));
+
+    // Should have RUN_STARTED and RUN_FINISHED
+    const types = events.map((e) => e.type);
+    expect(types).toContain(EventType.RUN_STARTED);
+    expect(types).toContain(EventType.RUN_FINISHED);
+
+    // RUN_FINISHED should contain the resource content
+    const runFinished = events.find(
+      (e) => e.type === EventType.RUN_FINISHED,
+    ) as BaseEvent & { result?: unknown };
+    expect(runFinished).toBeDefined();
+    expect(runFinished.result).toBeDefined();
+
+    // The result should contain resource contents
+    const result = runFinished.result as { contents?: unknown[] };
+    expect(result.contents).toBeDefined();
+    expect(Array.isArray(result.contents)).toBe(true);
+
+    const resource = (
+      result.contents as Array<{ uri: string; text?: string }>
+    )[0];
+    expect(resource).toBeDefined();
+    expect(resource.uri).toBe("app://dashboard");
+    expect(resource.text).toContain("Dashboard content here");
+  });
+});

package/src/v2/runtime/core/fetch-handler.ts

@@ -46,6 +46,14 @@ import { handleConnectAgent } from "../handlers/handle-connect";
 import { handleStopAgent } from "../handlers/handle-stop";
 import { handleGetRuntimeInfo } from "../handlers/get-runtime-info";
 import { handleTranscribe } from "../handlers/handle-transcribe";
+import {
+  handleListThreads,
+  handleSubscribeToThreads,
+  handleUpdateThread,
+  handleArchiveThread,
+  handleDeleteThread,
+  handleGetThreadMessages,
+} from "../handlers/handle-threads";
 import {
   parseMethodCall,
   createJsonRequest,
@@ -306,6 +314,31 @@ function dispatchRoute(
       return handleGetRuntimeInfo({ runtime, request });
     case "transcribe":
       return handleTranscribe({ runtime, request });
+    case "threads/list":
+      return handleListThreads({ runtime, request });
+    case "threads/subscribe":
+      return handleSubscribeToThreads({ runtime, request });
+    case "threads/update":
+      if (request.method.toUpperCase() === "DELETE") {
+        return handleDeleteThread({
+          runtime,
+          request,
+          threadId: route.threadId,
+        });
+      }
+      return handleUpdateThread({ runtime, request, threadId: route.threadId });
+    case "threads/archive":
+      return handleArchiveThread({
+        runtime,
+        request,
+        threadId: route.threadId,
+      });
+    case "threads/messages":
+      return handleGetThreadMessages({
+        runtime,
+        request,
+        threadId: route.threadId,
+      });
   }
 }
 
@@ -376,10 +409,28 @@ function validateHttpMethod(
   route: RouteInfo,
 ): Response | null {
   const method = httpMethod.toUpperCase();
-  if (route.method === "info" && method === "GET") return null;
-  if (route.method !== "info" && method === "POST") return null;
-  const allowed = route.method === "info" ? "GET" : "POST";
-  return jsonResponse({ error: "Method not allowed" }, 405, { Allow: allowed });
+
+  switch (route.method) {
+    case "info":
+    case "threads/list":
+    case "threads/messages":
+      if (method === "GET") return null;
+      return jsonResponse({ error: "Method not allowed" }, 405, {
+        Allow: "GET",
+      });
+
+    case "threads/update":
+      if (method === "PATCH" || method === "DELETE") return null;
+      return jsonResponse({ error: "Method not allowed" }, 405, {
+        Allow: "PATCH, DELETE",
+      });
+
+    default:
+      if (method === "POST") return null;
+      return jsonResponse({ error: "Method not allowed" }, 405, {
+        Allow: "POST",
+      });
+  }
 }
 
 /* ------------------------------------------------------------------------------------------------

package/src/v2/runtime/core/fetch-router.ts

@@ -108,5 +108,53 @@ function matchSegments(path: string): RouteInfo | null {
     return { method: "agent/stop", agentId, threadId };
   }
 
+  // /threads/subscribe (2 segments)
+  if (
+    len >= 2 &&
+    segments[len - 2] === "threads" &&
+    segments[len - 1] === "subscribe"
+  ) {
+    return { method: "threads/subscribe" };
+  }
+
+  // /threads/:threadId/messages (3 segments)
+  if (
+    len >= 3 &&
+    segments[len - 3] === "threads" &&
+    segments[len - 1] === "messages"
+  ) {
+    const threadId = safeDecodeURIComponent(segments[len - 2]!);
+    if (!threadId) return null;
+    return { method: "threads/messages", threadId };
+  }
+
+  // /threads/:threadId/archive (3 segments)
+  if (
+    len >= 3 &&
+    segments[len - 3] === "threads" &&
+    segments[len - 1] === "archive"
+  ) {
+    const threadId = safeDecodeURIComponent(segments[len - 2]!);
+    if (!threadId) return null;
+    return { method: "threads/archive", threadId };
+  }
+
+  // /threads/:threadId (2 segments) — update or delete
+  if (
+    len >= 2 &&
+    segments[len - 2] === "threads" &&
+    segments[len - 1] !== "subscribe"
+  ) {
+    const threadId = safeDecodeURIComponent(segments[len - 1]!);
+    if (!threadId) return null;
+    // Disambiguated by HTTP method in the handler
+    return { method: "threads/update", threadId };
+  }
+
+  // /threads (1 segment) — list
+  if (len >= 1 && segments[len - 1] === "threads") {
+    return { method: "threads/list" };
+  }
+
   return null;
 }

package/src/v2/runtime/core/hooks.ts

@@ -38,7 +38,12 @@ export type RouteInfo =
   | { method: "agent/connect"; agentId: string }
   | { method: "agent/stop"; agentId: string; threadId: string }
   | { method: "info" }
-  | { method: "transcribe" };
+  | { method: "transcribe" }
+  | { method: "threads/list" }
+  | { method: "threads/subscribe" }
+  | { method: "threads/update"; threadId: string }
+  | { method: "threads/archive"; threadId: string }
+  | { method: "threads/messages"; threadId: string };
 
 /* ------------------------------------------------------------------------------------------------
  * Hook contexts

package/src/v2/runtime/handlers/handle-threads.ts

@@ -1,6 +1,7 @@
 export {
   handleArchiveThread,
   handleDeleteThread,
+  handleGetThreadMessages,
   handleListThreads,
   handleSubscribeToThreads,
   handleUpdateThread,

package/src/v2/runtime/handlers/intelligence/threads.ts

@@ -231,3 +231,31 @@ export async function handleDeleteThread({
     return errorResponse("Failed to delete thread", 500);
   }
 }
+
+export async function handleGetThreadMessages({
+  runtime,
+  request,
+  threadId,
+}: ThreadMutationParams): Promise<Response> {
+  const intelligenceRuntime = requireIntelligenceRuntime(runtime);
+  if (isHandlerResponse(intelligenceRuntime)) {
+    return intelligenceRuntime;
+  }
+
+  try {
+    const user = await resolveIntelligenceUser({
+      runtime: intelligenceRuntime,
+      request,
+    });
+    if (isHandlerResponse(user)) return user;
+
+    const data = await intelligenceRuntime.intelligence.getThreadMessages({
+      threadId,
+    });
+
+    return Response.json(data);
+  } catch (error) {
+    logger.error({ err: error, threadId }, "Error getting thread messages");
+    return errorResponse("Failed to get thread messages", 500);
+  }
+}