@copilotkit/runtime 1.55.1 → 1.55.2-next.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @copilotkit/runtime
 
+## 1.55.2-next.0
+
+### Patch Changes
+
+- @copilotkit/shared@1.55.2-next.0
+
 ## 1.55.1
 
 ### Patch Changes

package/dist/package.cjs

@@ -5,7 +5,7 @@ const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
 var require_package = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
 	module.exports = {
 		"name": "@copilotkit/runtime",
-		"version": "1.55.1",
+		"version": "1.55.2-next.0",
 		"private": false,
 		"keywords": [
 			"ai",
@@ -81,7 +81,7 @@ var require_package = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, m
 			"attw": "attw --pack . --profile node16"
 		},
 		"dependencies": {
-			"@ag-ui/a2ui-middleware": "0.0.3",
+			"@ag-ui/a2ui-middleware": "0.0.4",
 			"@ag-ui/client": "0.0.52",
 			"@ag-ui/core": "0.0.52",
 			"@ag-ui/encoder": "0.0.52",
@@ -123,6 +123,7 @@ var require_package = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, m
 			"zod": "^3.23.3"
 		},
 		"devDependencies": {
+			"@copilotkit/aimock": "^1.10.0",
 			"@swc/core": "1.5.28",
 			"@types/cors": "^2.8.17",
 			"@types/express": "^4.17.21",

package/dist/package.mjs

@@ -5,7 +5,7 @@ import { __commonJSMin } from "./_virtual/_rolldown/runtime.mjs";
 var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = {
 		"name": "@copilotkit/runtime",
-		"version": "1.55.1",
+		"version": "1.55.2-next.0",
 		"private": false,
 		"keywords": [
 			"ai",
@@ -81,7 +81,7 @@ var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			"attw": "attw --pack . --profile node16"
 		},
 		"dependencies": {
-			"@ag-ui/a2ui-middleware": "0.0.3",
+			"@ag-ui/a2ui-middleware": "0.0.4",
 			"@ag-ui/client": "0.0.52",
 			"@ag-ui/core": "0.0.52",
 			"@ag-ui/encoder": "0.0.52",
@@ -123,6 +123,7 @@ var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			"zod": "^3.23.3"
 		},
 		"devDependencies": {
+			"@copilotkit/aimock": "^1.10.0",
 			"@swc/core": "1.5.28",
 			"@types/cors": "^2.8.17",
 			"@types/express": "^4.17.21",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/runtime",
-  "version": "1.55.1",
+  "version": "1.55.2-next.0",
   "private": false,
   "keywords": [
     "ai",
@@ -76,7 +76,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@ag-ui/a2ui-middleware": "0.0.3",
+    "@ag-ui/a2ui-middleware": "0.0.4",
     "@ag-ui/client": "0.0.52",
     "@ag-ui/core": "0.0.52",
     "@ag-ui/encoder": "0.0.52",
@@ -115,9 +115,10 @@
     "uuid": "^10.0.0",
     "ws": "^8.18.0",
     "zod": "^3.23.3",
-    "@copilotkit/shared": "1.55.1"
+    "@copilotkit/shared": "1.55.2-next.0"
   },
   "devDependencies": {
+    "@copilotkit/aimock": "^1.10.0",
     "@swc/core": "1.5.28",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",

package/src/agent/__tests__/mcp-servers-integration.test.ts

@@ -0,0 +1,373 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { BasicAgent } from "../index";
+import { EventType } from "@ag-ui/client";
+import { streamText } from "ai";
+import { LLMock, MCPMock } from "@copilotkit/aimock";
+import {
+  mockStreamTextResponse,
+  textDelta,
+  finish,
+  collectEvents,
+  toolCall,
+  toolResult,
+} from "./test-helpers";
+
+// Mock the ai module — we don't want real LLM calls
+vi.mock("ai", () => ({
+  streamText: vi.fn(),
+  tool: vi.fn((config) => config),
+  stepCountIs: vi.fn((count: number) => ({ type: "stepCount", count })),
+}));
+
+vi.mock("@ai-sdk/openai", () => ({
+  createOpenAI: vi.fn(() => (modelId: string) => ({
+    modelId,
+    provider: "openai",
+  })),
+}));
+
+// Do NOT mock @ai-sdk/mcp or @modelcontextprotocol/sdk transports —
+// we want real HTTP connections to the MCPMock server.
+
+describe("mcpServers — real MCP server integration", () => {
+  const originalEnv = process.env;
+  let llm: LLMock;
+  let mcpMock: MCPMock;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env = { ...originalEnv };
+    process.env.OPENAI_API_KEY = "test-key";
+  });
+
+  afterEach(async () => {
+    process.env = originalEnv;
+    if (llm) {
+      await llm.stop().catch(() => {});
+    }
+  });
+
+  const baseInput = {
+    threadId: "thread1",
+    runId: "run1",
+    messages: [],
+    tools: [],
+    context: [],
+    state: {},
+  };
+
+  /**
+   * Start an LLMock with an MCPMock mounted at /mcp.
+   * Returns the full MCP endpoint URL.
+   */
+  async function startMcpServer(
+    tools: Array<{ name: string; description?: string }>,
+  ): Promise<{ mcpUrl: string; llm: LLMock; mcpMock: MCPMock }> {
+    const mock = new MCPMock();
+    for (const t of tools) {
+      mock.addTool({
+        name: t.name,
+        description: t.description ?? `${t.name} tool`,
+        inputSchema: {
+          type: "object",
+          properties: { query: { type: "string" } },
+        },
+      });
+      mock.onToolCall(t.name, () => `result from ${t.name}`);
+    }
+
+    const server = new LLMock({ port: 0 });
+    server.mount("/mcp", mock);
+    await server.start();
+
+    return {
+      mcpUrl: `${server.url}/mcp`,
+      llm: server,
+      mcpMock: mock,
+    };
+  }
+
+  it("HTTP transport fetches tools from MCPMock", async () => {
+    const result = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result.llm;
+    mcpMock = result.mcpMock;
+
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "http", url: result.mcpUrl }],
+    });
+
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([textDelta("Hello"), finish()]) as any,
+    );
+
+    await collectEvents(agent["run"](baseInput));
+
+    const callArgs = vi.mocked(streamText).mock.calls[0][0];
+    expect(callArgs.tools).toHaveProperty("get_weather");
+  });
+
+  it("SSE transport against MCPMock emits RUN_ERROR or completes without crash", async () => {
+    // MCPMock only supports Streamable HTTP, not SSE.
+    // The agent should emit RUN_ERROR when SSE connection fails.
+    const result = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result.llm;
+    mcpMock = result.mcpMock;
+
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "sse", url: result.mcpUrl }],
+    });
+
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([finish()]) as any,
+    );
+
+    // Collect events manually — the Observable may error after emitting RUN_ERROR
+    const events: any[] = [];
+    try {
+      await new Promise((resolve, reject) => {
+        agent["run"](baseInput).subscribe({
+          next: (event: any) => events.push(event),
+          error: (err: any) => reject(err),
+          complete: () => resolve(events),
+        });
+      });
+      // If it completes without error, that's also acceptable (graceful fallthrough)
+    } catch {
+      // Expected — SSE transport failure should emit RUN_ERROR then error
+    }
+
+    const hasRunError = events.some((e) => e.type === EventType.RUN_ERROR);
+    // Either we got a RUN_ERROR or streamText was never called (connection failed before tools fetch)
+    expect(hasRunError || !vi.mocked(streamText).mock.calls.length).toBe(true);
+  });
+
+  it("tool call round-trip emits TOOL_CALL_START, TOOL_CALL_RESULT, and TEXT_MESSAGE_CHUNK", async () => {
+    const result = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result.llm;
+    mcpMock = result.mcpMock;
+
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "http", url: result.mcpUrl }],
+    });
+
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([
+        toolCall("tc1", "get_weather", { query: "NYC" }),
+        toolResult("tc1", "get_weather", "Sunny 72F"),
+        textDelta("The weather is sunny."),
+        finish(),
+      ]) as any,
+    );
+
+    const events = await collectEvents(agent["run"](baseInput));
+
+    const types = events.map((e: any) => e.type);
+    expect(types).toContain(EventType.TOOL_CALL_START);
+    expect(types).toContain(EventType.TOOL_CALL_RESULT);
+    expect(types).toContain(EventType.TEXT_MESSAGE_CHUNK);
+
+    // Verify the tool call result content
+    const resultEvent = events.find(
+      (e: any) => e.type === EventType.TOOL_CALL_RESULT,
+    ) as any;
+    expect(resultEvent.toolCallId).toBe("tc1");
+    expect(resultEvent.content).toContain("Sunny 72F");
+  });
+
+  it("MCP clients are cleaned up after completion — second run creates fresh connections", async () => {
+    const result = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result.llm;
+    mcpMock = result.mcpMock;
+
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "http", url: result.mcpUrl }],
+    });
+
+    // First run
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([textDelta("Run 1"), finish()]) as any,
+    );
+    const events1 = await collectEvents(agent["run"](baseInput));
+    expect(events1.some((e: any) => e.type === EventType.RUN_FINISHED)).toBe(
+      true,
+    );
+
+    // Second run — should succeed with fresh MCP client connections
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([textDelta("Run 2"), finish()]) as any,
+    );
+    const events2 = await collectEvents(agent["run"](baseInput));
+    expect(events2.some((e: any) => e.type === EventType.RUN_FINISHED)).toBe(
+      true,
+    );
+
+    // streamText was called twice (once per run), each time with MCP tools
+    expect(vi.mocked(streamText).mock.calls).toHaveLength(2);
+    expect(vi.mocked(streamText).mock.calls[0][0].tools).toHaveProperty(
+      "get_weather",
+    );
+    expect(vi.mocked(streamText).mock.calls[1][0].tools).toHaveProperty(
+      "get_weather",
+    );
+  });
+
+  it("unreachable MCP server emits RUN_ERROR", async () => {
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "http", url: "http://localhost:59999" }],
+    });
+
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([finish()]) as any,
+    );
+
+    const events: any[] = [];
+    try {
+      await new Promise((resolve, reject) => {
+        agent["run"](baseInput).subscribe({
+          next: (event: any) => events.push(event),
+          error: (err: any) => reject(err),
+          complete: () => resolve(events),
+        });
+      });
+    } catch {
+      // Expected — connection refused should cause an error
+    }
+
+    expect(events.some((e) => e.type === EventType.RUN_ERROR)).toBe(true);
+    // streamText should not have been called since MCP init failed
+    expect(streamText).not.toHaveBeenCalled();
+  });
+
+  it("MCP clients are cleaned up after streamText error — subsequent run still works", async () => {
+    const result = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result.llm;
+    mcpMock = result.mcpMock;
+
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "http", url: result.mcpUrl }],
+    });
+
+    // First run — streamText throws an error
+    vi.mocked(streamText).mockImplementation(() => {
+      throw new Error("LLM connection failed");
+    });
+
+    const events1: any[] = [];
+    try {
+      await new Promise((resolve, reject) => {
+        agent["run"](baseInput).subscribe({
+          next: (event: any) => events1.push(event),
+          error: (err: any) => reject(err),
+          complete: () => resolve(events1),
+        });
+      });
+    } catch {
+      // Expected — streamText threw
+    }
+
+    // Should have emitted RUN_ERROR
+    expect(events1.some((e) => e.type === EventType.RUN_ERROR)).toBe(true);
+
+    // Second run — streamText works normally, proving MCP cleanup happened
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([textDelta("Recovery"), finish()]) as any,
+    );
+    const events2 = await collectEvents(agent["run"](baseInput));
+    expect(events2.some((e: any) => e.type === EventType.RUN_FINISHED)).toBe(
+      true,
+    );
+
+    // The second run should have MCP tools available
+    const secondCallArgs = vi.mocked(streamText).mock.calls[1][0];
+    expect(secondCallArgs.tools).toHaveProperty("get_weather");
+  });
+
+  it("MCP tool descriptions are passed to streamText tools config", async () => {
+    const result = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result.llm;
+    mcpMock = result.mcpMock;
+
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "http", url: result.mcpUrl }],
+    });
+
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([textDelta("Hello"), finish()]) as any,
+    );
+
+    await collectEvents(agent["run"](baseInput));
+
+    const callArgs = vi.mocked(streamText).mock.calls[0][0];
+    expect(callArgs.tools).toHaveProperty("get_weather");
+    // The MCP tool should include the description from the MCPMock server
+    expect(callArgs.tools.get_weather.description).toBe("Get the weather");
+  });
+
+  it("multiple MCP servers merge tools from both", async () => {
+    // First server with get_weather
+    const result1 = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result1.llm;
+
+    // Second server with search_docs
+    const mock2 = new MCPMock();
+    mock2.addTool({
+      name: "search_docs",
+      description: "Search documentation",
+      inputSchema: {
+        type: "object",
+        properties: { query: { type: "string" } },
+      },
+    });
+    mock2.onToolCall("search_docs", () => "doc results");
+
+    const llm2 = new LLMock({ port: 0 });
+    llm2.mount("/mcp", mock2);
+    await llm2.start();
+
+    try {
+      const agent = new BasicAgent({
+        model: "openai/gpt-4o",
+        mcpServers: [
+          { type: "http", url: result1.mcpUrl },
+          { type: "http", url: `${llm2.url}/mcp` },
+        ],
+      });
+
+      vi.mocked(streamText).mockReturnValue(
+        mockStreamTextResponse([
+          textDelta("Both tools available"),
+          finish(),
+        ]) as any,
+      );
+
+      await collectEvents(agent["run"](baseInput));
+
+      const callArgs = vi.mocked(streamText).mock.calls[0][0];
+      expect(callArgs.tools).toHaveProperty("get_weather");
+      expect(callArgs.tools).toHaveProperty("search_docs");
+    } finally {
+      await llm2.stop().catch(() => {});
+    }
+  });
+});

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");
+  });
+});