@copilotkit/runtime 1.71.0 → 1.71.1

package/skills/runtime/references/agent-runners.md

@@ -1,336 +0,0 @@
-# CopilotKit Agent Runners
-
-`AgentRunner` is the abstraction that owns thread run state — active runs, the event stream
-replay, and stop semantics. Pick one per `CopilotRuntime` instance.
-
-- `InMemoryAgentRunner` — default; process-global in-memory Map; lost on restart.
-- `SqliteAgentRunner` — file-backed; requires `better-sqlite3` peer.
-- `IntelligenceAgentRunner` — auto-wired by `CopilotIntelligenceRuntime`. You do NOT
-  construct this directly and you cannot pass `runner` alongside `intelligence`.
-- Custom — subclass `AgentRunner` for Redis / Postgres / any backend.
-
-## Setup
-
-Default (in-memory, dev only):
-
-```typescript
-import { CopilotRuntime } from "@copilotkit/runtime/v2";
-
-// Equivalent to passing `runner: new InMemoryAgentRunner()`
-const runtime = new CopilotRuntime({
-  agents: {
-    /* ... */
-  } as any,
-});
-```
-
-Production (file-backed SQLite):
-
-```typescript
-import { CopilotRuntime } from "@copilotkit/runtime/v2";
-import { SqliteAgentRunner } from "@copilotkit/sqlite-runner";
-
-const runtime = new CopilotRuntime({
-  agents: {
-    /* ... */
-  } as any,
-  runner: new SqliteAgentRunner({ dbPath: "./data/threads.db" }),
-});
-```
-
-Installation for the SQLite runner (the `better-sqlite3` peer is required):
-
-```bash
-pnpm add @copilotkit/sqlite-runner better-sqlite3
-```
-
-## Core Patterns
-
-### The AgentRunner contract
-
-```typescript
-import { AgentRunner } from "@copilotkit/runtime/v2";
-import type {
-  AgentRunnerRunRequest,
-  AgentRunnerConnectRequest,
-  AgentRunnerIsRunningRequest,
-  AgentRunnerStopRequest,
-} from "@copilotkit/runtime/v2";
-import { Observable } from "rxjs";
-import type { BaseEvent } from "@ag-ui/client";
-
-class MyRunner extends AgentRunner {
-  run(request: AgentRunnerRunRequest): Observable<BaseEvent> {
-    // Start a new run for request.threadId. Throw `new Error("Thread already running")`
-    // if a run is in flight. Stream events from agent.run(request.input).
-    return new Observable<BaseEvent>();
-  }
-  connect(request: AgentRunnerConnectRequest): Observable<BaseEvent> {
-    // Replay events for an active run, or historic runs for request.threadId.
-    return new Observable<BaseEvent>();
-  }
-  async isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean> {
-    return false;
-  }
-  async stop(request: AgentRunnerStopRequest): Promise<boolean | undefined> {
-    return true;
-  }
-}
-```
-
-### Handle double-submit on the client
-
-By default, both `InMemoryAgentRunner` and `SqliteAgentRunner` throw
-`"Thread already running"` on concurrent `run()` calls for the same `threadId`.
-`"throw"` is the default, but it is not the only option: constructing
-`InMemoryAgentRunner` with `onConcurrentRun: "supersede"` makes it abort the
-in-flight run (the same path `stop()` takes) and start the new one instead of
-throwing — the superseded run's partial output is discarded rather than persisted
-to history. `SqliteAgentRunner` has no such option and always throws. When the
-throw does happen, how it surfaces to the client depends on the runtime mode:
-
-- **Intelligence mode** — CopilotKit Intelligence returns HTTP `409` when a lock is
-  held. The client core maps this to `CopilotKitCoreErrorCode.AGENT_THREAD_LOCKED`
-  and fires `onError({ code: "agent_thread_locked", ... })`. Handle this in
-  `<CopilotKit onError>` (the `CopilotKit` provider from `@copilotkit/react-core/v2`).
-- **SSE mode** (default, in-memory / SQLite runners) — the runner throws
-  synchronously and the handler returns a plain `500` JSON body like
-  `{ "error": "Failed to run agent", "message": "Thread already running" }`.
-  There is no typed `agent_thread_locked` code — match on the message text or
-  just guard on the client with a busy flag.
-
-```tsx
-// client — Intelligence mode (typed code)
-import { CopilotKit } from "@copilotkit/react-core/v2";
-
-<CopilotKit
-  onError={({ code }) => {
-    if (code === "agent_thread_locked") {
-      alert("Agent is busy — wait for the current response to finish.");
-    }
-  }}
-/>;
-```
-
-```tsx
-// client — any mode: guard with a busy flag so double-submit is impossible
-import { useAgent } from "@copilotkit/react-core/v2";
-import { useState } from "react";
-
-function Composer() {
-  const agent = useAgent({ agentId: "default" });
-  const [busy, setBusy] = useState(false);
-
-  async function send(text: string) {
-    if (busy) return;
-    setBusy(true);
-    try {
-      await agent?.addMessage({ role: "user", content: text });
-    } finally {
-      setBusy(false);
-    }
-  }
-
-  return null;
-}
-```
-
-## Common Mistakes
-
-### HIGH Shipping InMemoryAgentRunner to production
-
-Wrong:
-
-```typescript
-// production:
-new CopilotRuntime({ agents: { default: agent } });
-```
-
-Correct:
-
-```typescript
-import { SqliteAgentRunner } from "@copilotkit/sqlite-runner";
-
-new CopilotRuntime({
-  agents: { default: agent },
-  runner: new SqliteAgentRunner({ dbPath: "./data/threads.db" }),
-});
-// Or upgrade to Intelligence mode for managed durability.
-```
-
-The default runner is `new InMemoryAgentRunner()`. It keeps state in a process-global,
-bounded store — threads are lost on restart, evicted past the memory limits, and
-horizontally-scaled instances see divergent state. See `agent-runners-in-memory.md`
-for the bounds and how to tune them.
-
-Source: `packages/runtime/src/v2/runtime/runner/in-memory.ts`.
-
-### HIGH Setting runner alongside intelligence option
-
-Wrong:
-
-```typescript
-new CopilotRuntime({
-  agents,
-  intelligence,
-  runner: new SqliteAgentRunner({ dbPath: "./data/threads.db" }),
-});
-```
-
-Correct:
-
-```typescript
-new CopilotRuntime({
-  agents,
-  intelligence,
-  identifyUser: (req) => ({
-    id: req.headers.get("x-user-id")!,
-    name: req.headers.get("x-user-name") ?? "Anonymous",
-  }),
-});
-```
-
-`CopilotIntelligenceRuntimeOptions` does not declare a `runner` field — Intelligence mode
-auto-wires `IntelligenceAgentRunner` pointed at the Intelligence service socket. Excess-property checks will
-flag a `runner:` key on an Intelligence-shaped options object as a type error, and a caller who
-evades that check (JS, `as any`, or a non-literal options object) gets a `throw` at construction
-rather than a silently ignored runner.
-
-Source: `packages/runtime/src/v2/runtime/core/runtime.ts` — `runner?` is declared only on
-`CopilotSseRuntimeOptions` (:239); the Intelligence constructor guard is at :512 and the
-auto-wired runner at :582.
-
-### HIGH Forgetting the better-sqlite3 peer
-
-Wrong:
-
-```bash
-pnpm add @copilotkit/sqlite-runner
-```
-
-Correct:
-
-```bash
-pnpm add @copilotkit/sqlite-runner better-sqlite3
-```
-
-`@copilotkit/sqlite-runner` imports `better-sqlite3` at the top of its module, so if the peer
-is missing, `import { SqliteAgentRunner } from "@copilotkit/sqlite-runner"` itself fails at
-module load with `Cannot find module 'better-sqlite3'` — long before the constructor runs.
-(The constructor has a friendlier multi-line install hint as a belt-and-suspenders fallback,
-but in practice you will see the bare module-resolution error first.) It is a peer dependency,
-not a direct dep.
-
-Source: `packages/sqlite-runner/src/sqlite-runner.ts:18`, `:55-66`.
-
-### HIGH Default SqliteAgentRunner with :memory: dbPath
-
-Wrong:
-
-```typescript
-new SqliteAgentRunner();
-```
-
-Correct:
-
-```typescript
-new SqliteAgentRunner({ dbPath: "./data/threads.db" });
-```
-
-The default `dbPath` is `":memory:"` — SQLite's in-memory mode. Data is lost at restart,
-defeating the reason to use the file-backed runner.
-
-Source: `packages/sqlite-runner/src/sqlite-runner.ts:48-54`.
-
-### MEDIUM Concurrent run() on the same threadId
-
-Wrong:
-
-```tsx
-// Double-click send button → two POST /agent/:id/run to the same thread
-<button onClick={() => agent.addMessage({ role: "user", content })}>
-  Send
-</button>
-```
-
-Correct:
-
-```tsx
-const [busy, setBusy] = useState(false);
-<button
-  disabled={busy}
-  onClick={async () => {
-    setBusy(true);
-    try {
-      await agent.addMessage({ role: "user", content });
-    } finally {
-      setBusy(false);
-    }
-  }}
->
-  Send
-</button>;
-```
-
-By default both runners throw `"Thread already running"` on concurrent runs, so
-debouncing on the client is still the right baseline. In Intelligence mode you can
-additionally handle `code === "agent_thread_locked"` in `<CopilotKit onError>`; SSE
-mode surfaces only a generic 500 with that message.
-
-Throwing is the default (`onConcurrentRun: "throw"`), not the only behavior:
-constructing `InMemoryAgentRunner` with `onConcurrentRun: "supersede"` aborts the
-in-flight run (the `stop()` path) and starts the new one instead of throwing,
-discarding the superseded run's partial output rather than persisting it. That
-suits a UX where a fast follow-up should displace a still-running (or wedged) turn.
-Unlike the process-global memory limits, `onConcurrentRun` is per-runner-instance —
-it affects only the runner you pass it to. `SqliteAgentRunner` has no such option
-and always throws.
-
-Source: the `throw new Error("Thread already running")` in `InMemoryAgentRunner.run()`,
-`packages/runtime/src/v2/runtime/runner/in-memory.ts`;
-`packages/core/src/intelligence-agent.ts:368-369`.
-
-### HIGH In-memory runner + horizontal scaling
-
-Wrong:
-
-```typescript
-// 3 Fly.io / Cloud Run instances, each with its own InMemoryAgentRunner
-new CopilotRuntime({ agents });
-```
-
-Correct:
-
-```typescript
-// Sticky-session one instance per thread (so every run for a thread lands on the
-// same process), OR move to Intelligence mode for managed multi-instance durability.
-new CopilotRuntime({ agents }); // + route by threadId at the load balancer
-```
-
-`InMemoryAgentRunner`'s store is a process-global singleton — multi-instance deploys see
-totally different thread state per worker, making reconnects and `GET /connect` non-deterministic.
-
-Source: the exported `ɵGLOBAL_STORE` singleton in `packages/runtime/src/v2/runtime/runner/in-memory.ts`.
-
-A shared `dbPath` on `SqliteAgentRunner` is **not** a horizontal-scaling fix on its own.
-Sharing the file gives you durable, persisted history: runs survive process restarts, and
-completed runs are readable from any instance pointed at the same file. But the live-run
-bookkeeping used by the connect-bridge and by `stop()` lives in a process-local
-`ACTIVE_CONNECTIONS` map. A second instance has **no** entry for a run started elsewhere, so
-it can replay stored history but **cannot** reconnect to — or stop — an in-flight run on
-another instance. Use `SqliteAgentRunner` for restart-resilient single-instance durability;
-for managed multi-instance durability, use Intelligence mode.
-
-Source: `packages/sqlite-runner/src/sqlite-runner.ts:46` (module-level `ACTIVE_CONNECTIONS`).
-
-## References
-
-- [InMemoryAgentRunner — store, bounds, concurrency, and lifecycle](agent-runners-in-memory.md)
-- [SqliteAgentRunner — schema, retention, ops](agent-runners-sqlite.md)
-- [Custom runner — Redis/Postgres skeleton](agent-runners-custom.md)
-
-## See also
-
-- `copilotkit/intelligence-mode` — managed durability alternative (CopilotKit Intelligence managed service, not self-hostable)
-- `copilotkit/setup-endpoint` — runner is passed via the CopilotRuntime constructor
-- `copilotkit/scale-to-multi-agent` — horizontal scaling considerations

