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

package/src/lib/runtime/__tests__/handle-service-adapter.test.ts

@@ -0,0 +1,108 @@
+import type { LanguageModel } from "ai";
+import { CopilotKitMisuseError } from "@copilotkit/shared";
+import { describe, expect, it } from "vitest";
+import { BuiltInAgent } from "../../../agent";
+import type { CopilotServiceAdapter } from "../../../service-adapters";
+import { CopilotRuntime } from "../copilot-runtime";
+
+function makeAdapter(
+  overrides?: Partial<CopilotServiceAdapter>,
+): CopilotServiceAdapter {
+  return {
+    name: "TestAdapter",
+    async process() {
+      throw new Error("process() is not expected to be called in these tests");
+    },
+    ...overrides,
+  };
+}
+
+async function getDefaultAgent(runtime: CopilotRuntime) {
+  const agents = await runtime.instance.agents;
+  return agents.default;
+}
+
+// `BuiltInAgent.config` is private; reading it is the only way to verify the
+// correct model was passed through without running the entire agent pipeline.
+// This narrow accessor is the Rule 2 exception, documented here once rather
+// than inline at each call site.
+function getBuiltInAgentModel(agent: BuiltInAgent): unknown {
+  return (agent as unknown as { config: { model: unknown } }).config.model;
+}
+
+describe("CopilotRuntime#handleServiceAdapter (#3217)", () => {
+  it("uses the adapter's pre-configured LanguageModel when getLanguageModel() returns one", async () => {
+    const fakeLanguageModel = {
+      specificationVersion: "v1",
+    } as unknown as LanguageModel;
+    const runtime = new CopilotRuntime();
+
+    runtime.handleServiceAdapter(
+      makeAdapter({
+        name: "OpenAIAdapter",
+        provider: "openai",
+        model: "gpt-4o",
+        getLanguageModel: () => fakeLanguageModel,
+      }),
+    );
+
+    const agent = await getDefaultAgent(runtime);
+    expect(agent).toBeInstanceOf(BuiltInAgent);
+    expect(getBuiltInAgentModel(agent as BuiltInAgent)).toBe(fakeLanguageModel);
+  });
+
+  it("builds a 'provider/model' string when only provider+model are exposed", async () => {
+    const runtime = new CopilotRuntime();
+
+    runtime.handleServiceAdapter(
+      makeAdapter({
+        name: "GroqAdapter",
+        provider: "groq",
+        model: "llama-3.3-70b-versatile",
+      }),
+    );
+
+    const agent = await getDefaultAgent(runtime);
+    expect(agent).toBeInstanceOf(BuiltInAgent);
+    expect(getBuiltInAgentModel(agent as BuiltInAgent)).toBe(
+      "groq/llama-3.3-70b-versatile",
+    );
+  });
+
+  it("throws CopilotKitMisuseError when no model source is available (LangChainAdapter regression)", async () => {
+    const runtime = new CopilotRuntime();
+
+    runtime.handleServiceAdapter(makeAdapter({ name: "LangChainAdapter" }));
+
+    await expect(runtime.instance.agents).rejects.toBeInstanceOf(
+      CopilotKitMisuseError,
+    );
+    await expect(runtime.instance.agents).rejects.toThrow(
+      /Service adapter "LangChainAdapter" does not provide model information/,
+    );
+  });
+
+  it("falls back to 'unknown' in the thrown error when the adapter has no name", async () => {
+    const runtime = new CopilotRuntime();
+
+    runtime.handleServiceAdapter(makeAdapter({ name: undefined }));
+
+    await expect(runtime.instance.agents).rejects.toThrow(
+      /Service adapter "unknown" does not provide model information/,
+    );
+  });
+
+  it("does not throw when provider is set without a model — but must not emit 'undefined/undefined'", async () => {
+    // Guards the specific #3217 regression: when only one half of the pair is
+    // present, we must NOT synthesize a bogus "provider/undefined" string.
+    const runtime = new CopilotRuntime();
+
+    runtime.handleServiceAdapter(
+      makeAdapter({ name: "PartialAdapter", provider: "openai" }),
+    );
+
+    await expect(runtime.instance.agents).rejects.toThrow(
+      CopilotKitMisuseError,
+    );
+  });
+});

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

