zidane 2.2.0 → 2.2.2

package/README.md

@@ -4,7 +4,29 @@
 
 An agent that goes straight to the goal.
 
-Minimal TypeScript agent loop built with [Bun](https://bun.sh). Hook into every step using [hookable](https://github.com/unjs/hookable). Built to be embedded.
+Minimal TypeScript agent loop built with [Bun](https://bun.sh).
+
+Hook into every step using [hookable](https://github.com/unjs/hookable).
+
+Built to be embedded.
+
+## Features
+
+- 🧠 **Multi-provider** — Anthropic, OpenAI Codex, OpenRouter, Cerebras, plus a generic `openaiCompat` factory (Baseten, Fireworks, Groq, local servers). OAuth + API-key auth, auto-refreshing tokens.
+- 🔁 **Streaming turn loop** — stream text + thinking deltas, tool calls, and tool results with hookable events at every step.
+- 🛠 **Tools first-class** — shell, file IO, glob, spawn, human-in-the-loop, plus any [MCP](https://modelcontextprotocol.io) server. Sequential or parallel execution, per-call gates, typed hooks.
+- 🧩 **[Agent Skills](https://agentskills.io/specification) spec-aligned** — discover, activate, and run skills with `allowed-tools` enforcement and session-resume rehydration.
+- 💾 **Pluggable sessions** — in-memory, SQLite, remote HTTP, or a file-map adapter. Turns persist incrementally — a crash leaves valid partial history.
+- 🖼 **Multimodal** — images + documents via `PromptPart[]`; tools can return image blocks (screenshots, diagrams) routed natively on vision providers and via companion messages elsewhere.
+- 🧠 **Extended thinking** — named levels (`off` / `minimal` / `low` / `medium` / `high`) or exact token budgets; traces streamed + persisted.
+- ⚡ **Prompt caching** — auto-injected `cache_control` breakpoints on Anthropic + OpenRouter routes; cache-read / cache-write surfaced on `TurnUsage`.
+- 🚀 **Parallel MCP bootstrap** — every server connects concurrently with per-server timeouts; `agent.warmup()` + `eager: true` hide cold-start latency.
+- 🎯 **Structured output** — force the final answer to match a JSON Schema (Zod v4 interop), no brittle parsing.
+- 🧵 **Sub-agent spawning** — delegate to child agents with inherited or overridden preset; child stream/tool events bubble to the parent.
+- 🧭 **Typed errors** — `AgentContextExceededError` / `AgentProviderError` / `AgentAbortedError` instead of sniffing error strings.
+- 🔌 **Execution contexts** — run tools in-process, in Docker, or in a remote sandbox (E2B / Rivet / any `SandboxProvider`).
+- 🪝 **Hookable everything** — ~40 typed hook events covering turn, stream, tool, MCP, session, skills, spawn, OAuth refresh, and bootstrap timing.
+- 🧪 **915+ tests, zero API keys** — mock providers + mock execution contexts; suite runs in under 2 seconds.
 
 ## Quickstart
 
@@ -47,9 +69,11 @@ createAgent({
     maxTurns: 50,                    // max loop iterations
     maxTokens: 16384,                // max tokens per LLM response
     thinkingBudget: 10240,           // exact thinking token budget
+    cache: true,                     // prompt-cache breakpoints on supported providers (default: true)
   },
   execution: createProcessContext(), // where tools run
   mcpServers: [],                    // MCP tool servers
+  eager: true,                       // pre-warm MCP bootstrap in the background (default: false)
   skills: {},                        // skills configuration
 })
 ```
@@ -148,6 +172,39 @@ cerebras({ apiKey: 'csk-...', defaultModel: 'zai-glm-4.7' })
 
 Fallback: `params.apiKey` > `CEREBRAS_API_KEY` env
 
+### OpenAI-compatible (custom endpoints)
+
+Any OpenAI Chat Completions endpoint — Baseten, Fireworks, Groq, local LM servers, corporate proxies:
+
+```ts
+import { openaiCompat } from 'zidane/providers'
+
+openaiCompat({
+  name: 'baseten',
+  apiKey: process.env.BASETEN_API_KEY!,
+  baseURL: process.env.BASETEN_PROXY_URL!,
+  authHeader: { name: 'Authorization', scheme: 'Api-Key' },  // vendor-specific scheme
+  capabilities: { vision: false, imageInToolResult: false },
+  cacheBreakpoints: false,                                    // set true only for endpoints that honor `cache_control`
+})
+```
+
+`openrouter` and `cerebras` are thin wrappers around this factory with vendor defaults pinned. Reach for `openaiCompat` directly when adding a new backend instead of forking a bespoke provider.
+
+### Prompt caching
+
+Enabled by default via `behavior.cache`. The provider inserts `cache_control: { type: 'ephemeral' }` markers on the three largest stable prefixes — system prompt, tool definitions, and the last message's final content block — so the shared prefix is served from cache across turns.
+
+| Provider | Behavior |
+|---|---|
+| `anthropic` | Breakpoints honored natively. |
+| `openrouter` | Breakpoints forwarded; Anthropic + Gemini routes honor them, OpenAI / DeepSeek / Grok / Groq / Moonshot routes cache automatically and ignore the markers. |
+| `openaiCompat` | Opt-in via `cacheBreakpoints: true`. Default off so strict-schema endpoints (OpenAI direct, most OSS servers) don't reject unknown fields. |
+| `cerebras` | Off (factory doesn't enable breakpoints). |
+| `openai` (Codex) | Not affected — separate wire format (pi-ai). |
+
+Cache hits + writes land on `TurnUsage.cacheRead` / `TurnUsage.cacheCreation` and are surfaced via the `usage` hook.
+
 ## Presets
 
 Reusable slices of `AgentOptions` — spread them into `createAgent()`.
@@ -157,11 +214,13 @@ The `basic` preset bundles:
 | Tool | Description |
 |---|---|
 | `shell` | Execute shell commands |
-| `read_file` | Read file contents |
-| `write_file` | Write/create files |
-| `list_files` | List directory contents |
+| `readFile` | Read file contents |
+| `writeFile` | Write/create files |
+| `listFiles` | List directory contents |
 | `spawn` | Spawn a sub-agent |
 
+Extra tools live alongside: `glob` (pattern-based file matching), `createInteractionTool` (human-in-the-loop factory), and the three `skills_use` / `skills_read` / `skills_run_script` tools that auto-inject when the skills catalog is non-empty.
+
 Define a custom preset:
 
 ```ts
@@ -395,13 +454,17 @@ Turns are persisted incrementally after each turn — not as a full save. If the
 ### Storage backends
 
 ```ts
-import { createMemoryStore, createSqliteStore, createRemoteStore } from 'zidane/session'
+import { createMemoryStore, createRemoteStore, createFileMapStore } from 'zidane/session'
+import { createSqliteStore } from 'zidane/session/sqlite'   // separate subpath (Bun-only)
 
 createMemoryStore()                                    // in-memory, no persistence
-createSqliteStore({ path: './sessions.db' })           // SQLite (Bun built-in)
+createSqliteStore({ path: './sessions.db' })           // SQLite via bun:sqlite — WAL mode, per-turn flush
 createRemoteStore({ url: 'https://api.example.com' })  // HTTP REST API
+createFileMapStore(hostAdapter)                        // bridge to any { get, save, delete } file-map backend
 ```
 
+`createSqliteStore` lives on its own subpath because it depends on `bun:sqlite`. Non-Bun consumers importing from `zidane` or `zidane/session` never evaluate that module.
+
 ### Restoring a session
 
 ```ts
@@ -431,13 +494,47 @@ const agent = createAgent({
   ...basic,
   provider,
   mcpServers: [
-    { name: 'fs', transport: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', '.'] },
+    { name: 'fs', transport: 'stdio', command: 'npx', args: ['-y', '@modelcontextprotocol/server-filesystem', '.'], bootstrapTimeout: 10_000 },
     { name: 'api', transport: 'streamable-http', url: 'http://localhost:3002/mcp' },
   ],
 })
 ```
 
 MCP servers can live on a preset too (they're just `AgentOptions` fields). Connections are lazy (first `run()`) and reused.
+Set `bootstrapTimeout` to cap how long a slow `connect + listTools` phase can delay the first model request.
+
+### Hiding bootstrap latency
+
+Every server is bootstrapped in parallel, but the first `run()` still waits for the slowest one. Two knobs to hide the cost:
+
+```ts
+// Option 1 — pre-warm manually behind other setup work.
+const agent = createAgent({ provider, mcpServers })
+await Promise.all([agent.warmup(), authenticate(), loadConfig()])
+await agent.run({ prompt: 'go' })                 // no MCP wait here
+
+// Option 2 — let createAgent kick the warmup off for you.
+const agent = createAgent({ provider, mcpServers, eager: true })
+// ... unrelated startup work ...
+await agent.run({ prompt: 'go' })                 // awaits the in-flight warmup
+```
+
+`warmup()` is idempotent and safe to call from multiple callers concurrently. Failures are surfaced on the next `warmup()` / `run()` rather than crashing the eager kickoff.
+
+### Observability
+
+Two hooks fire around each per-server bootstrap, regardless of success:
+
+```ts
+agent.hooks.hook('mcp:bootstrap:start', ({ name, transport }) => { /* ... */ })
+agent.hooks.hook('mcp:bootstrap:end', (ctx) => {
+  // ctx.name, ctx.transport, ctx.durationMs
+  // ctx.ok === true  → ctx.toolCount
+  // ctx.ok === false → ctx.error
+})
+```
+
+Use these to attribute cold-start latency per server — the only way to know if a specific MCP (e.g. a remote GitHub MCP) is the one stretching your first `run()`.
 
 ## Skills
 
@@ -541,6 +638,7 @@ agent.isRunning           // is a run in progress?
 agent.turns               // conversation history (SessionTurn[])
 agent.abort()             // cancel the current run
 agent.reset()             // clear messages and queues
+await agent.warmup()      // pre-connect MCP (idempotent, safe to call concurrently)
 await agent.destroy()     // clean up context + MCP connections
 await agent.waitForIdle() // wait for current run to complete
 ```
@@ -554,8 +652,12 @@ type SessionContentBlock =
   | { type: 'text', text: string }
   | { type: 'image', mediaType: string, data: string }
   | { type: 'tool_call', id: string, name: string, input: Record<string, unknown> }
-  | { type: 'tool_result', callId: string, output: string, isError?: boolean }
-  | { type: 'thinking', text: string }
+  | { type: 'tool_result', callId: string, output: string | ToolResultContent[], isError?: boolean }
+  | { type: 'thinking', text: string, signature?: string }
+
+type ToolResultContent =
+  | { type: 'text', text: string }
+  | { type: 'image', mediaType: string, data: string }
 
 interface SessionMessage {
   role: 'user' | 'assistant'
@@ -563,12 +665,39 @@ interface SessionMessage {
 }
 ```
 
+Tool results can carry structured content — pure-text tools keep returning a `string`, tools that produce images (MCP browser servers, screenshot tools) return a `ToolResultContent[]` that the loop routes natively on providers with `imageInToolResult: true` and via a companion user message elsewhere. Use `toolResultToText(output)` to flatten when a consumer only handles strings.
+
 Converters for external interop:
 
 ```ts
 import { fromAnthropic, toAnthropic, fromOpenAI, toOpenAI, autoDetectAndConvert } from 'zidane'
 ```
 
+## Typed Errors
+
+Provider failures are wrapped into typed error classes before leaving `agent.run()` — match on `instanceof` instead of sniffing strings.
+
+```ts
+import { AgentAbortedError, AgentContextExceededError, AgentProviderError } from 'zidane'
+
+try {
+  await agent.run({ prompt })
+}
+catch (err) {
+  if (err instanceof AgentContextExceededError) {
+    // prune history, retry
+  }
+  else if (err instanceof AgentAbortedError) {
+    // user cancelled
+  }
+  else if (err instanceof AgentProviderError) {
+    console.error(`${err.provider}: ${err.message} (${err.providerCode})`)
+  }
+}
+```
+
+Every provider ships a `classifyError(err)` that maps native errors into a `ClassifiedError` union — unrecognized errors fall through as `AgentProviderError`. Abort paths (`agent.abort()` or a triggered `AbortSignal`) always produce `AgentAbortedError` regardless of classification.
+
 ## Structured Output
 
 Force the agent's final response to match a JSON Schema via provider-level tool forcing.
@@ -612,8 +741,9 @@ const schema = zodToJsonSchema(z.toJsonSchema(z.object({ name: z.string() })))
 
 ```ts
 const stats = await agent.run({ prompt: 'hello' })
-stats.turnUsage   // TurnUsage[] — per-turn { input, output, cacheCreation?, cacheRead?, thinking?, cost? }
-stats.cost        // total USD cost (if reported by provider)
+stats.turnUsage                 // TurnUsage[] — per-turn { input, output, cacheCreation?, cacheRead?, thinking?, cost?, finishReason?, modelId? }
+stats.cost                      // total USD cost (if reported by provider)
+stats.timeTillFirstTokenMs      // ms from run() start to the first stream/tool event
 ```
 
 ## Types
@@ -633,7 +763,11 @@ import type { ToolHookContext, McpToolHookContext, SessionHookContext, StreamHoo
 bun test
 ```
 
-495+ tests with mock provider and execution context. No API keys or Docker needed.
+915+ tests with mock provider and execution context. No API keys or Docker needed; the suite runs in under 2 seconds.
+
+## Benchmarks
+
+Harness integrations for running zidane against public agent benchmarks live in [`benchmarks/`](./benchmarks). First integration: [Terminal-Bench](./benchmarks/terminal-bench).
 
 ## License
 

package/dist/{agent-vPBFXnu-.d.ts → agent-C0hLXofc.d.ts}

@@ -153,6 +153,16 @@ interface McpServerConfig {
     url?: string;
     /** Optional headers for HTTP transports */
     headers?: Record<string, string>;
+    /**
+     * Timeout in milliseconds for MCP server bootstrap (connect + tool discovery).
+     *
+     * Zidane connects MCP servers lazily on the first `run()`. Without a
+     * bootstrap timeout, a slow or hung server can delay the first provider call
+     * for an arbitrarily long time even when that MCP server is never used.
+     *
+     * Default: `10000`.
+     */
+    bootstrapTimeout?: number;
     /** Timeout in milliseconds for MCP tool calls (default: 30000) */
     toolTimeout?: number;
 }
@@ -166,8 +176,24 @@ interface AgentBehavior {
     maxTokens?: number;
     /** Thinking token budget — overrides the level-based default when set */
     thinkingBudget?: number;
-    /** JSON Schema for structured output. When set, the agent's final turn produces JSON matching this schema. */
+    /** JSON Schema for structured output enforcement */
     schema?: Record<string, unknown>;
+    /**
+     * Enable provider prompt caching. When on (default), the provider marks the
+     * system prompt, tools, and the last stable message with cache breakpoints so
+     * the shared prefix is served from cache across turns.
+     *
+     * - Anthropic: `cache_control: { type: 'ephemeral' }` on the last `system`
+     *   content part, the last tool, and the last message content part.
+     * - OpenAI-compatible / OpenRouter: same shape — honored by Anthropic-backed
+     *   OpenRouter routes and by Gemini; ignored (no-op) by providers that cache
+     *   automatically (OpenAI, DeepSeek, Grok, Groq, Moonshot).
+     *
+     * Usage is surfaced via `TurnUsage.cacheRead` / `TurnUsage.cacheCreation`.
+     *
+     * Default: `true`.
+     */
+    cache?: boolean;
 }
 interface ImageContent {
     type: 'image';
@@ -600,6 +626,20 @@ interface OpenAICompatParams {
      * (e.g. OpenRouter vision models, Baseten image-capable deployments).
      */
     capabilities?: ProviderCapabilities;
+    /**
+     * Whether this endpoint honors `cache_control: { type: 'ephemeral' }` markers
+     * on message content parts and tool definitions.
+     *
+     * - `true`  — inject markers when the caller asks for caching. OpenRouter routes
+     *             to Anthropic/Gemini forward the markers; routes to OpenAI/DeepSeek/
+     *             Grok/Groq/Moonshot ignore them (those backends cache automatically).
+     * - `false` — never inject markers. Safe default for endpoints that strictly
+     *             validate the request schema (OpenAI direct, most OSS inference
+     *             servers) and would reject unknown fields.
+     *
+     * Default: `false`. The `openrouter` wrapper sets this to `true`.
+     */
+    cacheBreakpoints?: boolean;
 }
 /**
  * Factory for any OpenAI-compatible HTTP endpoint.
@@ -723,6 +763,14 @@ interface StreamOptions {
         type: 'auto' | 'required' | 'tool';
         name?: string;
     };
+    /**
+     * Enable prompt caching on this call. When `true`, providers that support it
+     * insert `cache_control` breakpoints on the system prompt, last tool, and
+     * last stable message so the shared prefix is cached across turns.
+     *
+     * Default: `false` (providers opt callers in — the agent loop passes `true`).
+     */
+    cache?: boolean;
     /** Abort signal for cancellation */
     signal?: AbortSignal;
 }
@@ -1448,6 +1496,30 @@ interface AgentHooks {
     'mcp:close': (ctx: {
         name: string;
     }) => void;
+    /**
+     * Fires at the start of a per-server bootstrap attempt, before any network I/O.
+     * Pairs with `mcp:bootstrap:end` and is always emitted, regardless of outcome.
+     */
+    'mcp:bootstrap:start': (ctx: {
+        name: string;
+        transport: string;
+    }) => void;
+    /**
+     * Fires at the end of a per-server bootstrap attempt. `durationMs` spans from
+     * the matching `mcp:bootstrap:start`. On `ok: false` carries the originating
+     * error so consumers can log / trace without relying on a separate `mcp:error`.
+     */
+    'mcp:bootstrap:end': (ctx: {
+        name: string;
+        transport: string;
+        durationMs: number;
+    } & ({
+        ok: true;
+        toolCount: number;
+    } | {
+        ok: false;
+        error: Error;
+    })) => void;
     'mcp:tool:gate': (ctx: McpToolHookContext & {
         block: boolean;
         reason: string;
@@ -1535,8 +1607,21 @@ interface AgentOptions {
     session?: Session;
     /** Skills configuration */
     skills?: SkillsConfig;
-    /** @internal */
-    _mcpConnector?: (configs: McpServerConfig[]) => Promise<McpConnection>;
+    /** @internal Test-only override for the MCP connector. Public consumers should not rely on this. */
+    mcpConnector?: (configs: McpServerConfig[]) => Promise<McpConnection>;
+    /**
+     * Pre-connect MCP servers in the background as soon as `createAgent` returns,
+     * instead of deferring the bootstrap to the first `agent.run()`.
+     *
+     * Useful when MCP latency is the dominant cost of a cold start: callers that
+     * construct the agent early (e.g. at process init) can hide the bootstrap
+     * behind other setup work. If bootstrap fails, the error is stored and
+     * surfaced on the first `agent.run()` / `agent.warmup()`; the in-flight
+     * promise is `await`ed by both paths so the error is never silently lost.
+     *
+     * No-op when `mcpServers` is empty. Default: `false`.
+     */
+    eager?: boolean;
 }
 interface Agent {
     hooks: Hookable<AgentHooks>;
@@ -1568,6 +1653,17 @@ interface Agent {
      * No-op when the skill wasn't active.
      */
     deactivateSkill: (name: string) => Promise<void>;
+    /**
+     * Pre-connect MCP servers without running a turn. Idempotent and concurrency-safe:
+     * - No MCP servers configured → resolves immediately.
+     * - Connection already established → resolves immediately.
+     * - Another `warmup()` / `run()` is bootstrapping → awaits the in-flight promise.
+     *
+     * Use from host code that wants to hide MCP bootstrap latency behind other
+     * startup work (UI init, auth, etc.). Safe to call multiple times and from
+     * multiple callers concurrently.
+     */
+    warmup: () => Promise<void>;
     readonly isRunning: boolean;
     readonly turns: SessionTurn[];
     readonly execution: ExecutionContext;
@@ -1577,6 +1673,6 @@ interface Agent {
     readonly activeSkills: readonly ActiveSkill[];
     meta: Record<string, unknown>;
 }
-declare function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, _mcpConnector }: AgentOptions): Agent;
+declare function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, mcpConnector, eager }: AgentOptions): Agent;
 
 export { type ToolHookContext as $, type Agent as A, type SessionData as B, CONTEXT_EXCEEDED_MESSAGE_PATTERNS as C, type SessionEndStatus as D, type SessionHookContext as E, type SessionMessage as F, type SessionRun as G, type SessionStore as H, type ImageContent as I, type SessionTurn as J, type SkillConfig as K, type SkillResource as L, type McpConnection as M, type SkillsConfig as N, type OAuthRefreshHookContext as O, type PromptDocumentPart as P, type SpawnHookContext as Q, type RemoteStoreOptions as R, type Session as S, type StreamCallbacks as T, type StreamHookContext as U, type StreamOptions as V, type ThinkingLevel as W, type ToolCall as X, type ToolContext as Y, type ToolDef as Z, type ToolExecutionMode as _, AgentAbortedError as a, type ToolMap as a0, type ToolResult as a1, type ToolResultContent as a2, type ToolResultImageContent as a3, type ToolResultTextContent as a4, type ToolSpec as a5, type TurnFinishReason as a6, type TurnResult as a7, type TurnUsage as a8, matchesContextExceeded as a9, loadSession as aA, mapOAIFinishReason as aB, normalizeMcpBlocks as aC, normalizeMcpServers as aD, openai as aE, openaiCompat as aF, openrouter as aG, resultToString as aH, toAnthropic as aI, toOpenAI as aJ, toTypedError as aK, toolResultToText as aa, type ActivationVia as ab, type ActiveSkill as ac, type DeactivationReason as ad, type FileMapAdapter as ae, type FileMapStoreOptions as af, type OpenAICompatAuthHeader as ag, OpenAICompatHttpError as ah, type OpenAICompatParams as ai, type SkillActivationState as aj, type SkillActivationStateOptions as ak, type SkillDiagnostic as al, type SkillSource as am, anthropic as an, autoDetectAndConvert as ao, cerebras as ap, classifyOpenAICompatError as aq, connectMcpServers as ar, createAgent as as, createFileMapStore as at, createMemoryStore as au, createRemoteStore as av, createSession as aw, createSkillActivationState as ax, fromAnthropic as ay, fromOpenAI 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, AgentToolNotAllowedError as i, type AnthropicParams as j, type CerebrasParams as k, type ChildRunStats as l, type ClassifiedError as m, type ClassifiedErrorKind as n, type CreateSessionOptions 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 ProviderCapabilities as x, type RunHookMap as y, type SessionContentBlock as z };

package/dist/{chunk-S3FCOMRI.js → chunk-CYWF2U62.js}

@@ -84,10 +84,14 @@ async function consumeSSE(response, callbacks, signal) {
         }
         const chunkUsage = chunk.usage;
         if (chunkUsage) {
+          const cachedRead = chunkUsage.prompt_tokens_details?.cached_tokens;
+          const cachedWrite = chunkUsage.prompt_tokens_details?.cache_creation_input_tokens ?? chunkUsage.prompt_tokens_details?.cache_write_tokens ?? chunkUsage.cache_creation_input_tokens;
           usage = {
             input: chunkUsage.prompt_tokens ?? 0,
             output: chunkUsage.completion_tokens ?? 0,
-            cost: chunkUsage.total_cost ?? void 0
+            cost: chunkUsage.total_cost ?? void 0,
+            ...typeof cachedRead === "number" && cachedRead > 0 ? { cacheRead: cachedRead } : {},
+            ...typeof cachedWrite === "number" && cachedWrite > 0 ? { cacheCreation: cachedWrite } : {}
           };
         }
       }
@@ -204,6 +208,38 @@ ${attachedMarker}` : attachedMarker;
   }
   return out;
 }
+var EPHEMERAL = { type: "ephemeral" };
+function applyOAICacheBreakpoints(messages) {
+  if (messages.length === 0)
+    return;
+  const first = messages[0];
+  if (first.role === "system")
+    markLastContentPart(first);
+  const lastIdx = messages.length - 1;
+  if (lastIdx > 0)
+    markLastContentPart(messages[lastIdx]);
+}
+function markLastContentPart(msg) {
+  if (typeof msg.content === "string") {
+    if (msg.content.length === 0)
+      return;
+    msg.content = [{ type: "text", text: msg.content, cache_control: EPHEMERAL }];
+    return;
+  }
+  if (!Array.isArray(msg.content) || msg.content.length === 0)
+    return;
+  const parts = msg.content;
+  const lastBlockIdx = parts.length - 1;
+  parts[lastBlockIdx] = { ...parts[lastBlockIdx], cache_control: EPHEMERAL };
+}
+function applyOAIToolCacheBreakpoint(tools) {
+  if (tools.length === 0)
+    return tools;
+  const lastIdx = tools.length - 1;
+  return tools.map(
+    (tool, i) => i === lastIdx ? { ...tool, cache_control: EPHEMERAL } : tool
+  );
+}
 function formatTools(tools) {
   return tools.map((t) => ({
     type: "function",
@@ -337,6 +373,7 @@ function openaiCompat(params) {
     vision: params.capabilities?.vision ?? false,
     imageInToolResult: params.capabilities?.imageInToolResult ?? false
   };
+  const cacheBreakpointsEnabled = params.cacheBreakpoints === true;
   return {
     name,
     meta: { defaultModel, capabilities },
@@ -350,6 +387,10 @@ function openaiCompat(params) {
       const messages = toOAIMessages(options.system, options.messages, {
         imageInToolResult: capabilities.imageInToolResult === true
       });
+      const shouldCache = cacheBreakpointsEnabled && options.cache !== false;
+      if (shouldCache) {
+        applyOAICacheBreakpoints(messages);
+      }
       const maxTokens = options.thinkingBudget ? options.thinkingBudget + options.maxTokens : options.maxTokens;
       const body = {
         model: modelId,
@@ -357,8 +398,9 @@ function openaiCompat(params) {
         max_tokens: maxTokens,
         stream: true
       };
-      if (options.tools && options.tools.length > 0)
-        body.tools = options.tools;
+      if (options.tools && options.tools.length > 0) {
+        body.tools = shouldCache ? applyOAIToolCacheBreakpoint(options.tools) : options.tools;
+      }
       if (options.toolChoice) {
         if (options.toolChoice.type === "tool" && options.toolChoice.name)
           body.tool_choice = { type: "function", function: { name: options.toolChoice.name } };

package/dist/{chunk-37GD7NL3.js → chunk-DRAYZZ23.js}

@@ -3,6 +3,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { getDefaultEnvironment, StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var DEFAULT_MCP_BOOTSTRAP_TIMEOUT_MS = 1e4;
 function inferTransport(raw) {
   if (raw.transport === "stdio" || raw.transport === "sse" || raw.transport === "streamable-http")
     return raw.transport;
@@ -34,6 +35,8 @@ function normalizeOne(name, raw) {
     config.url = url;
   if (raw.headers)
     config.headers = raw.headers;
+  if (typeof raw.bootstrapTimeout === "number")
+    config.bootstrapTimeout = raw.bootstrapTimeout;
   if (typeof raw.toolTimeout === "number")
     config.toolTimeout = raw.toolTimeout;
   return config;
@@ -148,113 +151,25 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
   const tools = {};
   const errors = [];
   let closed = false;
-  for (const config of configs) {
-    try {
-      const client = _clientFactory ? _clientFactory() : new Client({ name: "zidane", version: "1.0.0" });
-      const transport = createTransport(config);
-      await client.connect(transport);
-      connections.push({ name: config.name, client });
-      const { tools: mcpTools } = await client.listTools();
-      const toolNames = [];
-      for (const tool of mcpTools) {
-        const namespacedName = `mcp_${config.name}_${tool.name}`;
-        toolNames.push(namespacedName);
-        tools[namespacedName] = {
-          spec: {
-            name: namespacedName,
-            description: tool.description || "",
-            inputSchema: tool.inputSchema ?? { type: "object", properties: {} }
-          },
-          execute: async (input, ctx) => {
-            const { turnId, callId, signal } = ctx;
-            const displayName = ctx.toolAliases?.[namespacedName] ?? namespacedName;
-            const gateCtx = {
-              turnId,
-              callId,
-              server: config.name,
-              tool: tool.name,
-              displayName,
-              input,
-              block: false,
-              reason: "MCP tool execution was blocked"
-            };
-            await hooks?.callHook("mcp:tool:gate", gateCtx);
-            if (gateCtx.block)
-              return `Blocked: ${gateCtx.reason}`;
-            const effectiveInput = gateCtx.input;
-            await hooks?.callHook("mcp:tool:before", {
-              turnId,
-              callId,
-              server: config.name,
-              tool: tool.name,
-              displayName,
-              input: effectiveInput
-            });
-            const timeout = config.toolTimeout ?? 3e4;
-            try {
-              const result = await raceWithTimeoutAndSignal(
-                () => client.callTool({ name: tool.name, arguments: effectiveInput }),
-                timeout,
-                `MCP tool "${tool.name}" on server "${config.name}" timed out after ${timeout}ms`,
-                signal
-              );
-              let output = packMcpResult(result.content);
-              const transformCtx = {
-                turnId,
-                callId,
-                server: config.name,
-                tool: tool.name,
-                displayName,
-                input: effectiveInput,
-                result: output
-              };
-              await hooks?.callHook("mcp:tool:transform", transformCtx);
-              output = transformCtx.result;
-              await hooks?.callHook("mcp:tool:after", {
-                turnId,
-                callId,
-                server: config.name,
-                tool: tool.name,
-                displayName,
-                input: effectiveInput,
-                result: output
-              });
-              return output;
-            } catch (err) {
-              const error = err instanceof Error ? err : new Error(String(err));
-              await hooks?.callHook("mcp:tool:error", {
-                turnId,
-                callId,
-                server: config.name,
-                tool: tool.name,
-                displayName,
-                input: effectiveInput,
-                error
-              });
-              await hooks?.callHook("mcp:tool:after", {
-                turnId,
-                callId,
-                server: config.name,
-                tool: tool.name,
-                displayName,
-                input: effectiveInput,
-                result: error.message
-              });
-              throw error;
-            }
-          }
-        };
-      }
-      await hooks?.callHook("mcp:connect", {
-        name: config.name,
-        transport: config.transport,
-        tools: toolNames
-      });
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      errors.push({ name: config.name, error });
-      await hooks?.callHook("mcp:error", { name: config.name, error });
+  const bootstrapResults = await Promise.all(configs.map((config) => bootstrapServer(config, _clientFactory, hooks)));
+  for (const result of bootstrapResults) {
+    if (!result.ok) {
+      errors.push({ name: result.name, error: result.error });
+      await hooks?.callHook("mcp:error", { name: result.name, error: result.error });
+      continue;
+    }
+    connections.push({ name: result.name, client: result.client });
+    const toolNames = [];
+    for (const tool of result.tools) {
+      const namespacedName = `mcp_${result.config.name}_${tool.name}`;
+      toolNames.push(namespacedName);
+      tools[namespacedName] = buildMcpToolDef(result.config, result.client, tool, namespacedName, hooks);
     }
+    await hooks?.callHook("mcp:connect", {
+      name: result.name,
+      transport: result.config.transport,
+      tools: toolNames
+    });
   }
   if (errors.length > 0 && connections.length === 0) {
     const messages = errors.map((e) => `${e.name}: ${e.error.message}`).join(", ");
@@ -275,6 +190,153 @@ async function connectMcpServers(configs, _clientFactory, hooks) {
     }
   };
 }
+async function bootstrapServer(config, _clientFactory, hooks) {
+  const start = Date.now();
+  await hooks?.callHook("mcp:bootstrap:start", { name: config.name, transport: config.transport });
+  let client = null;
+  try {
+    client = _clientFactory ? _clientFactory() : new Client({ name: "zidane", version: "1.0.0" });
+    const currentClient = client;
+    const transport = createTransport(config);
+    const bootstrapTimeout = config.bootstrapTimeout ?? DEFAULT_MCP_BOOTSTRAP_TIMEOUT_MS;
+    const { tools: mcpTools } = await raceWithTimeout(
+      async () => {
+        await currentClient.connect(transport);
+        return await currentClient.listTools();
+      },
+      bootstrapTimeout,
+      `MCP server "${config.name}" bootstrap timed out after ${bootstrapTimeout}ms`
+    );
+    const durationMs = Date.now() - start;
+    await hooks?.callHook("mcp:bootstrap:end", {
+      name: config.name,
+      transport: config.transport,
+      durationMs,
+      ok: true,
+      toolCount: mcpTools.length
+    });
+    return { ok: true, name: config.name, config, client: currentClient, tools: mcpTools };
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    await closeClientQuietly(client);
+    const durationMs = Date.now() - start;
+    await hooks?.callHook("mcp:bootstrap:end", {
+      name: config.name,
+      transport: config.transport,
+      durationMs,
+      ok: false,
+      error
+    });
+    return { ok: false, name: config.name, error };
+  }
+}
+function buildMcpToolDef(config, client, tool, namespacedName, hooks) {
+  return {
+    spec: {
+      name: namespacedName,
+      description: tool.description || "",
+      inputSchema: tool.inputSchema ?? { type: "object", properties: {} }
+    },
+    execute: async (input, ctx) => {
+      const { turnId, callId, signal } = ctx;
+      const displayName = ctx.toolAliases?.[namespacedName] ?? namespacedName;
+      const gateCtx = {
+        turnId,
+        callId,
+        server: config.name,
+        tool: tool.name,
+        displayName,
+        input,
+        block: false,
+        reason: "MCP tool execution was blocked"
+      };
+      await hooks?.callHook("mcp:tool:gate", gateCtx);
+      if (gateCtx.block)
+        return `Blocked: ${gateCtx.reason}`;
+      const effectiveInput = gateCtx.input;
+      await hooks?.callHook("mcp:tool:before", {
+        turnId,
+        callId,
+        server: config.name,
+        tool: tool.name,
+        displayName,
+        input: effectiveInput
+      });
+      const timeout = config.toolTimeout ?? 3e4;
+      try {
+        const result = await raceWithTimeoutAndSignal(
+          () => client.callTool({ name: tool.name, arguments: effectiveInput }),
+          timeout,
+          `MCP tool "${tool.name}" on server "${config.name}" timed out after ${timeout}ms`,
+          signal
+        );
+        let output = packMcpResult(result.content);
+        const transformCtx = {
+          turnId,
+          callId,
+          server: config.name,
+          tool: tool.name,
+          displayName,
+          input: effectiveInput,
+          result: output
+        };
+        await hooks?.callHook("mcp:tool:transform", transformCtx);
+        output = transformCtx.result;
+        await hooks?.callHook("mcp:tool:after", {
+          turnId,
+          callId,
+          server: config.name,
+          tool: tool.name,
+          displayName,
+          input: effectiveInput,
+          result: output
+        });
+        return output;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        await hooks?.callHook("mcp:tool:error", {
+          turnId,
+          callId,
+          server: config.name,
+          tool: tool.name,
+          displayName,
+          input: effectiveInput,
+          error
+        });
+        await hooks?.callHook("mcp:tool:after", {
+          turnId,
+          callId,
+          server: config.name,
+          tool: tool.name,
+          displayName,
+          input: effectiveInput,
+          result: error.message
+        });
+        throw error;
+      }
+    }
+  };
+}
+async function closeClientQuietly(client) {
+  if (!client)
+    return;
+  try {
+    await client.close();
+  } catch {
+  }
+}
+async function raceWithTimeout(task, timeoutMs, timeoutMessage) {
+  let timer;
+  try {
+    return await new Promise((resolvePromise, rejectPromise) => {
+      timer = setTimeout(() => rejectPromise(new Error(timeoutMessage)), timeoutMs);
+      task().then(resolvePromise, rejectPromise);
+    });
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
 async function raceWithTimeoutAndSignal(task, timeoutMs, timeoutMessage, signal) {
   if (signal?.aborted)
     throw new Error("MCP tool call aborted");

package/dist/{chunk-SP5NA6WF.js → chunk-MDVZX6GM.js}

@@ -4,7 +4,7 @@ import {
   shell,
   spawn,
   writeFile
-} from "./chunk-F5UBXERT.js";
+} from "./chunk-O2XZLJMG.js";
 
 // src/presets/basic.ts
 var basicTools = { shell, readFile, writeFile, listFiles };

package/dist/{chunk-F5UBXERT.js → chunk-O2XZLJMG.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-2EQT4EHD.js";
 import {
   connectMcpServers
-} from "./chunk-37GD7NL3.js";
+} from "./chunk-DRAYZZ23.js";
 import {
   AgentAbortedError,
   AgentProviderError,
@@ -589,6 +589,7 @@ async function executeTurn(ctx, turn) {
     maxTokens: ctx.maxTokens ?? 16384,
     thinking: ctx.thinking,
     thinkingBudget: ctx.thinkingBudget,
+    cache: ctx.cache ?? true,
     signal: ctx.signal
   };
   const transformCtx = { messages: streamOptions.messages };
@@ -960,6 +961,8 @@ var HOOK_EVENT_NAMES = [
   "mcp:connect",
   "mcp:error",
   "mcp:close",
+  "mcp:bootstrap:start",
+  "mcp:bootstrap:end",
   "mcp:tool:gate",
   "mcp:tool:before",
   "mcp:tool:after",
@@ -989,10 +992,11 @@ function resolveBehavior(agentBehavior, runBehavior) {
     maxTurns: runBehavior?.maxTurns ?? agentBehavior?.maxTurns,
     maxTokens: runBehavior?.maxTokens ?? agentBehavior?.maxTokens,
     thinkingBudget: runBehavior?.thinkingBudget ?? agentBehavior?.thinkingBudget,
-    schema: runBehavior?.schema ?? agentBehavior?.schema
+    schema: runBehavior?.schema ?? agentBehavior?.schema,
+    cache: runBehavior?.cache ?? agentBehavior?.cache ?? true
   };
 }
-function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, _mcpConnector }) {
+function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, mcpConnector, eager }) {
   const hooks = createHooks();
   const executionContext = execution ?? createProcessContext();
   const sourceTools = agentTools ?? {};
@@ -1002,6 +1006,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
   let idlePromise;
   let executionHandle = null;
   let mcpConnection = null;
+  let mcpWarmupPromise = null;
   const allMcpServers = mcpServers ?? [];
   const steeringQueue = [];
   const followUpQueue = [];
@@ -1076,11 +1081,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
       executionHandle = await executionContext.spawn();
     }
     if (allMcpServers.length > 0 && !mcpConnection) {
-      if (_mcpConnector) {
-        mcpConnection = await _mcpConnector(allMcpServers);
-      } else {
-        mcpConnection = await connectMcpServers(allMcpServers, void 0, hooks);
-      }
+      await warmup();
     }
     if (!skillsDisabled && skillsConfig && !resolvedSkills) {
       resolvedSkills = await resolveSkills(skillsConfig);
@@ -1115,7 +1116,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
     }
     const thinking = options.thinking ?? "off";
     const model = options.model ?? provider.meta.defaultModel;
-    const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema } = resolveBehavior(agentBehavior, options.behavior);
+    const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache } = resolveBehavior(agentBehavior, options.behavior);
     let system = options.system || agentSystem || "You are a helpful assistant.";
     if (skillsCatalog) {
       system = `${system}
@@ -1177,6 +1178,12 @@ ${skillsCatalog}`;
     }
     conversationTurns = turns;
     let lastPersistedTurnCount = isResume ? session.turns.length : 0;
+    if (session && turns.length > lastPersistedTurnCount) {
+      const seededTurns = turns.slice(lastPersistedTurnCount);
+      await session.appendTurns(seededTurns);
+      lastPersistedTurnCount = turns.length;
+      await hooks.callHook("session:turns", { sessionId: session.id, turns: seededTurns, count: turns.length });
+    }
     const unregisterSessionSync = session ? hooks.hook("turn:after", async () => {
       const newTurns = turns.slice(lastPersistedTurnCount);
       if (newTurns.length > 0) {
@@ -1243,6 +1250,7 @@ ${skillsCatalog}`;
         depth: runDepth,
         thinkingBudget,
         schema,
+        cache,
         runStartMs
       });
       const finalStats = {
@@ -1358,10 +1366,39 @@ ${skillsCatalog}`;
     };
   }
   let destroyed = false;
+  async function warmup() {
+    if (destroyed)
+      return;
+    if (mcpConnection || allMcpServers.length === 0)
+      return;
+    if (mcpWarmupPromise)
+      return mcpWarmupPromise;
+    mcpWarmupPromise = (async () => {
+      const connection = mcpConnector ? await mcpConnector(allMcpServers) : await connectMcpServers(allMcpServers, void 0, hooks);
+      if (destroyed) {
+        await connection.close().catch(() => {
+        });
+        return;
+      }
+      mcpConnection = connection;
+    })();
+    try {
+      await mcpWarmupPromise;
+    } catch (err) {
+      mcpWarmupPromise = null;
+      throw err;
+    }
+  }
   async function destroy() {
     if (destroyed)
       return;
     destroyed = true;
+    if (mcpWarmupPromise) {
+      try {
+        await mcpWarmupPromise;
+      } catch {
+      }
+    }
     if (mcpConnection) {
       await mcpConnection.close();
       mcpConnection = null;
@@ -1371,6 +1408,10 @@ ${skillsCatalog}`;
       executionHandle = null;
     }
   }
+  if (eager && allMcpServers.length > 0) {
+    void warmup().catch(() => {
+    });
+  }
   return {
     hooks,
     run,
@@ -1380,6 +1421,7 @@ ${skillsCatalog}`;
     waitForIdle,
     reset,
     destroy,
+    warmup,
     activateSkill,
     deactivateSkill,
     get isRunning() {

package/dist/{chunk-CDRXC7A7.js → chunk-ZSEMKVHP.js}

@@ -5,7 +5,7 @@ import {
   toAnthropic,
   toolResultsMessage,
   userMessage
-} from "./chunk-S3FCOMRI.js";
+} from "./chunk-CYWF2U62.js";
 import {
   matchesContextExceeded
 } from "./chunk-LNN5UTS2.js";
@@ -186,6 +186,52 @@ function mapStopReason(stopReason) {
       return "other";
   }
 }
+var EPHEMERAL = { type: "ephemeral" };
+function applyAnthropicCacheBreakpoints(params) {
+  if (typeof params.system === "string") {
+    if (params.system.length > 0) {
+      params.system = [{ type: "text", text: params.system, cache_control: EPHEMERAL }];
+    }
+  } else if (Array.isArray(params.system) && params.system.length > 0) {
+    const lastIdx = params.system.length - 1;
+    params.system = params.system.map(
+      (block, i) => i === lastIdx ? { ...block, cache_control: EPHEMERAL } : block
+    );
+  }
+  if (params.tools && params.tools.length > 0) {
+    const lastIdx = params.tools.length - 1;
+    params.tools = params.tools.map(
+      (tool, i) => i === lastIdx ? { ...tool, cache_control: EPHEMERAL } : tool
+    );
+  }
+  if (params.messages.length === 0)
+    return;
+  const lastMsgIdx = params.messages.length - 1;
+  const lastMsg = params.messages[lastMsgIdx];
+  if (typeof lastMsg.content === "string") {
+    if (lastMsg.content.length === 0)
+      return;
+    params.messages[lastMsgIdx] = {
+      ...lastMsg,
+      content: [{ type: "text", text: lastMsg.content, cache_control: EPHEMERAL }]
+    };
+    return;
+  }
+  if (!Array.isArray(lastMsg.content) || lastMsg.content.length === 0)
+    return;
+  const blocks = lastMsg.content;
+  let targetIdx = blocks.length - 1;
+  while (targetIdx >= 0 && isThinkingBlock(blocks[targetIdx]))
+    targetIdx -= 1;
+  if (targetIdx < 0)
+    return;
+  const nextBlocks = blocks.slice();
+  nextBlocks[targetIdx] = { ...nextBlocks[targetIdx], cache_control: EPHEMERAL };
+  params.messages[lastMsgIdx] = { ...lastMsg, content: nextBlocks };
+}
+function isThinkingBlock(block) {
+  return block.type === "thinking" || block.type === "redacted_thinking";
+}
 function looksLikeAnthropicApiError(err) {
   if (!err || typeof err !== "object")
     return false;
@@ -345,6 +391,8 @@ function anthropic(anthropicParams) {
         messages: messages.map((m) => toAnthropic(m)),
         stream: true
       };
+      if (options.cache !== false)
+        applyAnthropicCacheBreakpoints(params);
       if (thinking !== "off") {
         const budgetTokens = options.thinkingBudget ?? THINKING_BUDGETS[thinking];
         params.thinking = {
@@ -698,7 +746,12 @@ function openrouter(params) {
       "HTTP-Referer": "https://github.com/Tahul/zidane",
       "X-Title": "zidane"
     },
-    capabilities: params?.capabilities ?? { vision: true, imageInToolResult: false }
+    capabilities: params?.capabilities ?? { vision: true, imageInToolResult: false },
+    // OpenRouter honors `cache_control` markers for Anthropic + Gemini routes and
+    // silently ignores them for routes that cache automatically. Safe to turn on
+    // by default — the caller can still flip `behavior.cache = false` to opt out
+    // without needing to re-instantiate the provider.
+    cacheBreakpoints: true
   });
 }
 

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import { d as AgentHooks } from './agent-vPBFXnu-.js';
-export { ab as ActivationVia, ac as ActiveSkill, A as Agent, a as AgentAbortedError, b as AgentBehavior, c as AgentContextExceededError, e as AgentOptions, f as AgentProviderError, g as AgentRunOptions, h as AgentStats, i as AgentToolNotAllowedError, j as AnthropicParams, C as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, k as CerebrasParams, m as ClassifiedError, n as ClassifiedErrorKind, o as CreateSessionOptions, ad as DeactivationReason, ae as FileMapAdapter, af as FileMapStoreOptions, I as ImageContent, M as McpConnection, p as McpServerConfig, q as McpToolHookContext, O as OAuthRefreshHookContext, ag as OpenAICompatAuthHeader, ah as OpenAICompatHttpError, ai as OpenAICompatParams, r as OpenAIParams, s as OpenRouterParams, P as PromptDocumentPart, t as PromptImagePart, u as PromptPart, v as PromptTextPart, w as Provider, x as ProviderCapabilities, R as RemoteStoreOptions, y as RunHookMap, S as Session, z as SessionContentBlock, B as SessionData, D as SessionEndStatus, E as SessionHookContext, F as SessionMessage, G as SessionRun, H as SessionStore, J as SessionTurn, aj as SkillActivationState, ak as SkillActivationStateOptions, K as SkillConfig, al as SkillDiagnostic, L as SkillResource, am as SkillSource, N as SkillsConfig, Q as SpawnHookContext, T as StreamCallbacks, U as StreamHookContext, V as StreamOptions, W as ThinkingLevel, X as ToolCall, Y as ToolContext, Z as ToolDef, _ as ToolExecutionMode, $ as ToolHookContext, a0 as ToolMap, a1 as ToolResult, a2 as ToolResultContent, a3 as ToolResultImageContent, a4 as ToolResultTextContent, a5 as ToolSpec, a6 as TurnFinishReason, a7 as TurnResult, a8 as TurnUsage, an as anthropic, ao as autoDetectAndConvert, ap as cerebras, aq as classifyOpenAICompatError, ar as connectMcpServers, as as createAgent, at as createFileMapStore, au as createMemoryStore, av as createRemoteStore, aw as createSession, ax as createSkillActivationState, ay as fromAnthropic, az as fromOpenAI, aA as loadSession, aB as mapOAIFinishReason, a9 as matchesContextExceeded, aC as normalizeMcpBlocks, aD as normalizeMcpServers, aE as openai, aF as openaiCompat, aG as openrouter, aH as resultToString, aI as toAnthropic, aJ as toOpenAI, aK as toTypedError, aa as toolResultToText } from './agent-vPBFXnu-.js';
+import { d as AgentHooks } from './agent-C0hLXofc.js';
+export { ab as ActivationVia, ac as ActiveSkill, A as Agent, a as AgentAbortedError, b as AgentBehavior, c as AgentContextExceededError, e as AgentOptions, f as AgentProviderError, g as AgentRunOptions, h as AgentStats, i as AgentToolNotAllowedError, j as AnthropicParams, C as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, k as CerebrasParams, m as ClassifiedError, n as ClassifiedErrorKind, o as CreateSessionOptions, ad as DeactivationReason, ae as FileMapAdapter, af as FileMapStoreOptions, I as ImageContent, M as McpConnection, p as McpServerConfig, q as McpToolHookContext, O as OAuthRefreshHookContext, ag as OpenAICompatAuthHeader, ah as OpenAICompatHttpError, ai as OpenAICompatParams, r as OpenAIParams, s as OpenRouterParams, P as PromptDocumentPart, t as PromptImagePart, u as PromptPart, v as PromptTextPart, w as Provider, x as ProviderCapabilities, R as RemoteStoreOptions, y as RunHookMap, S as Session, z as SessionContentBlock, B as SessionData, D as SessionEndStatus, E as SessionHookContext, F as SessionMessage, G as SessionRun, H as SessionStore, J as SessionTurn, aj as SkillActivationState, ak as SkillActivationStateOptions, K as SkillConfig, al as SkillDiagnostic, L as SkillResource, am as SkillSource, N as SkillsConfig, Q as SpawnHookContext, T as StreamCallbacks, U as StreamHookContext, V as StreamOptions, W as ThinkingLevel, X as ToolCall, Y as ToolContext, Z as ToolDef, _ as ToolExecutionMode, $ as ToolHookContext, a0 as ToolMap, a1 as ToolResult, a2 as ToolResultContent, a3 as ToolResultImageContent, a4 as ToolResultTextContent, a5 as ToolSpec, a6 as TurnFinishReason, a7 as TurnResult, a8 as TurnUsage, an as anthropic, ao as autoDetectAndConvert, ap as cerebras, aq as classifyOpenAICompatError, ar as connectMcpServers, as as createAgent, at as createFileMapStore, au as createMemoryStore, av as createRemoteStore, aw as createSession, ax as createSkillActivationState, ay as fromAnthropic, az as fromOpenAI, aA as loadSession, aB as mapOAIFinishReason, a9 as matchesContextExceeded, aC as normalizeMcpBlocks, aD as normalizeMcpServers, aE as openai, aF as openaiCompat, aG as openrouter, aH as resultToString, aI as toAnthropic, aJ as toOpenAI, aK as toTypedError, aa as toolResultToText } from './agent-C0hLXofc.js';
 export { createDockerContext, createProcessContext } from './contexts.js';
 export { S as SandboxProvider, c as createSandboxContext } from './sandbox-CW72eLDP.js';
 export { C as ContextCapabilities, a as ContextType, E as ExecResult, b as ExecutionContext, c as ExecutionHandle, S as SpawnConfig } from './types-BpvTmawk.js';
 export { Preset, basic, basicTools, definePreset } from './presets.js';
 export { IMPLICITLY_ALLOWED_SKILL_TOOLS, SkillValidationIssue, SkillValidationResult, SourcedScanPath, buildCatalog, defineSkill, discoverSkills, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, parseAllowedToolPattern, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk } from './skills.js';
-export { S as SkillsReadToolOptions, a as SkillsRunScriptToolOptions, b as SkillsUseToolOptions, c as createSkillsReadTool, d as createSkillsRunScriptTool, e as createSkillsUseTool, g as glob } from './skills-use-39cCsA7_.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-Czx3owjX.js';
+export { S as SkillsReadToolOptions, a as SkillsRunScriptToolOptions, b as SkillsUseToolOptions, c as createSkillsReadTool, d as createSkillsRunScriptTool, e as createSkillsUseTool, g as glob } from './skills-use-CvRJ1Qe3.js';
+export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-CT0ivxxH.js';
 import { Hookable } from 'hookable';
 import '@modelcontextprotocol/sdk/client/index.js';
 

package/dist/index.js

@@ -9,12 +9,12 @@ import {
   cerebras,
   openai,
   openrouter
-} from "./chunk-CDRXC7A7.js";
+} from "./chunk-ZSEMKVHP.js";
 import {
   basicTools,
   basic_default,
   definePreset
-} from "./chunk-SP5NA6WF.js";
+} from "./chunk-MDVZX6GM.js";
 import {
   createAgent,
   createInteractionTool,
@@ -24,7 +24,7 @@ import {
   createSpawnTool,
   glob,
   spawn
-} from "./chunk-F5UBXERT.js";
+} from "./chunk-O2XZLJMG.js";
 import {
   IMPLICITLY_ALLOWED_SKILL_TOOLS,
   buildCatalog,
@@ -53,7 +53,7 @@ import {
   normalizeMcpBlocks,
   normalizeMcpServers,
   resultToString
-} from "./chunk-37GD7NL3.js";
+} from "./chunk-DRAYZZ23.js";
 import {
   createFileMapStore,
   createMemoryStore,
@@ -71,7 +71,7 @@ import {
   openaiCompat,
   toAnthropic,
   toOpenAI
-} from "./chunk-S3FCOMRI.js";
+} from "./chunk-CYWF2U62.js";
 import {
   AgentAbortedError,
   AgentContextExceededError,

package/dist/mcp.d.ts

@@ -1,4 +1,4 @@
 import 'hookable';
-export { M as McpConnection, p as McpServerConfig, ar as connectMcpServers, aC as normalizeMcpBlocks, aD as normalizeMcpServers, aH as resultToString } from './agent-vPBFXnu-.js';
+export { M as McpConnection, p as McpServerConfig, ar as connectMcpServers, aC as normalizeMcpBlocks, aD as normalizeMcpServers, aH as resultToString } from './agent-C0hLXofc.js';
 import '@modelcontextprotocol/sdk/client/index.js';
 import './types-BpvTmawk.js';

package/dist/mcp.js

@@ -3,7 +3,7 @@ import {
   normalizeMcpBlocks,
   normalizeMcpServers,
   resultToString
-} from "./chunk-37GD7NL3.js";
+} from "./chunk-DRAYZZ23.js";
 export {
   connectMcpServers,
   normalizeMcpBlocks,

package/dist/presets.d.ts

@@ -1,4 +1,4 @@
-import { Z as ToolDef, e as AgentOptions } from './agent-vPBFXnu-.js';
+import { Z as ToolDef, e as AgentOptions } from './agent-C0hLXofc.js';
 import 'hookable';
 import './types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';
@@ -24,7 +24,7 @@ declare const _default: Preset;
  * createAgent({ ...basic, provider })
  * ```
  */
-type Preset = Omit<Partial<AgentOptions>, 'provider' | 'execution' | 'session' | '_mcpConnector'>;
+type Preset = Omit<Partial<AgentOptions>, 'provider' | 'execution' | 'session' | 'mcpConnector'>;
 /**
  * Identity helper for type inference when defining a preset.
  */

package/dist/presets.js

@@ -2,11 +2,11 @@ import {
   basicTools,
   basic_default,
   definePreset
-} from "./chunk-SP5NA6WF.js";
-import "./chunk-F5UBXERT.js";
+} from "./chunk-MDVZX6GM.js";
+import "./chunk-O2XZLJMG.js";
 import "./chunk-TPXPVEH6.js";
 import "./chunk-2EQT4EHD.js";
-import "./chunk-37GD7NL3.js";
+import "./chunk-DRAYZZ23.js";
 import "./chunk-LNN5UTS2.js";
 export {
   basic_default as basic,

package/dist/providers.d.ts

@@ -1,4 +1,4 @@
-export { j as AnthropicParams, k as CerebrasParams, ag as OpenAICompatAuthHeader, ah as OpenAICompatHttpError, ai as OpenAICompatParams, r as OpenAIParams, s as OpenRouterParams, w as Provider, x as ProviderCapabilities, T as StreamCallbacks, V as StreamOptions, X as ToolCall, a1 as ToolResult, a5 as ToolSpec, a7 as TurnResult, an as anthropic, ap as cerebras, aq as classifyOpenAICompatError, aB as mapOAIFinishReason, aE as openai, aF as openaiCompat, aG as openrouter } from './agent-vPBFXnu-.js';
+export { j as AnthropicParams, k as CerebrasParams, ag as OpenAICompatAuthHeader, ah as OpenAICompatHttpError, ai as OpenAICompatParams, r as OpenAIParams, s as OpenRouterParams, w as Provider, x as ProviderCapabilities, T as StreamCallbacks, V as StreamOptions, X as ToolCall, a1 as ToolResult, a5 as ToolSpec, a7 as TurnResult, an as anthropic, ap as cerebras, aq as classifyOpenAICompatError, aB as mapOAIFinishReason, aE as openai, aF as openaiCompat, aG as openrouter } from './agent-C0hLXofc.js';
 import 'hookable';
 import './types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';

package/dist/providers.js

@@ -3,13 +3,13 @@ import {
   cerebras,
   openai,
   openrouter
-} from "./chunk-CDRXC7A7.js";
+} from "./chunk-ZSEMKVHP.js";
 import {
   OpenAICompatHttpError,
   classifyOpenAICompatError,
   mapOAIFinishReason,
   openaiCompat
-} from "./chunk-S3FCOMRI.js";
+} from "./chunk-CYWF2U62.js";
 import "./chunk-LNN5UTS2.js";
 export {
   OpenAICompatHttpError,

package/dist/session/sqlite.d.ts

@@ -1,4 +1,4 @@
-import { H as SessionStore } from '../agent-vPBFXnu-.js';
+import { H as SessionStore } from '../agent-C0hLXofc.js';
 import 'hookable';
 import '../types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';

package/dist/session.d.ts

@@ -1,4 +1,4 @@
-export { o as CreateSessionOptions, ae as FileMapAdapter, af as FileMapStoreOptions, R as RemoteStoreOptions, S as Session, z as SessionContentBlock, B as SessionData, F as SessionMessage, G as SessionRun, H as SessionStore, J as SessionTurn, ao as autoDetectAndConvert, at as createFileMapStore, au as createMemoryStore, av as createRemoteStore, aw as createSession, ay as fromAnthropic, az as fromOpenAI, aA as loadSession, aI as toAnthropic, aJ as toOpenAI } from './agent-vPBFXnu-.js';
+export { o as CreateSessionOptions, ae as FileMapAdapter, af as FileMapStoreOptions, R as RemoteStoreOptions, S as Session, z as SessionContentBlock, B as SessionData, F as SessionMessage, G as SessionRun, H as SessionStore, J as SessionTurn, ao as autoDetectAndConvert, at as createFileMapStore, au as createMemoryStore, av as createRemoteStore, aw as createSession, ay as fromAnthropic, az as fromOpenAI, aA as loadSession, aI as toAnthropic, aJ as toOpenAI } from './agent-C0hLXofc.js';
 import 'hookable';
 import './types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';

package/dist/session.js

@@ -11,7 +11,7 @@ import {
   fromOpenAI,
   toAnthropic,
   toOpenAI
-} from "./chunk-S3FCOMRI.js";
+} from "./chunk-CYWF2U62.js";
 import "./chunk-LNN5UTS2.js";
 export {
   autoDetectAndConvert,

package/dist/{skills-use-39cCsA7_.d.ts → skills-use-CvRJ1Qe3.d.ts}

@@ -1,4 +1,4 @@
-import { Z as ToolDef, K as SkillConfig, aj as SkillActivationState, d as AgentHooks } from './agent-vPBFXnu-.js';
+import { Z as ToolDef, K as SkillConfig, aj as SkillActivationState, d as AgentHooks } from './agent-C0hLXofc.js';
 import { Hookable } from 'hookable';
 
 declare const glob: ToolDef;

package/dist/skills.d.ts

@@ -1,5 +1,5 @@
-import { d as AgentHooks, aj as SkillActivationState, K as SkillConfig, am as SkillSource, al as SkillDiagnostic, N as SkillsConfig } from './agent-vPBFXnu-.js';
-export { ab as ActivationVia, ac as ActiveSkill, ad as DeactivationReason, ak as SkillActivationStateOptions, L as SkillResource, ax as createSkillActivationState } from './agent-vPBFXnu-.js';
+import { d as AgentHooks, aj as SkillActivationState, K as SkillConfig, am as SkillSource, al as SkillDiagnostic, N as SkillsConfig } from './agent-C0hLXofc.js';
+export { ab as ActivationVia, ac as ActiveSkill, ad as DeactivationReason, ak as SkillActivationStateOptions, L as SkillResource, ax as createSkillActivationState } from './agent-C0hLXofc.js';
 import { Hookable } from 'hookable';
 import { b as ExecutionContext, c as ExecutionHandle } from './types-BpvTmawk.js';
 import '@modelcontextprotocol/sdk/client/index.js';

package/dist/{spawn-Czx3owjX.d.ts → spawn-CT0ivxxH.d.ts}

@@ -1,4 +1,4 @@
-import { Y as ToolContext, Z as ToolDef, h as AgentStats, l as ChildRunStats } from './agent-vPBFXnu-.js';
+import { Y as ToolContext, Z as ToolDef, h as AgentStats, l as ChildRunStats } from './agent-C0hLXofc.js';
 import { Preset } from './presets.js';
 
 /**

package/dist/tools.d.ts

@@ -1,7 +1,7 @@
-export { S as SkillsReadToolOptions, a as SkillsRunScriptToolOptions, b as SkillsUseToolOptions, c as createSkillsReadTool, d as createSkillsRunScriptTool, e as createSkillsUseTool, g as glob } from './skills-use-39cCsA7_.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-Czx3owjX.js';
-import { Z as ToolDef } from './agent-vPBFXnu-.js';
-export { Y as ToolContext, a0 as ToolMap } from './agent-vPBFXnu-.js';
+export { S as SkillsReadToolOptions, a as SkillsRunScriptToolOptions, b as SkillsUseToolOptions, c as createSkillsReadTool, d as createSkillsRunScriptTool, e as createSkillsUseTool, g as glob } from './skills-use-CvRJ1Qe3.js';
+export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState, c as createInteractionTool, b as createSpawnTool, s as spawn } from './spawn-CT0ivxxH.js';
+import { Z as ToolDef } from './agent-C0hLXofc.js';
+export { Y as ToolContext, a0 as ToolMap } from './agent-C0hLXofc.js';
 export { V as ValidationResult, v as validateToolArgs } from './validation-DOY_k7lW.js';
 import 'hookable';
 import './presets.js';

package/dist/tools.js

@@ -11,10 +11,10 @@ import {
   spawn,
   validateToolArgs,
   writeFile
-} from "./chunk-F5UBXERT.js";
+} from "./chunk-O2XZLJMG.js";
 import "./chunk-TPXPVEH6.js";
 import "./chunk-2EQT4EHD.js";
-import "./chunk-37GD7NL3.js";
+import "./chunk-DRAYZZ23.js";
 import "./chunk-LNN5UTS2.js";
 export {
   createInteractionTool,

package/dist/types.d.ts

@@ -1,8 +1,8 @@
-export { A as Agent, a as AgentAbortedError, b as AgentBehavior, c as AgentContextExceededError, d as AgentHooks, e as AgentOptions, f as AgentProviderError, g as AgentRunOptions, h as AgentStats, i as AgentToolNotAllowedError, j as AnthropicParams, C as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, k as CerebrasParams, l as ChildRunStats, m as ClassifiedError, n as ClassifiedErrorKind, o as CreateSessionOptions, I as ImageContent, M as McpConnection, p as McpServerConfig, q as McpToolHookContext, O as OAuthRefreshHookContext, r as OpenAIParams, s as OpenRouterParams, P as PromptDocumentPart, t as PromptImagePart, u as PromptPart, v as PromptTextPart, w as Provider, x as ProviderCapabilities, R as RemoteStoreOptions, y as RunHookMap, S as Session, z as SessionContentBlock, B as SessionData, D as SessionEndStatus, E as SessionHookContext, F as SessionMessage, G as SessionRun, H as SessionStore, J as SessionTurn, K as SkillConfig, L as SkillResource, N as SkillsConfig, Q as SpawnHookContext, T as StreamCallbacks, U as StreamHookContext, V as StreamOptions, W as ThinkingLevel, X as ToolCall, Y as ToolContext, Z as ToolDef, _ as ToolExecutionMode, $ as ToolHookContext, a0 as ToolMap, a1 as ToolResult, a2 as ToolResultContent, a3 as ToolResultImageContent, a4 as ToolResultTextContent, a5 as ToolSpec, a6 as TurnFinishReason, a7 as TurnResult, a8 as TurnUsage, a9 as matchesContextExceeded, aa as toolResultToText } from './agent-vPBFXnu-.js';
+export { A as Agent, a as AgentAbortedError, b as AgentBehavior, c as AgentContextExceededError, d as AgentHooks, e as AgentOptions, f as AgentProviderError, g as AgentRunOptions, h as AgentStats, i as AgentToolNotAllowedError, j as AnthropicParams, C as CONTEXT_EXCEEDED_MESSAGE_PATTERNS, k as CerebrasParams, l as ChildRunStats, m as ClassifiedError, n as ClassifiedErrorKind, o as CreateSessionOptions, I as ImageContent, M as McpConnection, p as McpServerConfig, q as McpToolHookContext, O as OAuthRefreshHookContext, r as OpenAIParams, s as OpenRouterParams, P as PromptDocumentPart, t as PromptImagePart, u as PromptPart, v as PromptTextPart, w as Provider, x as ProviderCapabilities, R as RemoteStoreOptions, y as RunHookMap, S as Session, z as SessionContentBlock, B as SessionData, D as SessionEndStatus, E as SessionHookContext, F as SessionMessage, G as SessionRun, H as SessionStore, J as SessionTurn, K as SkillConfig, L as SkillResource, N as SkillsConfig, Q as SpawnHookContext, T as StreamCallbacks, U as StreamHookContext, V as StreamOptions, W as ThinkingLevel, X as ToolCall, Y as ToolContext, Z as ToolDef, _ as ToolExecutionMode, $ as ToolHookContext, a0 as ToolMap, a1 as ToolResult, a2 as ToolResultContent, a3 as ToolResultImageContent, a4 as ToolResultTextContent, a5 as ToolSpec, a6 as TurnFinishReason, a7 as TurnResult, a8 as TurnUsage, a9 as matchesContextExceeded, aa as toolResultToText } from './agent-C0hLXofc.js';
 export { C as ContextCapabilities, a as ContextType, E as ExecResult, b as ExecutionContext, c as ExecutionHandle, S as SpawnConfig } from './types-BpvTmawk.js';
 export { S as SandboxProvider } from './sandbox-CW72eLDP.js';
 export { Preset } from './presets.js';
-export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState } from './spawn-Czx3owjX.js';
+export { C as ChildAgent, I as InteractionToolOptions, S as SpawnToolOptions, a as SpawnToolState } from './spawn-CT0ivxxH.js';
 export { V as ValidationResult } from './validation-DOY_k7lW.js';
 import 'hookable';
 import '@modelcontextprotocol/sdk/client/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zidane",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "an agent that goes straight to the goal",
   "type": "module",
   "private": false,