package/skills/runtime/references/built-in-agent-factory-modes.md

@@ -1,232 +0,0 @@
-BuiltInAgent Factory Modes — cookbook for TanStack AI, AI SDK, and custom AG-UI factories.
-
-## The AgentFactoryContext
-
-```typescript
-// packages/runtime/src/agent/index.ts
-export interface AgentFactoryContext {
-  input: RunAgentInput; // messages, tools, forwardedProps, context
-  abortController: AbortController; // prefer abortSignal
-  abortSignal: AbortSignal; // pass to AI SDK / fetch / custom
-}
-```
-
-Rule of thumb:
-
-- Prefer `abortSignal` for AI SDK, fetch, custom backends.
-- Use `abortController` for TanStack AI (its `chat()` takes the controller, not the signal).
-- NEVER call `ctx.abortController.abort()` inside the factory — use
-  `agent.abortRun()` from outside.
-
-## TanStack AI factory (preferred)
-
-```typescript
-import { BuiltInAgent, convertInputToTanStackAI } from "@copilotkit/runtime/v2";
-import { chat } from "@tanstack/ai";
-import { openaiText } from "@tanstack/ai-openai";
-
-new BuiltInAgent({
-  type: "tanstack",
-  factory: ({ input, abortController }) => {
-    const { messages, systemPrompts } = convertInputToTanStackAI(input);
-    systemPrompts.unshift("You are a helpful assistant.");
-    return chat({
-      adapter: openaiText("gpt-4o"),
-      messages,
-      systemPrompts,
-      tools: [
-        /* TanStack AI toolDefinition()s */
-      ],
-      abortController,
-    });
-  },
-});
-```
-
-### TanStack AI + forwardedProps
-
-```typescript
-new BuiltInAgent({
-  type: "tanstack",
-  factory: ({ input, abortController }) => {
-    const { messages, systemPrompts } = convertInputToTanStackAI(input);
-    const fwd = input.forwardedProps as
-      | { model?: string; temperature?: number }
-      | undefined;
-    return chat({
-      adapter: openaiText(fwd?.model ?? "gpt-4o"),
-      messages,
-      systemPrompts,
-      modelOptions: { temperature: fwd?.temperature ?? 0.2 },
-      abortController,
-    });
-  },
-});
-```
-
-## AI SDK factory (use when reasoning events are required)
-
-```typescript
-import {
-  BuiltInAgent,
-  convertMessagesToVercelAISDKMessages,
-  convertToolsToVercelAITools,
-} from "@copilotkit/runtime/v2";
-import { streamText, stepCountIs } from "ai";
-import { openai } from "@ai-sdk/openai";
-
-new BuiltInAgent({
-  type: "aisdk",
-  factory: ({ input, abortSignal }) => {
-    const messages = convertMessagesToVercelAISDKMessages(input.messages, {
-      forwardSystemMessages: true,
-    });
-    const tools = convertToolsToVercelAITools(input.tools);
-    return streamText({
-      model: openai("gpt-4o"),
-      messages,
-      tools,
-      abortSignal,
-      stopWhen: stepCountIs(5),
-    });
-  },
-});
-```
-
-The `BuiltInAgentAISDKFactoryConfig` contract requires an object with a `fullStream`
-async iterable — this is exactly what `streamText()` returns.
-
-## AI SDK + reasoning (Anthropic thinking)
-
-```typescript
-import { anthropic } from "@ai-sdk/anthropic";
-import { streamText } from "ai";
-import {
-  BuiltInAgent,
-  convertMessagesToVercelAISDKMessages,
-} from "@copilotkit/runtime/v2";
-
-new BuiltInAgent({
-  type: "aisdk",
-  factory: ({ input, abortSignal }) =>
-    streamText({
-      model: anthropic("claude-sonnet-4-6"),
-      messages: convertMessagesToVercelAISDKMessages(input.messages),
-      providerOptions: {
-        anthropic: { thinking: { type: "enabled", budgetTokens: 10000 } },
-      },
-      abortSignal,
-    }),
-});
-```
-
-TanStack AI silently drops reasoning events — only AI SDK surfaces them.
-
-## Custom factory (raw AG-UI events)
-
-```typescript
-import { BuiltInAgent } from "@copilotkit/runtime/v2";
-import type { BaseEvent } from "@ag-ui/client";
-import { EventType } from "@ag-ui/client";
-
-new BuiltInAgent({
-  type: "custom",
-  factory: async function* ({ input, abortSignal }): AsyncIterable<BaseEvent> {
-    // Check abortSignal.aborted on every iteration — agent.abortRun() signals
-    // cancellation via this flag, but the generator must consult it to stop yielding.
-    if (abortSignal.aborted) return;
-
-    const messageId = crypto.randomUUID();
-    yield {
-      type: EventType.TEXT_MESSAGE_START,
-      messageId,
-      role: "assistant",
-    } as any;
-
-    for (const delta of ["Hello", ", ", "world."]) {
-      if (abortSignal.aborted) return; // honor cancellation between yields
-      yield {
-        type: EventType.TEXT_MESSAGE_CONTENT,
-        messageId,
-        delta,
-      } as any;
-    }
-
-    yield { type: EventType.TEXT_MESSAGE_END, messageId } as any;
-  },
-});
-```
-
-A custom factory that never checks `abortSignal.aborted` (or registers an
-`addEventListener("abort", …)` handler to break its loop) is non-cancellable —
-`agent.abortRun()` will flip the flag but the generator will keep yielding until it
-exhausts its own source. Pass `abortSignal` through to any underlying `fetch` /
-streaming API as well so the upstream request is torn down.
-
-## Manual state-tool wiring (Factory Mode only)
-
-Simple Mode auto-injects `AGUISendStateSnapshot` / `AGUISendStateDelta`. In Factory Mode
-you must register them by hand for shared-state updates to reach the LLM. The AI SDK
-factory works out of the box because `defineTool` output adapts through
-`convertToolDefinitionsToVercelAITools`:
-
-```typescript
-import {
-  BuiltInAgent,
-  convertMessagesToVercelAISDKMessages,
-  convertToolDefinitionsToVercelAITools,
-  defineTool,
-} from "@copilotkit/runtime/v2";
-import { streamText } from "ai";
-import { openai } from "@ai-sdk/openai";
-import { z } from "zod";
-
-const sendStateSnapshot = defineTool({
-  name: "AGUISendStateSnapshot",
-  description: "Replace the entire application state with a new snapshot",
-  parameters: z.object({
-    snapshot: z.any().describe("The complete new state object"),
-  }),
-  execute: async ({ snapshot }) => ({ success: true, snapshot }),
-});
-const sendStateDelta = defineTool({
-  name: "AGUISendStateDelta",
-  description:
-    "Apply incremental updates to application state using JSON Patch operations",
-  // MUST mirror the Simple-Mode auto-injected schema (src/agent/index.ts:1140-1176)
-  // or the frontend's state handler won't recognize the payload.
-  parameters: z.object({
-    delta: z
-      .array(
-        z.object({
-          op: z.enum(["add", "replace", "remove"]),
-          path: z.string(),
-          value: z.any().optional(),
-        }),
-      )
-      .describe("Array of JSON Patch operations"),
-  }),
-  execute: async ({ delta }) => ({ success: true, delta }),
-});
-
-new BuiltInAgent({
-  type: "aisdk",
-  factory: ({ input, abortSignal }) =>
-    streamText({
-      model: openai("gpt-4o"),
-      messages: convertMessagesToVercelAISDKMessages(input.messages),
-      tools: convertToolDefinitionsToVercelAITools([
-        sendStateSnapshot,
-        sendStateDelta,
-      ]),
-      abortSignal,
-    }),
-});
-```
-
-For TanStack AI factories, `defineTool` output is NOT a TanStack tool — passing it to
-`chat({ tools })` does not work. Either switch to the AI SDK factory above, or redefine
-the tools with `toolDefinition()` from `@tanstack/ai`.
-
-Source: `packages/runtime/src/agent/index.ts`,
-`docs/content/docs/integrations/built-in-agent/custom-agent.mdx`.