@@ -110,10 +110,14 @@ describe("MCP Tools Utils", () => {
       });
       expect(result[1]).toEqual({
         name: "objectArray",
-        type: "array",
+        type: "object[]",
         description:
           "Array of objects Array of objects with properties: name, value",
         required: false,
+        attributes: [
+          { name: "name", type: "string", description: "", required: false },
+          { name: "value", type: "number", description: "", required: false },
+        ],
       });
     });
 
@@ -147,6 +151,7 @@ describe("MCP Tools Utils", () => {
         type: "string",
         description: "Status value Allowed values: active | inactive | pending",
         required: true,
+        enum: ["active", "inactive", "pending"],
       });
       expect(result[1]).toEqual({
         name: "priority",
@@ -192,6 +197,30 @@ describe("MCP Tools Utils", () => {
         description:
           "User object Object with properties: name, email, preferences",
         required: true,
+        attributes: [
+          { name: "name", type: "string", description: "", required: false },
+          { name: "email", type: "string", description: "", required: false },
+          {
+            name: "preferences",
+            type: "object",
+            description: "Object with properties: theme, notifications",
+            required: false,
+            attributes: [
+              {
+                name: "theme",
+                type: "string",
+                description: "",
+                required: false,
+              },
+              {
+                name: "notifications",
+                type: "boolean",
+                description: "",
+                required: false,
+              },
+            ],
+          },
+        ],
       });
     });
 

package/src/lib/runtime/__tests__/on-after-request.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi } from "vitest";
+import { CopilotRuntime } from "../copilot-runtime";
+
+describe("onAfterRequest middleware (#2124)", () => {
+  it("should pass hookParams to onAfterRequest, not an empty object", async () => {
+    const onAfterRequest = vi.fn();
+
+    const runtime = new CopilotRuntime({
+      middleware: {
+        onAfterRequest,
+      },
+    });
+
+    // Access the internal afterRequestMiddleware function
+    const afterRequestMw = runtime.instance.afterRequestMiddleware;
+    expect(afterRequestMw).toBeDefined();
+
+    // Simulate calling the middleware with hookParams (as the v2 runtime would)
+    const fakeHookParams = {
+      runtime: {} as any,
+      response: new Response("test"),
+      path: "/api/copilotkit",
+      messages: [
+        { id: "msg-1", role: "user", content: "Hi there" },
+        { id: "msg-2", role: "assistant", content: "Hello" },
+        { id: "msg-3", role: "tool", content: "result", toolCallId: "tc-1" },
+      ],
+      threadId: "thread-123",
+      runId: "run-456",
+    };
+
+    await (afterRequestMw as Function)(fakeHookParams);
+
+    expect(onAfterRequest).toHaveBeenCalledTimes(1);
+
+    const callArg = onAfterRequest.mock.calls[0][0];
+
+    // Should NOT be called with an empty object
+    expect(callArg).not.toEqual({});
+
+    // Verify all OnAfterRequestOptions fields are present
+    expect(callArg).toHaveProperty("threadId", "thread-123");
+    expect(callArg).toHaveProperty("runId", "run-456");
+    expect(callArg).toHaveProperty("url", "/api/copilotkit");
+    expect(callArg).toHaveProperty("properties");
+    expect(callArg.properties).toEqual({});
+
+    // Verify message splitting: user messages → inputMessages, others → outputMessages
+    expect(callArg.inputMessages).toHaveLength(1);
+    expect(callArg.inputMessages[0]).toMatchObject({
+      id: "msg-1",
+      role: "user",
+    });
+
+    expect(callArg.outputMessages).toHaveLength(2);
+    expect(callArg.outputMessages[0]).toMatchObject({
+      id: "msg-2",
+      role: "assistant",
+    });
+    expect(callArg.outputMessages[1]).toMatchObject({
+      id: "msg-3",
+      role: "tool",
+    });
+  });
+
+  it("should handle undefined messages gracefully", async () => {
+    const onAfterRequest = vi.fn();
+
+    const runtime = new CopilotRuntime({
+      middleware: {
+        onAfterRequest,
+      },
+    });
+
+    const afterRequestMw = runtime.instance.afterRequestMiddleware;
+
+    const fakeHookParams = {
+      runtime: {} as any,
+      response: new Response("test"),
+      path: "/api/copilotkit",
+      // messages intentionally omitted (undefined)
+      threadId: "thread-789",
+    };
+
+    await (afterRequestMw as Function)(fakeHookParams);
+
+    expect(onAfterRequest).toHaveBeenCalledTimes(1);
+
+    const callArg = onAfterRequest.mock.calls[0][0];
+    expect(callArg.threadId).toBe("thread-789");
+    expect(callArg.inputMessages).toEqual([]);
+    expect(callArg.outputMessages).toEqual([]);
+  });
+
+  it("should default threadId to empty string when undefined", async () => {
+    const onAfterRequest = vi.fn();
+
+    const runtime = new CopilotRuntime({
+      middleware: {
+        onAfterRequest,
+      },
+    });
+
+    const afterRequestMw = runtime.instance.afterRequestMiddleware;
+
+    const fakeHookParams = {
+      runtime: {} as any,
+      response: new Response("test"),
+      path: "/api/copilotkit",
+      messages: [],
+      // threadId intentionally omitted
+    };
+
+    await (afterRequestMw as Function)(fakeHookParams);
+
+    expect(onAfterRequest).toHaveBeenCalledTimes(1);
+
+    const callArg = onAfterRequest.mock.calls[0][0];
+    expect(callArg.threadId).toBe("");
+    expect(callArg.runId).toBeUndefined();
+  });
+});

