@copilotkit/runtime 2.0.0-next.1 → 2.0.0-rc.0

package/dist/agent/index.d.cts

@@ -0,0 +1,467 @@
+import { CreateSafeUrlDownloadOptions, SafeUrlDownloadOptions, createSafeUrlDownload } from "./url-download.cjs";
+import { BuiltInAgentLearnedSkills, BuiltInAgentLearnedSkillsOptions } from "./learned-skills.cjs";
+import { convertAISDKStream } from "./converters/aisdk.cjs";
+import { TanStackChatMessage, TanStackInputResult, convertInputToTanStackAI, convertTanStackStream } from "./converters/tanstack.cjs";
+import { InferSchemaOutput, ModelHostClass, StandardSchemaV1 } from "@copilotkit/shared";
+import { AbstractAgent, BaseEvent, Interrupt, Message, ResumeEntry, RunAgentInput } from "@ag-ui/client";
+import { Observable } from "rxjs";
+import { z } from "zod";
+import { AgentCapabilities } from "@ag-ui/core";
+import { Experimental_DownloadFunction, LanguageModel, ModelMessage, ToolChoice, ToolSet } from "ai";
+import { StreamableHTTPClientTransportOptions } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+//#region src/agent/index.d.ts
+/**
+ * Properties that can be overridden by forwardedProps
+ * These match the exact parameter names in streamText
+ */
+type OverridableProperty = "model" | "toolChoice" | "maxOutputTokens" | "temperature" | "topP" | "topK" | "presencePenalty" | "frequencyPenalty" | "stopSequences" | "seed" | "maxRetries" | "prompt" | "providerOptions";
+/**
+ * Model identifiers for BuiltInAgent. The named entries are editor
+ * suggestions, not an allowlist: any provider model id is sent through
+ * unchanged.
+ */
+type BuiltInAgentModel = "openai/gpt-5.5" | "openai/gpt-5.4" | "openai/gpt-5.4-mini" | "openai/gpt-5" | "openai/gpt-5-mini" | "openai/gpt-4.1" | "openai/gpt-4.1-mini" | "openai/gpt-4.1-nano" | "openai/gpt-4o" | "openai/gpt-4o-mini" | "openai/o3" | "openai/o3-mini" | "openai/o4-mini" | "anthropic/claude-sonnet-4-6" | "anthropic/claude-sonnet-4-5" | "anthropic/claude-opus-4-8" | "anthropic/claude-haiku-4-5" | "google/gemini-3.8-flash" | "google/gemini-3.5-flash" | "google/gemini-3.5-flash-lite" | "minimax/MiniMax-M3" | "minimax/MiniMax-M2.7" | (string & {});
+/**
+ * Model specifier - can be a string like "openai/gpt-4o" or a LanguageModel instance
+ */
+type ModelSpecifier = string | LanguageModel;
+/**
+ * MCP Client configuration for HTTP transport
+ */
+interface MCPClientConfigHTTP {
+  /** Type of MCP client */
+  type: "http";
+  /**
+   * Optional name for this server. When a tool name collides with another
+   * MCP server's tool or with an app tool, the MCP tool is exposed as
+   * `<name>_<tool>`. Without a name, the prefix is `mcp<N>`, where N is the
+   * server's position among `mcpClients` and then `mcpServers`, from 1.
+   * Give each server a different name: if a prefixed name is already in use,
+   * a number is added (`<name>_<tool>_2`).
+   */
+  name?: string;
+  /** URL of the MCP server */
+  url: string;
+  /**
+   * Optional transport options for the underlying
+   * `StreamableHTTPClientTransport`. The SDK's documented extension point
+   * for per-request customization is `options.fetch` — pass a wrapped fetch
+   * here if you need static + dynamic headers on outbound MCP requests.
+   */
+  options?: StreamableHTTPClientTransportOptions;
+}
+/**
+ * MCP Client configuration for SSE transport
+ */
+interface MCPClientConfigSSE {
+  /** Type of MCP client */
+  type: "sse";
+  /**
+   * Optional name for this server. When a tool name collides with another
+   * MCP server's tool or with an app tool, the MCP tool is exposed as
+   * `<name>_<tool>`. Without a name, the prefix is `mcp<N>`, where N is the
+   * server's position among `mcpClients` and then `mcpServers`, from 1.
+   * Give each server a different name: if a prefixed name is already in use,
+   * a number is added (`<name>_<tool>_2`).
+   */
+  name?: string;
+  /** URL of the MCP server */
+  url: string;
+  /** Optional HTTP headers (e.g., for authentication) */
+  headers?: Record<string, string>;
+}
+/**
+ * MCP Client configuration
+ */
+type MCPClientConfig = MCPClientConfigHTTP | MCPClientConfigSSE;
+/**
+ * A user-managed MCP client that provides tools to the agent.
+ * The user is responsible for creating, configuring, and closing the client.
+ * Compatible with the return type of @ai-sdk/mcp's createMCPClient().
+ *
+ * Unlike mcpServers, the agent does NOT create or close these clients.
+ * This allows persistent connections, custom auth, and tool caching.
+ */
+interface MCPClientProvider {
+  /** Return tools to be merged into the agent's tool set. */
+  tools(): Promise<ToolSet>;
+}
+declare function resolveModel(spec: ModelSpecifier, apiKey?: string): LanguageModel;
+/**
+ * Which vendor a model specifier will actually reach, as a closed vocabulary.
+ *
+ * `resolveModel` above is the only place this runtime builds a provider, so it
+ * is the only place that knows the endpoint. Once built, the endpoint is gone:
+ * an AI SDK model's `provider` names only the wire API (`"openai.responses"`
+ * on OpenAI and Azure, `"openai.chat"` on any other host), so it cannot tell
+ * OpenRouter from a laptop, and its base URL survives
+ * only inside a closure that the public `LanguageModelV3` type does not
+ * expose. Azure's own migration guide tells customers to use that same OpenAI
+ * client, so the case we are blindest to is the common one.
+ *
+ * A caller who hands us an already-built LanguageModel gets `unknown`. Nobody
+ * can recover the host from it, and saying so is more useful than guessing
+ * `openai` from a provider label that means only "speaks the OpenAI wire".
+ *
+ * The branches below mirror `resolveModel`'s switch and must change with it.
+ * `model-host-class.test.ts` walks every provider that switch accepts and
+ * fails if one lands here as `unknown`.
+ */
+declare function classifyModelSpec(spec: ModelSpecifier): ModelHostClass;
+/**
+ * Thrown by `AgentFactoryContext.interrupt()` on a fresh (non-resume) run to
+ * pause the factory. Caught in `runFactory` and translated into a RUN_FINISHED
+ * event carrying `outcome:{type:"interrupt",interrupts}`. Not a real error.
+ */
+declare class InterruptSignal extends Error {
+  readonly interrupts: Interrupt[];
+  constructor(interrupts: Interrupt[]);
+}
+/**
+ * Tool definition for BuiltInAgent
+ */
+interface ToolDefinition<TParameters extends StandardSchemaV1 = StandardSchemaV1> {
+  name: string;
+  description: string;
+  parameters: TParameters;
+  /**
+   * Server-side executor. Optional ONLY for interrupt tools (`interrupt:true`),
+   * which pause the run instead of executing.
+   */
+  execute?: (args: InferSchemaOutput<TParameters>) => Promise<unknown>;
+  /**
+   * When true, calling this tool pauses the run and emits a standard AG-UI
+   * interrupt (RUN_FINISHED outcome:interrupt) keyed by the tool call's id.
+   * The human response (resume payload) is injected as this tool call's result
+   * on the resume run. Interrupt tools must NOT define `execute`. The AI SDK
+   * pauses when a tool call has no result, even with a multi-step limit.
+   */
+  interrupt?: boolean;
+  /** Optional categorical reason surfaced on the Interrupt (default: "tool_call"). */
+  interruptReason?: string;
+  /** Optional human-readable prompt surfaced on the Interrupt. */
+  interruptMessage?: string;
+}
+/**
+ * Define a tool for use with BuiltInAgent
+ * @param name - The name of the tool
+ * @param description - Description of what the tool does
+ * @param parameters - Schema for the tool's input parameters (any Standard Schema V1 compatible library: Zod, Valibot, ArkType, etc.)
+ * @param execute - Function to execute the tool server-side
+ * @returns Tool definition
+ */
+declare function defineTool<TParameters extends StandardSchemaV1>(config: {
+  name: string;
+  description: string;
+  parameters: TParameters;
+  execute?: (args: InferSchemaOutput<TParameters>) => Promise<unknown>;
+  interrupt?: boolean;
+  interruptReason?: string;
+  interruptMessage?: string;
+}): ToolDefinition<TParameters>;
+/**
+ * Options for converting AG-UI messages to Vercel AI SDK format
+ */
+interface MessageConversionOptions {
+  forwardSystemMessages?: boolean;
+  forwardDeveloperMessages?: boolean;
+}
+/**
+ * Converts AG-UI messages to Vercel AI SDK ModelMessage format
+ */
+declare function convertMessagesToVercelAISDKMessages(messages: Message[], options?: MessageConversionOptions): ModelMessage[];
+/**
+ * JSON Schema type definition
+ */
+interface JsonSchema {
+  type?: "object" | "string" | "number" | "integer" | "boolean" | "array" | "null";
+  description?: string;
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  items?: JsonSchema;
+  enum?: string[];
+  anyOf?: JsonSchema[];
+  oneOf?: JsonSchema[];
+}
+/**
+ * Converts JSON Schema to Zod schema
+ */
+declare function convertJsonSchemaToZodSchema(jsonSchema: JsonSchema, required: boolean): z.ZodSchema;
+/** Preserve AG-UI tool schemas when passing them to the model provider. */
+declare function convertToolsToVercelAITools(tools: RunAgentInput["tools"]): ToolSet;
+/**
+ * Converts ToolDefinition array to Vercel AI SDK ToolSet.
+ *
+ * For Zod schemas, passes them directly to the AI SDK (Zod satisfies FlexibleSchema).
+ * For non-Zod schemas, converts to JSON Schema via schemaToJsonSchema() and wraps
+ * with the AI SDK's jsonSchema() helper.
+ */
+declare function convertToolDefinitionsToVercelAITools(tools: ToolDefinition[]): ToolSet;
+/**
+ * Context passed to the user-supplied factory function in factory mode.
+ */
+interface AgentFactoryContext {
+  /** Verified catalog and AI SDK tools for this run; empty when disabled or no skills exist. */
+  learnedSkills: BuiltInAgentLearnedSkills;
+  input: RunAgentInput;
+  /**
+   * Prefer `abortSignal` for most use cases (AI SDK, fetch, custom backends).
+   * Provided for backends like TanStack AI that require the full AbortController.
+   * Do NOT call `.abort()` on this controller — use `abortRun()` on the agent instead.
+   */
+  abortController: AbortController;
+  abortSignal: AbortSignal;
+  /**
+   * Pause the run for human input (AG-UI standard interrupt). On a fresh run
+   * this throws an InterruptSignal (caught by the runtime) and the run finishes
+   * with `outcome:{type:"interrupt",interrupts}`. On the resume run (when
+   * `input.resume` covers these interrupts) it returns the matching ResumeEntry
+   * responses so the factory can continue. Each `interrupts[i].id` is matched to
+   * `input.resume[].interruptId`.
+   */
+  interrupt: (interrupts: Interrupt[]) => Promise<ResumeEntry[]>;
+}
+/** Public name that avoids the runtime's request-scoped AgentFactoryContext. */
+type BuiltInAgentFactoryContext = AgentFactoryContext;
+/**
+ * Factory config for AI SDK backend.
+ * The factory must return an object with a `fullStream` async iterable
+ * (compatible with the result of `streamText()` — only `fullStream` is consumed).
+ *
+ * You own the `streamText()` call, so you also own its URL downloads. Pass
+ * `experimental_download: createSafeUrlDownload({ signal: ctx.abortSignal })`
+ * (imported from `@copilotkit/runtime`) to keep the server from fetching
+ * internal addresses named in request attachments, and to stop the downloads
+ * when the run is aborted. BuiltInAgent's `urlDownload` setting does not apply
+ * here: setting it in factory mode throws when the agent is constructed.
+ */
+interface BuiltInAgentAISDKFactoryConfig {
+  /** Opt in to automatic snapshot acquisition before each run, including resumes. */
+  learnedSkills?: BuiltInAgentLearnedSkillsOptions;
+  type: "aisdk";
+  factory: (ctx: AgentFactoryContext) => {
+    fullStream: AsyncIterable<unknown>;
+  } | Promise<{
+    fullStream: AsyncIterable<unknown>;
+  }>;
+}
+/**
+ * Factory config for TanStack AI backend.
+ * The factory must return an async iterable of TanStack AI stream chunks.
+ */
+interface BuiltInAgentTanStackFactoryConfig {
+  /** Opt in to automatic snapshot acquisition before each run, including resumes. */
+  learnedSkills?: BuiltInAgentLearnedSkillsOptions;
+  type: "tanstack";
+  factory: (ctx: AgentFactoryContext) => AsyncIterable<unknown> | Promise<AsyncIterable<unknown>>;
+}
+/**
+ * Factory config for a custom backend that directly yields AG-UI events.
+ */
+interface BuiltInAgentCustomFactoryConfig {
+  /** Opt in to automatic snapshot acquisition before each run, including resumes. */
+  learnedSkills?: BuiltInAgentLearnedSkillsOptions;
+  type: "custom";
+  factory: (ctx: AgentFactoryContext) => AsyncIterable<BaseEvent> | Promise<AsyncIterable<BaseEvent>>;
+}
+/**
+ * Union of all factory-mode configurations.
+ */
+type BuiltInAgentFactoryConfig = BuiltInAgentAISDKFactoryConfig | BuiltInAgentTanStackFactoryConfig | BuiltInAgentCustomFactoryConfig;
+/**
+ * Classic config — BuiltInAgent handles streamText, tools, MCP, state tools, prompt building.
+ */
+interface BuiltInAgentClassicConfig {
+  /** Opt in to automatic snapshot acquisition before each run, including resumes. */
+  learnedSkills?: BuiltInAgentLearnedSkillsOptions;
+  /**
+   * The model to use
+   */
+  model: BuiltInAgentModel | LanguageModel;
+  /**
+   * API key for the model provider (OpenAI, Anthropic, Google)
+   * If not provided, falls back to environment variables:
+   * - OPENAI_API_KEY for OpenAI models
+   * - ANTHROPIC_API_KEY for Anthropic models
+   * - GOOGLE_API_KEY for Google models
+   * - MINIMAX_API_KEY for MiniMax models
+   */
+  apiKey?: string;
+  /**
+   * Maximum number of steps/iterations for tool calling (default: 1, or 10 when learned skills are available)
+   */
+  maxSteps?: number;
+  /**
+   * Tool choice setting - how tools are selected for execution (default: "auto")
+   */
+  toolChoice?: ToolChoice<Record<string, unknown>>;
+  /**
+   * Maximum number of tokens to generate
+   */
+  maxOutputTokens?: number;
+  /**
+   * Temperature setting (range depends on provider)
+   */
+  temperature?: number;
+  /**
+   * Nucleus sampling (topP)
+   */
+  topP?: number;
+  /**
+   * Top K sampling
+   */
+  topK?: number;
+  /**
+   * Presence penalty
+   */
+  presencePenalty?: number;
+  /**
+   * Frequency penalty
+   */
+  frequencyPenalty?: number;
+  /**
+   * Sequences that will stop the generation
+   */
+  stopSequences?: string[];
+  /**
+   * Seed for deterministic results
+   */
+  seed?: number;
+  /**
+   * Maximum number of retries
+   */
+  maxRetries?: number;
+  /**
+   * Prompt for the agent
+   */
+  prompt?: string;
+  /**
+   * List of properties that can be overridden by forwardedProps.
+   */
+  overridableProperties?: OverridableProperty[];
+  /**
+   * Optional list of MCP server configurations
+   */
+  mcpServers?: MCPClientConfig[];
+  /**
+   * Optional list of user-managed MCP clients.
+   * Unlike mcpServers, the agent does NOT create or close these clients.
+   * The user controls the lifecycle, persistence, auth, and caching.
+   *
+   * Compatible with @ai-sdk/mcp's createMCPClient() return type:
+   * ```typescript
+   * const client = await createMCPClient({ transport });
+   * const agent = new BuiltInAgent({ model: "...", mcpClients: [client] });
+   * ```
+   */
+  mcpClients?: MCPClientProvider[];
+  /**
+   * Optional tools available to the agent
+   */
+  tools?: ToolDefinition[];
+  /**
+   * Forward system-role messages from input to the LLM.
+   * Default: false
+   */
+  forwardSystemMessages?: boolean;
+  /**
+   * Forward developer-role messages from input to the LLM (as system messages).
+   * Default: false
+   */
+  forwardDeveloperMessages?: boolean;
+  /**
+   * Provider-specific options passed to the model (e.g., OpenAI reasoningEffort).
+   * Example: `{ openai: { reasoningEffort: "high" } }`
+   */
+  providerOptions?: Record<string, any>;
+  /**
+   * How the server downloads URL attachments (image and file parts) that the
+   * model cannot take as a URL. The URL comes from the request, so the server
+   * must not fetch it blindly.
+   *
+   * - Not set or an options object (default): download only from public
+   *   internet addresses. The hostname is resolved and every address must be
+   *   public; the connection uses only the checked addresses; each redirect is
+   *   checked again, and a redirect from https to http is refused; the size
+   *   (default 20 MiB) and the time (default 30 s) of each download, and the
+   *   number of distinct URLs (20) and total size (50 MiB) of the downloads
+   *   for one model call are limited. The AI SDK downloads the attachments
+   *   again for each step of a multi-step run. `allowedHosts` limits
+   *   downloads to the hostnames you list: `cdn.example.com` matches exactly,
+   *   `*.example.com` matches subdomains only. Invalid options, including an
+   *   unknown option name, throw when the agent is constructed.
+   * - `"disabled"`: never download from the network. Any attachment URL other
+   *   than `data:` that the model cannot take directly fails the run.
+   * - A function: your own AI SDK download function. You are responsible for
+   *   what it fetches.
+   *
+   * URLs that the model takes directly are sent to the provider unchanged and
+   * are not downloaded by the server. `data:` URLs are decoded locally by the
+   * AI SDK in every mode. Classic config only: in factory mode, see
+   * {@link BuiltInAgentAISDKFactoryConfig}.
+   */
+  urlDownload?: "disabled" | SafeUrlDownloadOptions | Experimental_DownloadFunction;
+  /**
+   * Explicit agent capabilities. **Shallow-merged** at the category level on
+   * top of auto-inferred defaults — providing a category (e.g. `tools`)
+   * replaces that entire category, not individual fields within it.
+   *
+   * For example, `{ tools: { supported: true } }` will drop the inferred
+   * `clientProvided` value. Include all fields for any category you override.
+   */
+  capabilities?: Partial<AgentCapabilities>;
+}
+/**
+ * Configuration for BuiltInAgent.
+ *
+ * Two modes:
+ * - **Classic** (model + params): BuiltInAgent handles everything — streamText, tools, MCP, state tools.
+ * - **Factory** (type + factory): You own the LLM call. BuiltInAgent handles lifecycle only.
+ */
+type BuiltInAgentConfiguration = BuiltInAgentClassicConfig | BuiltInAgentFactoryConfig;
+declare class BuiltInAgent extends AbstractAgent {
+  private config;
+  private abortController?;
+  private skillRegistry?;
+  /**
+   * Which vendor this agent's configured model reaches. Read by the SSE layer
+   * onto `agent_execution_stream_*` telemetry.
+   *
+   * Computed once, from the configured model, because that is what holds for
+   * the agent's lifetime. A per-request `forwardedProps.model` override
+   * (handled further down in `run`) can point somewhere else for one run and
+   * is not reflected here — overrides are rare and the field describes the
+   * agent, not the call.
+   *
+   * Factory-mode configs own their own LLM call, so there is no model for us
+   * to classify.
+   */
+  readonly modelHostClass: ModelHostClass;
+  /**
+   * Gives the download function for URL attachments for one run (classic
+   * config only). Resolved in the constructor so a bad setting fails fast.
+   */
+  private readonly urlDownload?;
+  constructor(config: BuiltInAgentConfiguration);
+  /**
+   * Check if a property can be overridden by forwardedProps
+   */
+  canOverride(property: OverridableProperty): boolean;
+  getCapabilities(): Promise<AgentCapabilities>;
+  run(input: RunAgentInput): Observable<BaseEvent>;
+  private runFactory;
+  clone(): BuiltInAgent;
+  abortRun(): void;
+}
+/**
+ * @deprecated Use BuiltInAgent instead
+ */
+declare class BasicAgent extends BuiltInAgent {
+  constructor(config: BuiltInAgentConfiguration);
+}
+/** @deprecated Use BuiltInAgentClassicConfig instead */
+type BasicAgentConfiguration = BuiltInAgentClassicConfig;
+//#endregion
+export { BasicAgent, BasicAgentConfiguration, BuiltInAgent, BuiltInAgentAISDKFactoryConfig, BuiltInAgentClassicConfig, BuiltInAgentConfiguration, BuiltInAgentCustomFactoryConfig, BuiltInAgentFactoryConfig, BuiltInAgentFactoryContext, BuiltInAgentModel, BuiltInAgentTanStackFactoryConfig, InterruptSignal, MCPClientConfig, MCPClientConfigHTTP, MCPClientConfigSSE, MCPClientProvider, MessageConversionOptions, ModelSpecifier, OverridableProperty, ToolDefinition, classifyModelSpec, convertJsonSchemaToZodSchema, convertMessagesToVercelAISDKMessages, convertToolDefinitionsToVercelAITools, convertToolsToVercelAITools, defineTool, resolveModel };
+//# sourceMappingURL=index.d.cts.map

package/dist/agent/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/agent/index.ts"],"mappings":"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"}