package/skills/runtime/references/built-in-agent-helper-utilities.md

@@ -1,123 +0,0 @@
-BuiltInAgent helper utilities — exported from `@copilotkit/runtime/v2`.
-
-## convertInputToTanStackAI
-
-```typescript
-import { convertInputToTanStackAI } from "@copilotkit/runtime/v2";
-
-// signature (simplified):
-// convertInputToTanStackAI(input: RunAgentInput): {
-//   messages: TanStackAIMessage[];
-//   systemPrompts: string[];
-// }
-```
-
-Converts the AG-UI `RunAgentInput` into TanStack AI's `chat()` inputs. System messages in
-the input are collected into the `systemPrompts` array (not the `messages` array). Unshift
-your own system prompt onto `systemPrompts` before calling `chat()`:
-
-```typescript
-const { messages, systemPrompts } = convertInputToTanStackAI(input);
-systemPrompts.unshift("You are a helpful assistant.");
-return chat({ adapter, messages, systemPrompts, abortController });
-```
-
-Source: `packages/runtime/src/agent/converters/tanstack.ts:156`.
-
-## convertMessagesToVercelAISDKMessages
-
-```typescript
-import { convertMessagesToVercelAISDKMessages } from "@copilotkit/runtime/v2";
-
-// signature:
-// convertMessagesToVercelAISDKMessages(
-//   messages: Message[],
-//   options?: { forwardSystemMessages?: boolean; forwardDeveloperMessages?: boolean }
-// ): ModelMessage[]
-```
-
-Converts AG-UI `Message[]` to the Vercel AI SDK's `ModelMessage[]`. Handles multimodal
-content (text, image, audio/video/document, and legacy `binary`). By default drops
-`role: "system"` and `role: "developer"` messages — set the options to opt in.
-
-```typescript
-const messages = convertMessagesToVercelAISDKMessages(input.messages, {
-  forwardSystemMessages: true,
-});
-```
-
-Source: `packages/runtime/src/agent/index.ts:435`.
-
-## convertToolsToVercelAITools
-
-```typescript
-import { convertToolsToVercelAITools } from "@copilotkit/runtime/v2";
-
-// signature:
-// convertToolsToVercelAITools(tools: RunAgentInput["tools"]): ToolSet
-```
-
-Converts AG-UI `input.tools` (tools registered on the frontend — their parameters are plain
-JSON Schema) into the AI SDK's `ToolSet`. Throws `Invalid JSON schema for tool ${name}`
-when a tool's parameters aren't a JSON schema object. The resulting tools have no
-`execute` — the AI SDK emits tool-call events and the frontend handles them.
-
-```typescript
-const tools = convertToolsToVercelAITools(input.tools);
-return streamText({ model, messages, tools, abortSignal });
-```
-
-Source: `packages/runtime/src/agent/index.ts:599`.
-
-## convertToolDefinitionsToVercelAITools
-
-```typescript
-import { convertToolDefinitionsToVercelAITools } from "@copilotkit/runtime/v2";
-
-// signature:
-// convertToolDefinitionsToVercelAITools(tools: ToolDefinition[]): ToolSet
-```
-
-Converts server-side `ToolDefinition[]` (Standard Schema V1 parameters + `execute`
-function) into an AI SDK `ToolSet`. Zod schemas pass through directly; non-Zod Standard
-Schema V1 parameters (Valibot, ArkType, ...) are converted to JSON Schema via
-`schemaToJsonSchema` and wrapped with `jsonSchema()` from `ai`.
-
-```typescript
-import { defineTool } from "@copilotkit/runtime/v2";
-import { z } from "zod";
-
-const searchTool = defineTool({
-  name: "search",
-  description: "Search the web.",
-  parameters: z.object({ query: z.string() }),
-  execute: async ({ query }) => ({ results: [] }),
-});
-
-const tools = convertToolDefinitionsToVercelAITools([searchTool]);
-return streamText({ model, messages, tools, abortSignal });
-```
-
-Source: `packages/runtime/src/agent/index.ts:633`.
-
-## resolveModel
-
-```typescript
-import { resolveModel } from "@copilotkit/runtime/v2";
-
-// signature:
-// resolveModel(spec: ModelSpecifier, apiKey?: string): LanguageModel
-```
-
-Resolves a `"provider/model"` (or `"provider:model"`) string to a `LanguageModel`. If
-`spec` is already a `LanguageModel`, it's returned as-is. Throws
-`Invalid model string "..."` when the provider separator is missing.
-
-Supported providers: `openai`, `anthropic`, `google`/`gemini`/`google-gemini`, `vertex`.
-Unknown providers throw `Unknown provider "..." in "...". Supported: openai, anthropic, google (gemini).`
-
-```typescript
-const model = resolveModel("openai/gpt-4o", process.env.OPENAI_API_KEY);
-```
-
-Source: `packages/runtime/src/agent/index.ts:176-249`.