zidane 1.7.0 → 1.8.0

package/dist/{agent-B__ISsOE.d.ts → agent-CWQ5XOw6.d.ts}

@@ -3,6 +3,80 @@ import { b as ExecutionContext, c as ExecutionHandle } from './types-BpvTmawk.js
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { b as SkillsConfig, S as SkillConfig } from './types-CDI8Kmve.js';
 
+/**
+ * Typed error classes for agent runs.
+ *
+ * Providers classify native errors into one of these so downstream consumers
+ * (e.g. harness adapters) can react without string-sniffing messages.
+ *
+ * Provider authors: implement `Provider.classifyError` to map native errors
+ * (SDK exceptions, HTTP responses) to a `ClassifiedError`. The loop wraps
+ * unclassified errors in `AgentProviderError` automatically.
+ */
+/** Kind of classified provider error */
+type ClassifiedErrorKind = 'context_exceeded' | 'provider_error' | 'aborted';
+/** Structured classification returned by `Provider.classifyError` */
+interface ClassifiedError {
+    kind: ClassifiedErrorKind;
+    /** Upstream error code as surfaced by the provider (e.g. `context_length_exceeded`). Optional. */
+    providerCode?: string;
+    /** Optional human-readable message override. Falls back to the underlying error's message. */
+    message?: string;
+}
+interface TypedErrorOptions {
+    /** Provider name, always set (e.g. `anthropic`, `openrouter`) */
+    provider: string;
+    /** Optional upstream error code */
+    providerCode?: string;
+    /** Original error from the provider SDK/HTTP layer */
+    cause?: unknown;
+}
+/**
+ * Thrown when the model or provider signals that the context window was exceeded.
+ * Downstream consumers should catch this, prune history, and retry.
+ */
+declare class AgentContextExceededError extends Error {
+    readonly code: "context_exceeded";
+    readonly provider: string;
+    readonly providerCode?: string;
+    constructor(message: string, options: TypedErrorOptions);
+}
+/**
+ * Thrown when the provider returns a non-context error (auth, rate limit, server error, etc.).
+ * Catch-all for unclassified provider failures.
+ */
+declare class AgentProviderError extends Error {
+    readonly code: "provider_error";
+    readonly provider: string;
+    readonly providerCode?: string;
+    constructor(message: string, options: TypedErrorOptions);
+}
+/**
+ * Thrown when a run is aborted by the consumer via `agent.abort()` or an external `AbortSignal`.
+ */
+declare class AgentAbortedError extends Error {
+    readonly code: "aborted";
+    constructor(message?: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Regex patterns matching common "context window exceeded" messages across providers.
+ *
+ * Use {@link matchesContextExceeded} to test a free-form error message against them.
+ * Provider authors can also compose these into their own `classifyError` fallbacks.
+ */
+declare const CONTEXT_EXCEEDED_MESSAGE_PATTERNS: readonly RegExp[];
+/**
+ * Return true when `message` matches any of the known "context window exceeded"
+ * phrasings. Safe for `''` / non-strings (returns false).
+ */
+declare function matchesContextExceeded(message: unknown): boolean;
+/**
+ * Convert a `ClassifiedError` + underlying cause into the matching typed error instance.
+ */
+declare function toTypedError(classification: ClassifiedError, provider: string, cause: unknown): AgentContextExceededError | AgentProviderError | AgentAbortedError;
+
 /**
  * Shared types for the agent system.
  */
@@ -47,6 +121,41 @@ interface ImageContent {
         data: string;
     };
 }
+/**
+ * One block of a multimodal user prompt.
+ *
+ * `agent.run({ prompt })` accepts either a plain string (treated as a single
+ * text part) or an array of these parts for multimodal inputs.
+ *
+ * `document` parts are routed per provider: PDF-style mime types are sent as
+ * native document blocks when the provider supports them; text documents are
+ * inlined as text with an attachment header. Providers that cannot handle an
+ * image or document throw early.
+ */
+type PromptPart = PromptTextPart | PromptImagePart | PromptDocumentPart;
+interface PromptTextPart {
+    type: 'text';
+    text: string;
+}
+interface PromptImagePart {
+    type: 'image';
+    /** IANA media type (e.g. `image/png`, `image/jpeg`) */
+    mediaType: string;
+    /** Base64-encoded payload */
+    data: string;
+    /** Optional display name */
+    name?: string;
+}
+interface PromptDocumentPart {
+    type: 'document';
+    /** IANA media type (e.g. `application/pdf`, `text/plain`) */
+    mediaType: string;
+    /** Either a base64-encoded payload (`encoding: 'base64'`) or raw text (`encoding: 'text'`) */
+    data: string;
+    encoding: 'base64' | 'text';
+    /** Optional display name used in attachment headers */
+    name?: string;
+}
 type SessionContentBlock = {
     type: 'text';
     text: string;
@@ -85,12 +194,27 @@ interface SessionTurn {
     /** Unix timestamp (Date.now()) when the turn was created */
     createdAt: number;
 }
+/**
+ * Per-run hook registrations. Each entry can be a single handler or an array of handlers.
+ * Keys are `AgentHooks` event names (loose-typed here to avoid a circular import; agent.ts
+ * narrows it to the strongly-typed map).
+ */
+type RunHookMap = Record<string, ((ctx: any) => unknown) | ((ctx: any) => unknown)[]>;
 interface AgentRunOptions {
     model?: string;
-    /** User prompt. Optional when resuming a session with existing turns. */
-    prompt?: string;
+    /**
+     * User prompt. Optional when resuming a session with existing turns.
+     *
+     * Accepts either a plain string (single text part) or an array of `PromptPart`s for
+     * multimodal inputs (text, images, documents). See {@link PromptPart}.
+     */
+    prompt?: string | PromptPart[];
     system?: string;
     thinking?: ThinkingLevel;
+    /**
+     * Legacy image attachments. When `prompt` is a string, these are appended as image
+     * parts after the text. Ignored when `prompt` is a `PromptPart[]`.
+     */
     images?: ImageContent[];
     /** Abort signal — when triggered, the agent stops after the current turn */
     signal?: AbortSignal;
@@ -98,7 +222,16 @@ interface AgentRunOptions {
     behavior?: AgentBehavior;
     /** Tool overrides for this run. Pass {} for no tools. Omit to use harness tools. */
     tools?: Record<string, ToolDef>;
+    /**
+     * Per-run hook registrations. Each hook is attached before the run starts and
+     * detached in a finally block so handlers never leak across runs.
+     *
+     * Accepts either a single handler or an array (all handlers register).
+     */
+    hooks?: RunHookMap;
 }
+/** Reason the provider gave for stopping the turn */
+type TurnFinishReason = 'stop' | 'tool-calls' | 'length' | 'content-filter' | 'error' | 'other';
 interface TurnUsage {
     input: number;
     output: number;
@@ -110,6 +243,16 @@ interface TurnUsage {
     thinking?: number;
     /** Cost in USD as reported by the provider (OpenRouter) */
     cost?: number;
+    /**
+     * Why the model stopped this turn. Providers normalize native stop reasons to this union.
+     * Absent when the provider did not surface a reason (e.g. mock turns).
+     */
+    finishReason?: TurnFinishReason;
+    /**
+     * The model ID the provider ultimately used. May differ from the requested model when the
+     * provider remaps aliases. Absent for providers that do not echo a model ID.
+     */
+    modelId?: string;
 }
 interface AgentStats {
     totalIn: number;
@@ -124,25 +267,58 @@ interface AgentStats {
     children?: ChildRunStats[];
     /** Structured output from schema enforcement (only present when behavior.schema is set) */
     output?: Record<string, unknown>;
+    /**
+     * Milliseconds from the start of `agent.run()` to the first observable signal from the
+     * provider (first `stream:text`, `stream:thinking`, or `tool:before` event).
+     *
+     * Absent when the run produced no observable signals (e.g. aborted before any stream event).
+     */
+    timeTillFirstTokenMs?: number;
 }
 interface ChildRunStats {
     id: string;
     task: string;
     stats: AgentStats;
 }
-/** Base context for tool execution hooks */
+/**
+ * Base context for tool execution hooks.
+ *
+ * `name` is the canonical tool identity — the spec name defined in the harness (or the
+ * `mcp_{server}_{tool}` name for MCP tools). Hooks should policy-match against `name`.
+ *
+ * `displayName` is the outward-facing name — the alias surfaced to the LLM when
+ * `HarnessConfig.toolAliases` maps the canonical name; otherwise equal to `name`.
+ * UI/telemetry adapters should emit `displayName`.
+ *
+ * Canonical vs. alias matters on session resume: `session.turns` persists canonical
+ * names only, so renaming an alias cannot desync history.
+ */
 interface ToolHookContext {
     turnId: string;
     callId: string;
+    /** Canonical tool name (harness spec name). Stable across alias-map changes. */
     name: string;
+    /** Aliased (wire) name — equal to `name` when no alias is defined. */
+    displayName: string;
     input: Record<string, unknown>;
 }
-/** Base context for MCP tool hooks */
+/**
+ * Base context for MCP tool hooks.
+ *
+ * `tool` is the native tool name on the MCP server. `server` is the configured server
+ * name. The canonical zidane-namespaced identity is `mcp_{server}_{tool}`.
+ *
+ * `displayName` equals the canonical namespaced name unless the harness has aliased
+ * this MCP tool via `HarnessConfig.toolAliases`; in which case `displayName` is the
+ * alias that the LLM sees.
+ */
 interface McpToolHookContext {
     turnId: string;
     callId: string;
     server: string;
     tool: string;
+    /** Aliased wire name for this MCP tool, or the canonical `mcp_{server}_{tool}` name. */
+    displayName: string;
     input: Record<string, unknown>;
 }
 /** Base context for session hooks */
@@ -182,6 +358,12 @@ interface AnthropicParams {
     refresh?: string;
     expires?: number;
     defaultModel?: string;
+    /**
+     * Optional override for the Anthropic SDK base URL. Honored end-to-end — headers and
+     * routing pass through to the forwarded host. Useful for proxies (e.g. corporate
+     * gateways, internal router).
+     */
+    baseURL?: string;
 }
 declare function anthropic(anthropicParams?: AnthropicParams): Provider;
 
@@ -189,6 +371,12 @@ interface CerebrasParams {
     apiKey?: string;
     defaultModel?: string;
 }
+/**
+ * Cerebras provider.
+ *
+ * Thin wrapper around {@link openaiCompat} with Cerebras-specific defaults
+ * (base URL, default model).
+ */
 declare function cerebras(params?: CerebrasParams): Provider;
 
 interface OpenAIParams {
@@ -204,10 +392,98 @@ interface OpenAIParams {
 }
 declare function openai(params?: OpenAIParams): Provider;
 
+/**
+ * OpenAI-compatible provider factory + shared utilities.
+ *
+ * `openaiCompat(params)` returns a `Provider` that talks to any OpenAI-compatible
+ * HTTP endpoint (OpenRouter, Cerebras, Baseten, Fireworks, Groq, local LM servers, ...).
+ * Helpers (`consumeSSE`, `toOAIMessages`, ...) are shared by the bespoke `openrouter`
+ * and `cerebras` wrappers, which pin defaults on top of this factory.
+ */
+
+/**
+ * HTTP error thrown when an OpenAI-compatible endpoint returns a non-OK response.
+ *
+ * The body is best-effort JSON-parsed; `error.message` / `error.code` / `error.type`
+ * are extracted for clean downstream classification.
+ */
+declare class OpenAICompatHttpError extends Error {
+    readonly status: number;
+    readonly providerCode?: string;
+    readonly bodyText: string;
+    constructor(status: number, bodyText: string);
+}
+/**
+ * Classify an OpenAI-compatible error into `ClassifiedError`.
+ *
+ * Recognizes:
+ * - `AbortError` (from fetch) → `aborted`.
+ * - `OpenAICompatHttpError` with a context-exceeded code or message → `context_exceeded`.
+ * - Any other `OpenAICompatHttpError` → `provider_error`.
+ *
+ * Returns `null` for unrecognized error shapes (the loop falls back to `AgentProviderError`).
+ */
+declare function classifyOpenAICompatError(err: unknown): ClassifiedError | null;
+/**
+ * Map an OpenAI-compatible `finish_reason` string to the zidane `TurnFinishReason` union.
+ */
+declare function mapOAIFinishReason(reason: string | null | undefined): TurnFinishReason | undefined;
+/**
+ * Auth header config. `scheme` is prepended to the api key with a space, e.g.
+ * `{ name: 'Authorization', scheme: 'Bearer' }` → `Authorization: Bearer <key>`.
+ * Omit `scheme` for raw header values (e.g. `{ name: 'X-Api-Key' }` → `X-Api-Key: <key>`).
+ *
+ * Real-world examples:
+ * - Default OpenAI / OpenRouter / Cerebras: `{ name: 'Authorization', scheme: 'Bearer' }`.
+ * - Baseten: `{ name: 'Authorization', scheme: 'Api-Key' }`.
+ * - Some gateways: `{ name: 'X-Api-Key' }`.
+ */
+interface OpenAICompatAuthHeader {
+    name: string;
+    scheme?: string;
+}
+interface OpenAICompatParams {
+    /** Bearer-style API key. */
+    apiKey: string;
+    /** Base URL — `/chat/completions` is appended. */
+    baseURL: string;
+    /** Default model id when `run({ model })` is omitted. */
+    defaultModel?: string;
+    /** Provider name exposed as `Provider.name`. Defaults to `'openai-compat'`. */
+    name?: string;
+    /** Auth header shape. Defaults to `{ name: 'Authorization', scheme: 'Bearer' }`. */
+    authHeader?: OpenAICompatAuthHeader;
+    /** Extra headers sent with every request (e.g. referer, user-agent). */
+    extraHeaders?: Record<string, string>;
+}
+/**
+ * Factory for any OpenAI-compatible HTTP endpoint.
+ *
+ * Speaks the standard `POST /chat/completions` + `stream: true` + SSE dialect.
+ * Thin wrappers (`openrouter`, `cerebras`) call this with pinned defaults.
+ *
+ * @example Baseten (non-standard auth scheme)
+ * ```ts
+ * openaiCompat({
+ *   name: 'baseten',
+ *   apiKey: process.env.BASETEN_API_KEY!,
+ *   baseURL: process.env.BASETEN_PROXY_URL!,
+ *   authHeader: { name: 'Authorization', scheme: 'Api-Key' },
+ * })
+ * ```
+ */
+declare function openaiCompat(params: OpenAICompatParams): Provider;
+
 interface OpenRouterParams {
     apiKey?: string;
     defaultModel?: string;
 }
+/**
+ * OpenRouter provider.
+ *
+ * Thin wrapper around {@link openaiCompat} with OpenRouter-specific defaults
+ * (base URL, default model) and required attribution headers.
+ */
 declare function openrouter(params?: OpenRouterParams): Provider;
 
 interface ToolSpec {
@@ -273,6 +549,23 @@ interface Provider {
     toolResultsMessage: (results: ToolResult[]) => SessionMessage;
     /** Stream a turn, calling onText for each text delta */
     stream: (options: StreamOptions, callbacks: StreamCallbacks) => Promise<TurnResult>;
+    /**
+     * Build a user `SessionMessage` from multimodal prompt parts.
+     *
+     * Providers that cannot handle a particular part type (e.g. document) should throw.
+     * The agent loop always canonicalizes the run-level prompt into parts before calling
+     * this method; providers may fall back to `userMessage` for the text-only path if
+     * they do not implement this.
+     */
+    promptMessage?: (parts: PromptPart[]) => SessionMessage;
+    /**
+     * Classify a native provider error for downstream typed-error wrapping.
+     *
+     * Return `null` when the error is not recognized — the loop will wrap it in
+     * `AgentProviderError` with the provider's name. Return a `ClassifiedError` to
+     * route it to one of the typed error classes.
+     */
+    classifyError?: (err: unknown) => ClassifiedError | null;
 }
 
 /** Core tools available in every basic harness (without spawn) */
@@ -324,6 +617,31 @@ interface HarnessConfig {
     skills?: SkillsConfig;
     /** Default behavior for agents using this harness */
     behavior?: AgentBehavior;
+    /**
+     * Map canonical tool names to LLM-facing (aliased) names.
+     *
+     * Aliasing is **LLM-boundary-only**:
+     * - The alias is what the provider's tool spec carries, what the model calls it, and
+     *   what appears in `ToolHookContext.displayName` / `McpToolHookContext.displayName`.
+     * - The canonical name is what lives in `session.turns`, `ToolHookContext.name`, and
+     *   what the agent uses to look up the tool implementation. Alias changes never
+     *   desync persisted history.
+     *
+     * Keys are canonical names from `tools` (or `mcp_{server}_{tool}` for MCP tools).
+     * Collisions between aliases are rejected by the loop.
+     *
+     * @example
+     * ```ts
+     * defineHarness({
+     *   tools: { ...basicTools },
+     *   toolAliases: { shell: 'Bash', read_file: 'Read', write_file: 'Write' },
+     * })
+     * ```
+     *
+     * @remarks Alias a tool only when the aliased name is semantically equivalent.
+     * `list_files` → `Glob` is NOT a valid alias because Glob is pattern-based.
+     */
+    toolAliases?: Record<string, string>;
 }
 /**
  * Define a harness with a name, optional system prompt, and tools.
@@ -347,6 +665,19 @@ interface McpConnection {
     tools: Record<string, ToolDef>;
     close: () => Promise<void>;
 }
+/**
+ * Normalize MCP server configs from any common shape to `McpServerConfig[]`.
+ *
+ * Accepts:
+ * - `McpServerConfig[]` — zidane native (pass-through).
+ * - `McpServerConfig` — a single config object (wrapped to a 1-element array).
+ * - `Record<string, RawShape>` — name-keyed map (common in host-SDK configs), where the key is the server name.
+ * - Mixed shapes with `type` vs `transport`, `httpUrl`/`sseUrl` vs `url`.
+ *
+ * Returns `[]` when `input` is nullish. Throws a descriptive error when the transport
+ * cannot be inferred from a given entry, or when the input shape is unsupported.
+ */
+declare function normalizeMcpServers(input: unknown): McpServerConfig[];
 /**
  * Convert MCP tool result content blocks to a single string.
  * Text blocks are extracted; non-text blocks are JSON-stringified.
@@ -364,6 +695,68 @@ declare function resultToString(content: unknown[]): string;
  */
 declare function connectMcpServers(configs: McpServerConfig[], _clientFactory?: () => Client, hooks?: Hookable<AgentHooks>): Promise<McpConnection>;
 
+/**
+ * File-map session store.
+ *
+ * Wraps a narrow 3-method adapter (`get` / `save` / `delete`) that exchanges a flat
+ * map of filename → string content. Useful for embedding zidane sessions inside
+ * host-provided session backends that only speak in file maps (not zidane's native
+ * `SessionStore` shape).
+ *
+ * Serialization format:
+ * - `turns.jsonl` — one `SessionTurn` per line.
+ * - `meta.json` — session metadata (id, agentId, status, runs, metadata, timestamps).
+ *
+ * JSONL for turns keeps history inspectable with tools like `jq` and resilient to
+ * partial corruption — parse up to the first bad line and you still have a valid
+ * prefix. Metadata lives in its own file so large turn logs don't bloat the
+ * metadata path.
+ *
+ * Scope: each `createFileMapStore` handles a **single session** — the adapter's
+ * file map holds at most one zidane session at a time. This matches how host SDKs
+ * scope their session stores per conversation.
+ *
+ * Divergences from the built-in memory / sqlite stores:
+ * - `appendTurns` / `updateStatus` / `updateRun` auto-create a minimal `SessionData`
+ *   record on first write, instead of silently no-oping when the session hasn't been
+ *   explicitly `save()`-ed. This matches the host-SDK integration path where
+ *   `createSession(...)` → `agent.run(...)` directly without an explicit `save()` call.
+ * - `updateRun` inserts the run if not found in the cached record (rather than
+ *   silently dropping). Run records therefore always reach the adapter.
+ */
+
+/**
+ * Host-provided file-map adapter. Three methods exchanging `Record<string, string>`
+ * payloads — the whole persistence surface the wrapper needs.
+ */
+interface FileMapAdapter {
+    /** Load the current file map. Returns an empty `files` record when nothing is persisted. */
+    get: () => Promise<{
+        files: Record<string, string>;
+    }>;
+    /** Replace the persisted file map. Full-rewrite semantics. */
+    save: (files: Record<string, string>) => Promise<void>;
+    /** Delete all persisted state. */
+    delete: () => Promise<void>;
+}
+interface FileMapStoreOptions {
+    /** Filename for the JSONL turns log. Default: `turns.jsonl`. */
+    turnsFile?: string;
+    /** Filename for the metadata JSON. Default: `meta.json`. */
+    metaFile?: string;
+}
+/**
+ * Create a single-session `SessionStore` backed by a file-map adapter.
+ *
+ * @example
+ * ```ts
+ * const session = await createSession({
+ *   store: createFileMapStore(hostSessionStore),
+ * })
+ * ```
+ */
+declare function createFileMapStore(adapter: FileMapAdapter, options?: FileMapStoreOptions): SessionStore;
+
 /**
  * In-memory session store.
  * Useful for development and testing. Data is lost when the process exits.
@@ -495,6 +888,13 @@ interface Session {
     readonly agentId?: string;
     /** Current turn history */
     readonly turns: SessionTurn[];
+    /**
+     * True when this session has no turns yet.
+     *
+     * Use this as a first-prompt signal when setting up a run — e.g. writing initial
+     * configuration only on fresh sessions. Equivalent to `turns.length === 0`.
+     */
+    readonly isEmpty: boolean;
     /** Top-level session status */
     readonly status: SessionData['status'];
     /** All runs in this session */
@@ -714,4 +1114,4 @@ interface Agent {
 }
 declare function createAgent({ harness: harnessOption, provider, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, _mcpConnector }: AgentOptions): Agent;
 
-export { defineHarness as $, type Agent as A, type ToolCall as B, type CerebrasParams as C, type ToolContext as D, type ToolDef as E, type ToolExecutionMode as F, type ToolHookContext as G, type Harness as H, type ImageContent as I, type ToolMap as J, type ToolResult as K, type ToolSpec as L, type McpConnection as M, type TurnResult as N, type OAuthRefreshHookContext as O, type Provider as P, type TurnUsage as Q, type RemoteStoreOptions as R, type Session as S, type ThinkingLevel as T, autoDetectAndConvert as U, connectMcpServers as V, createAgent as W, createMemoryStore as X, createRemoteStore as Y, createSession as Z, createSqliteStore as _, type AgentBehavior as a, fromAnthropic as a0, fromOpenAI as a1, loadSession as a2, noTools as a3, toAnthropic as a4, toOpenAI as a5, anthropic as a6, cerebras as a7, openai as a8, openrouter as a9, _default as aa, basicTools as ab, resultToString as ac, type AgentHooks as b, type AgentOptions as c, type AgentRunOptions as d, type AgentStats as e, type AnthropicParams as f, type ChildRunStats as g, type CreateSessionOptions as h, type HarnessConfig as i, type McpServerConfig as j, type McpToolHookContext as k, type OpenAIParams as l, type OpenRouterParams as m, type SessionContentBlock as n, type SessionData as o, type SessionEndStatus as p, type SessionHookContext as q, type SessionMessage as r, type SessionRun as s, type SessionStore as t, type SessionTurn as u, type SpawnHookContext as v, type SqliteStoreOptions as w, type StreamCallbacks as x, type StreamHookContext as y, type StreamOptions as z };
+export { type ToolResult as $, type Agent as A, type SessionEndStatus as B, CONTEXT_EXCEEDED_MESSAGE_PATTERNS as C, type SessionHookContext as D, type SessionMessage as E, type SessionRun as F, type SessionStore as G, type Harness as H, type ImageContent as I, type SessionTurn as J, type SpawnHookContext as K, type SqliteStoreOptions as L, type McpConnection as M, type StreamCallbacks as N, type OAuthRefreshHookContext as O, type PromptDocumentPart as P, type StreamHookContext as Q, type RemoteStoreOptions as R, type Session as S, type StreamOptions as T, type ThinkingLevel as U, type ToolCall as V, type ToolContext as W, type ToolDef as X, type ToolExecutionMode as Y, type ToolHookContext as Z, type ToolMap as _, AgentAbortedError as a, type ToolSpec as a0, type TurnFinishReason as a1, type TurnResult as a2, type TurnUsage as a3, matchesContextExceeded as a4, type FileMapAdapter as a5, type FileMapStoreOptions as a6, type OpenAICompatAuthHeader as a7, OpenAICompatHttpError as a8, type OpenAICompatParams as a9, resultToString as aA, anthropic as aa, autoDetectAndConvert as ab, cerebras as ac, classifyOpenAICompatError as ad, connectMcpServers as ae, createAgent as af, createFileMapStore as ag, createMemoryStore as ah, createRemoteStore as ai, createSession as aj, createSqliteStore as ak, defineHarness as al, fromAnthropic as am, fromOpenAI as an, loadSession as ao, mapOAIFinishReason as ap, noTools as aq, normalizeMcpServers as ar, openai as as, openaiCompat as at, openrouter as au, toAnthropic as av, toOpenAI as aw, toTypedError as ax, _default as ay, basicTools as az, type AgentBehavior as b, AgentContextExceededError as c, type AgentHooks as d, type AgentOptions as e, AgentProviderError as f, type AgentRunOptions as g, type AgentStats as h, type AnthropicParams as i, type CerebrasParams as j, type ChildRunStats as k, type ClassifiedError as l, type ClassifiedErrorKind as m, type CreateSessionOptions as n, type HarnessConfig as o, type McpServerConfig as p, type McpToolHookContext as q, type OpenAIParams as r, type OpenRouterParams as s, type PromptImagePart as t, type PromptPart as u, type PromptTextPart as v, type Provider as w, type RunHookMap as x, type SessionContentBlock as y, type SessionData as z };