package/src/lib/runtime/__tests__/retry-utils.test.ts

@@ -0,0 +1,137 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { fetchWithRetry, parseRetryAfter, RETRY_CONFIG } from "../retry-utils";
+
+function responseWithRetryAfter(
+  headerValue: string | null,
+  status = 429,
+): Response {
+  const headers = new Headers();
+  if (headerValue !== null) headers.set("Retry-After", headerValue);
+  return new Response(null, { status, headers });
+}
+
+describe("parseRetryAfter", () => {
+  it("returns undefined when the Retry-After header is absent", () => {
+    expect(parseRetryAfter(responseWithRetryAfter(null))).toBeUndefined();
+  });
+
+  it("parses integer seconds into milliseconds", () => {
+    expect(parseRetryAfter(responseWithRetryAfter("5"))).toBe(5000);
+  });
+
+  it("treats zero seconds as zero delay", () => {
+    expect(parseRetryAfter(responseWithRetryAfter("0"))).toBe(0);
+  });
+
+  it("clamps a negative numeric value to zero", () => {
+    // `-1` fails the `seconds >= 0` guard and falls through to Date.parse,
+    // which interprets it as a year-in-the-past timestamp; the past-date
+    // branch then clamps to 0. The behavior is lenient rather than strict.
+    expect(parseRetryAfter(responseWithRetryAfter("-1"))).toBe(0);
+  });
+
+  it("parses an HTTP-date in the future as the delta to now", () => {
+    const now = Date.parse("2026-04-22T12:00:00Z");
+    vi.useFakeTimers();
+    vi.setSystemTime(now);
+    try {
+      const future = new Date(now + 30_000).toUTCString();
+      expect(parseRetryAfter(responseWithRetryAfter(future))).toBe(30_000);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("clamps an HTTP-date in the past to zero", () => {
+    const now = Date.parse("2026-04-22T12:00:00Z");
+    vi.useFakeTimers();
+    vi.setSystemTime(now);
+    try {
+      const past = new Date(now - 60_000).toUTCString();
+      expect(parseRetryAfter(responseWithRetryAfter(past))).toBe(0);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("returns undefined for unparseable values", () => {
+    expect(parseRetryAfter(responseWithRetryAfter("soon"))).toBeUndefined();
+  });
+});
+
+describe("fetchWithRetry Retry-After handling (#3637)", () => {
+  let fetchMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+  });
+
+  it("honors Retry-After within the allowed maximum on 429", async () => {
+    fetchMock
+      .mockResolvedValueOnce(responseWithRetryAfter("2"))
+      .mockResolvedValueOnce(new Response("ok", { status: 200 }));
+
+    const promise = fetchWithRetry("https://example.com", {});
+    await vi.advanceTimersByTimeAsync(1999);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    await vi.advanceTimersByTimeAsync(1);
+    const response = await promise;
+
+    expect(response.status).toBe(200);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("throws when Retry-After exceeds maxRetryAfterSeconds", async () => {
+    const excessive = RETRY_CONFIG.maxRetryAfterSeconds + 1;
+    fetchMock.mockResolvedValue(responseWithRetryAfter(String(excessive)));
+
+    // The oversized-Retry-After branch throws before sleeping, and the
+    // resulting Error doesn't match any retryable pattern, so the loop
+    // breaks out without consuming the remaining attempts.
+    await expect(fetchWithRetry("https://example.com", {})).rejects.toThrow(
+      new RegExp(
+        `Retry-After of ${excessive}s.*exceeds the maximum of ${RETRY_CONFIG.maxRetryAfterSeconds}s`,
+      ),
+    );
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("falls back to exponential backoff when Retry-After is missing on 429", async () => {
+    fetchMock
+      .mockResolvedValueOnce(new Response(null, { status: 429 }))
+      .mockResolvedValueOnce(new Response("ok", { status: 200 }));
+
+    const promise = fetchWithRetry("https://example.com", {});
+    // calculateDelay(0) === RETRY_CONFIG.baseDelayMs
+    await vi.advanceTimersByTimeAsync(RETRY_CONFIG.baseDelayMs - 1);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    await vi.advanceTimersByTimeAsync(1);
+    const response = await promise;
+
+    expect(response.status).toBe(200);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("ignores Retry-After on non-429 retryable responses (e.g. 503)", async () => {
+    const longRetryAfter = String(RETRY_CONFIG.maxRetryAfterSeconds + 600);
+    fetchMock
+      .mockResolvedValueOnce(responseWithRetryAfter(longRetryAfter, 503))
+      .mockResolvedValueOnce(new Response("ok", { status: 200 }));
+
+    const promise = fetchWithRetry("https://example.com", {});
+    // Exponential backoff applies, not the header value — otherwise this
+    // would wait 10 minutes and the test would time out.
+    await vi.advanceTimersByTimeAsync(RETRY_CONFIG.baseDelayMs);
+    const response = await promise;
+
+    expect(response.status).toBe(200);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+});

package/src/lib/runtime/agent-integrations/langgraph/__tests__/dispatch-event-filtering.test.ts

@@ -1,5 +1,7 @@
 import { EventType } from "@ag-ui/client";
 import { LangGraphAgent } from "../agent";
+import { CustomEventNames } from "../consts";
+import { vi } from "vitest";
 
 function createAgent() {
   const agent = new LangGraphAgent({
@@ -33,6 +35,25 @@ function makeTextEvent(
   };
 }
 
+function makeCustomEvent(name: string, value: any) {
+  return {
+    type: EventType.CUSTOM,
+    name,
+    value,
+  } as any;
+}
+
+/**
+ * Mock the parent class's langGraphDefaultMergeState for a single test,
+ * using vi.spyOn for automatic cleanup.
+ */
+function withMockedParentMerge(agent: LangGraphAgent, returnValue: any) {
+  const parentProto = Object.getPrototypeOf(Object.getPrototypeOf(agent));
+  return vi
+    .spyOn(parentProto, "langGraphDefaultMergeState")
+    .mockReturnValue(returnValue);
+}
+
 describe("dispatchEvent emit-messages filtering", () => {
   it("suppresses message events when copilotkit:emit-messages is false", () => {
     const { agent, events } = createAgent();
@@ -153,3 +174,172 @@ describe("dispatchEvent emit-tool-calls filtering", () => {
     expect(events).toHaveLength(1);
   });
 });
+
+// ---------- CopilotKit custom event dispatch ----------
+
+describe("dispatchEvent custom CopilotKit events", () => {
+  it("manually_emit_message produces TextMessage event sequence", () => {
+    const { agent, events } = createAgent();
+
+    const result = agent.dispatchEvent(
+      makeCustomEvent(CustomEventNames.CopilotKitManuallyEmitMessage, {
+        message_id: "msg-manual-1",
+        message: "Hello from agent",
+        role: "assistant",
+      }),
+    );
+
+    expect(result).toBe(true);
+    expect(events).toHaveLength(3);
+    expect(events[0].type).toBe(EventType.TEXT_MESSAGE_START);
+    expect(events[0].messageId).toBe("msg-manual-1");
+    expect(events[0].role).toBe("assistant");
+    expect(events[1].type).toBe(EventType.TEXT_MESSAGE_CONTENT);
+    expect(events[1].delta).toBe("Hello from agent");
+    expect(events[2].type).toBe(EventType.TEXT_MESSAGE_END);
+    expect(events[2].messageId).toBe("msg-manual-1");
+  });
+
+  it("manually_emit_tool_call produces ToolCall event sequence", () => {
+    const { agent, events } = createAgent();
+
+    const result = agent.dispatchEvent(
+      makeCustomEvent(CustomEventNames.CopilotKitManuallyEmitToolCall, {
+        id: "tc-manual-1",
+        name: "SearchTool",
+        args: { query: "test" },
+      }),
+    );
+
+    expect(result).toBe(true);
+    expect(events).toHaveLength(3);
+    expect(events[0].type).toBe(EventType.TOOL_CALL_START);
+    expect(events[0].toolCallId).toBe("tc-manual-1");
+    expect(events[0].toolCallName).toBe("SearchTool");
+    expect(events[1].type).toBe(EventType.TOOL_CALL_ARGS);
+    expect(events[1].toolCallId).toBe("tc-manual-1");
+    expect(events[1].delta).toEqual({ query: "test" });
+    expect(events[2].type).toBe(EventType.TOOL_CALL_END);
+    expect(events[2].toolCallId).toBe("tc-manual-1");
+  });
+
+  it("manually_emit_state produces StateSnapshot event", () => {
+    const { agent, events } = createAgent();
+
+    // Mock getStateSnapshot since it depends on thread state
+    (agent as any).getStateSnapshot = (state: any) => ({
+      values: state.values,
+    });
+
+    const result = agent.dispatchEvent(
+      makeCustomEvent(
+        CustomEventNames.CopilotKitManuallyEmitIntermediateState,
+        {
+          progress: 75,
+        },
+      ),
+    );
+
+    expect(result).toBe(true);
+    expect((agent as any).activeRun.manuallyEmittedState).toEqual({
+      progress: 75,
+    });
+    const snapshotEvents = events.filter(
+      (e) => e.type === EventType.STATE_SNAPSHOT,
+    );
+    expect(snapshotEvents.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it("copilotkit_exit produces Exit custom event", () => {
+    const { agent, events } = createAgent();
+
+    const result = agent.dispatchEvent(
+      makeCustomEvent(CustomEventNames.CopilotKitExit, {}),
+    );
+
+    expect(result).toBe(true);
+    expect(events).toHaveLength(1);
+    expect(events[0].type).toBe(EventType.CUSTOM);
+    // "Exit" is the hardcoded downstream name in agent.ts — not a constant,
+    // because it's the value the frontend listens for, not an internal enum.
+    expect(events[0].name).toBe("Exit");
+    expect(events[0].value).toBe(true);
+  });
+
+  it("events without rawEvent pass through to subscriber", () => {
+    const { agent, events } = createAgent();
+
+    const result = agent.dispatchEvent({
+      type: EventType.TEXT_MESSAGE_START,
+      messageId: "msg-no-raw",
+      role: "assistant",
+    } as any);
+
+    expect(result).toBe(true);
+    expect(events).toHaveLength(1);
+    expect(events[0].messageId).toBe("msg-no-raw");
+  });
+});
+
+// ---------- langGraphDefaultMergeState ----------
+
+describe("langGraphDefaultMergeState", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("merges copilotkit actions from ag-ui tools", () => {
+    const { agent } = createAgent();
+    const tools = [{ name: "tool1" }, { name: "tool2" }];
+
+    withMockedParentMerge(agent, {
+      "ag-ui": { tools, context: [] },
+      tools: [],
+      messages: [],
+    });
+
+    const result = agent.langGraphDefaultMergeState({} as any, [], {} as any);
+    expect(result.copilotkit).toBeDefined();
+    expect(result.copilotkit.actions).toEqual(expect.arrayContaining(tools));
+  });
+
+  it("merges copilotkit context from ag-ui", () => {
+    const { agent } = createAgent();
+    const context = [{ description: "user info", value: "test" }];
+
+    withMockedParentMerge(agent, {
+      "ag-ui": { tools: [], context },
+      tools: [],
+      messages: [],
+    });
+
+    const result = agent.langGraphDefaultMergeState({} as any, [], {} as any);
+    expect(result.copilotkit.context).toEqual(context);
+  });
+
+  it("handles missing ag-ui key without crashing", () => {
+    const { agent } = createAgent();
+
+    withMockedParentMerge(agent, { messages: [] });
+
+    const result = agent.langGraphDefaultMergeState({} as any, [], {} as any);
+    expect(result.copilotkit).toBeDefined();
+    expect(result.copilotkit.actions).toEqual([]);
+    expect(result.copilotkit.context).toEqual([]);
+  });
+
+  it("deduplicates tools from returnedTools and ag-ui tools", () => {
+    const { agent } = createAgent();
+    const tool = { name: "SharedTool", id: "shared-1" };
+
+    withMockedParentMerge(agent, {
+      "ag-ui": { tools: [tool], context: [] },
+      tools: [tool],
+      messages: [],
+    });
+
+    const result = agent.langGraphDefaultMergeState({} as any, [], {} as any);
+    expect(result.copilotkit.actions).toHaveLength(1);
+    expect(result.copilotkit.actions[0].name).toBe("SharedTool");
+  });
+});

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

@@ -463,10 +463,26 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       }
 
       if (isAgentsListEmpty) {
-        const model =
-          serviceAdapter.getLanguageModel?.() ??
-          `${serviceAdapter.provider}/${serviceAdapter.model}`;
-        agentsList.default = new BuiltInAgent({ model });
+        const languageModel = serviceAdapter.getLanguageModel?.();
+        if (languageModel) {
+          // Adapter exposes a pre-configured LanguageModel (e.g. OpenAI/Anthropic adapters)
+          agentsList.default = new BuiltInAgent({ model: languageModel });
+        } else if (serviceAdapter.provider && serviceAdapter.model) {
+          // Adapter exposes provider/model strings
+          agentsList.default = new BuiltInAgent({
+            model: `${serviceAdapter.provider}/${serviceAdapter.model}`,
+          });
+        } else {
+          throw new CopilotKitMisuseError({
+            message:
+              `Service adapter "${serviceAdapter.name ?? "unknown"}" does not provide model information. ` +
+              `When using adapters like LangChainAdapter without an explicit agents list, ` +
+              `please provide a default agent in the runtime config. Example:\n` +
+              `  new CopilotRuntime({\n` +
+              `    agents: { default: new BuiltInAgent({ model: "openai/gpt-4o" }) }\n` +
+              `  })`,
+          });
+        }
       }
 
       const actions = this.params?.actions;
@@ -626,9 +642,22 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       params?.afterRequestMiddleware?.(hookParams);
 
       if (params?.middleware?.onAfterRequest) {
-        // TODO: provide old expected params here when available
-        // @ts-expect-error -- missing arguments.
-        params.middleware.onAfterRequest({});
+        const messages = hookParams.messages ?? [];
+        params.middleware.onAfterRequest({
+          threadId: hookParams.threadId ?? "",
+          runId: hookParams.runId,
+          inputMessages: messages.filter(
+            (m): m is typeof m & { role: string } =>
+              "role" in m && m.role === "user",
+          ) as unknown as Message[],
+          outputMessages: messages.filter(
+            (m): m is typeof m & { role: string } =>
+              "role" in m && m.role !== "user",
+          ) as unknown as Message[],
+          // TODO: forward actual properties once the after-request hook has access to the request body
+          properties: {},
+          url: hookParams.path,
+        } satisfies OnAfterRequestOptions);
       }
     };
   }