zidane 3.0.2 → 3.1.1

package/README.md

@@ -12,25 +12,17 @@ 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`, `read_file`, `write_file`, `edit`, `multi_edit`, `glob`, `grep`, `spawn`, human-in-the-loop, plus any [MCP](https://modelcontextprotocol.io) server. Sequential or parallel execution, per-call gates, typed hooks. Built-in tools ship with sensible truncation and idempotency defaults so consumers don't have to polyfill them.
-- ✂️ **Token-aware tool ergonomics** — `read_file` line-paginates with a footer that documents how to read the rest, `shell` tail-truncates combined output at 8 KB, `write_file` returns `No change needed` on idempotent writes. `outputBytes` surfaced on every tool/mcp hook.
-- 🧰 **Self-healing tool args** — `validateToolArgs` auto-coerces small/OSS-model mistakes (`"true"` → `true`, `"42"` → `42`, JSON-encoded arrays) before reaching `execute`. `validation:reject` fires only on irrecoverable mismatches.
-- 🪤 **Hallucinated tool names** handled — `tool:unknown` fires before the default error so consumers can substitute a friendly response.
-- 📉 **Per-turn output budget** — `behavior.toolOutputBudget` injects a "summarize before continuing" message when a turn's tool outputs exceed the cap. Off by default.
-- 🧩 **[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** — typed hook events covering turn, stream, tool, MCP, session, skills, spawn, OAuth refresh, bootstrap timing, validation rejection / coercion, and budget overflow.
-- 🧪 **1000+ tests, zero API keys** — mock providers + mock execution contexts; suite runs in under 2 seconds.
+A small, hookable core with sensible defaults so most consumers don't write a single hook. Built around three principles: **token discipline by default** (cache, dedup, compaction, byte-accounting), **self-healing on the fault paths** (auto-coerce args, hallucinated-tool fallback, error rewriting), and **provider parity** (server-side features on Anthropic, client-side equivalents everywhere else).
+
+- 🧠 **Multi-provider, multi-auth** — Anthropic, OpenAI Codex, OpenRouter, Cerebras, plus a generic `openaiCompat` factory (Baseten, Fireworks, Groq, local servers). OAuth + API key, auto-refreshing tokens. Anthropic accepts opt-in `extraBetas` and `contextManagement` for first-party features.
+- 🪝 **Streaming, hookable turn loop** — text/thinking deltas, tool calls, MCP, sessions, skills, spawn, OAuth, validation, budgets — all observable (and most mutatable) via typed hook events.
+- 🛠 **Tools first-class** — `shell`, `read_file`, `write_file`, `edit`, `multi_edit`, `glob`, `grep`, `spawn`, human-in-the-loop, plus any [MCP](https://modelcontextprotocol.io) server. Sequential or parallel, per-call gates (`tool:gate`), validation auto-coerce (`"true"` → `true`), hallucinated-tool fallback (`tool:unknown`), error rewriting (`tool:error` → `result`).
+- ✂️ **Token-aware ergonomics** — paginated reads with a "how to page" footer, 8 KB tail-truncated `shell`, idempotent `write_file`; `outputBytes` surfaced on every tool/MCP hook. `behavior.toolOutputBudget` injects a "summarize" nudge when a turn's outputs exceed the cap.
+- 🗜 **Context discipline** — auto-injected `cache_control` breakpoints (Anthropic + OpenRouter); server-side compaction via `context-management-2025-06-27` on Anthropic, `behavior.compactStrategy: 'tail'` on everyone else. Per-session `read_file` dedup + opt-in `requireReadBeforeEdit` guard kill stale-content edits.
+- 🎯 **Reasoning + structured output** — thinking levels (`off` / `minimal` / `low` / `medium` / `high` / `adaptive`) with optional exact budgets; force the final answer to a JSON Schema (Zod v4 interop), no brittle parsing.
+- 💾 **Sessions, skills, multimodal** — pluggable session stores (memory / SQLite / remote / file-map), incremental persistence; [Agent Skills](https://agentskills.io/specification) spec-aligned with `allowed-tools` enforcement + resume rehydration; images + documents via `PromptPart[]`, tools can return image blocks routed natively on vision providers or via companion messages elsewhere.
+- 🧵 **Sub-agents + execution contexts** — delegate to child agents with inherited or overridden preset (child events bubble to the parent); run tools in-process, Docker, or any `SandboxProvider` (E2B / Rivet / custom). Parallel MCP bootstrap with `agent.warmup()` + `eager: true` to hide cold starts.
+- 🧭 **Typed errors + 1000+ tests** — `AgentContextExceededError` / `AgentProviderError` / `AgentAbortedError` instead of sniffing strings. Suite runs in under 2s with mock providers + mock execution contexts, zero API keys.
 
 > Upgrading from 2.x? See [`docs/migrate-from-v2.md`](./docs/migrate-from-v2.md) for the full list of behavior changes.
 
@@ -77,6 +69,11 @@ createAgent({
     thinkingBudget: 10240,           // exact thinking token budget
     cache: true,                     // prompt-cache breakpoints on supported providers (default: true)
     toolOutputBudget: 32768,         // soft per-turn cap on tool-output bytes (off by default)
+    dedupReads: true,                // dedup identical re-reads of the same file in `read_file` (default: true)
+    requireReadBeforeEdit: false,    // refuse `edit` / `multi_edit` against unread or stale files (default: false)
+    compactStrategy: 'off',          // client-side tail compaction for non-Anthropic providers — 'off' | 'tail' (default: 'off')
+    compactThreshold: 131_072,       // bytes threshold that triggers tail compaction (default: 128 KiB)
+    compactKeepTurns: 4,             // trailing turns left intact during compaction (default: 4)
   },
   execution: createProcessContext(), // where tools run
   mcpServers: [],                    // MCP tool servers
@@ -141,10 +138,30 @@ anthropic({ apiKey: 'sk-ant-...' })
 anthropic({ access: 'sk-ant-oat-...' })                      // OAuth
 anthropic({ access: 'sk-ant-oat-...', refresh: '...', expires: Date.now() + 3600_000 }) // auto-refresh
 anthropic({ apiKey: '...', defaultModel: 'claude-sonnet-4-6' })
+
+// Opt into first-party Anthropic betas + server-side context compaction:
+anthropic({
+  apiKey: '...',
+  extraBetas: [
+    'context-management-2025-06-27',     // server-side, token-accurate compaction
+    'token-efficient-tools-2026-03-28',  // ~4.5% output token reduction
+    'interleaved-thinking-2025-05-14',   // think between tool calls in one turn
+  ],
+  contextManagement: {
+    edits: [{
+      type: 'clear_tool_uses_20250919',
+      trigger: { type: 'input_tokens', value: 180_000 },
+      clear_at_least: { type: 'input_tokens', value: 140_000 },
+      clear_tool_inputs: ['Read', 'Bash', 'Grep', 'Glob'],
+    }],
+  },
+})
 ```
 
 Fallback: `params.apiKey` > `params.access` > `ANTHROPIC_API_KEY` env > `.credentials.json`
 
+`extraBetas` are merged with the OAuth defaults (`claude-code-20250219`, `oauth-2025-04-20`) and de-duped. `contextManagement` is sent on the request body as `context_management`; pair it with the `context-management-2025-06-27` beta. For non-Anthropic providers, see `behavior.compactStrategy: 'tail'` for the client-side fallback.
+
 ### OpenRouter
 
 ```ts
@@ -270,6 +287,7 @@ Extended reasoning with named levels or exact token budgets.
 | `low` | 4,096 tokens |
 | `medium` | 10,240 tokens |
 | `high` | 32,768 tokens |
+| `adaptive` | model self-budgets per turn |
 
 ```ts
 // Named level
@@ -278,12 +296,18 @@ await agent.run({ prompt: 'solve this', thinking: 'high' })
 // Exact budget (overrides level default)
 await agent.run({ prompt: 'solve this', thinking: 'high', behavior: { thinkingBudget: 50000 } })
 
+// Adaptive — model self-budgets, but `thinkingBudget` caps the response envelope
+// (max_tokens) to soft-bound runaway thinking on Anthropic.
+await agent.run({ prompt: 'solve this', thinking: 'adaptive', behavior: { thinkingBudget: 32000 } })
+
 // Agent-level default
 const agent = createAgent({ ...basic, provider, behavior: { thinkingBudget: 16384 } })
 ```
 
 Thinking traces are stored in session turns as `{ type: 'thinking', text }` content blocks and streamed live via the `stream:thinking` hook. Supported by Anthropic (native) and OpenRouter/Cerebras (`reasoning_content`/`reasoning` SSE fields).
 
+`adaptive` is Anthropic-specific (`thinking.type='adaptive'`) and avoids the `thinking.type='enabled'` deprecation warning on opus 4.6+. It has no native budget knob — when `thinkingBudget` is paired with `adaptive`, zidane caps `max_tokens = min(maxTokens, thinkingBudget)` so unbounded reasoning can't run away. Other providers fall back to no reasoning when `adaptive` is selected.
+
 ## Hooks
 
 Every hook receives a mutable context object.
@@ -352,7 +376,11 @@ agent.hooks.hook('tool:gate', (ctx) => {
 
 agent.hooks.hook('tool:before', (ctx) => { /* ctx.turnId, ctx.callId, ctx.name, ctx.input, ctx.coercions? */ })
 agent.hooks.hook('tool:after', (ctx) => { /* + ctx.result, ctx.outputBytes, ctx.coercions? */ })
-agent.hooks.hook('tool:error', (ctx) => { /* + ctx.error */ })
+agent.hooks.hook('tool:error', (ctx) => {
+  // + ctx.error. Mutate ctx.result to substitute the payload sent back to the
+  // model in place of the default `Tool error: <msg>` — useful for OSS-model
+  // error rewriting (collapse stack traces, prepend recovery hints).
+})
 agent.hooks.hook('tool:transform', (ctx) => {
   // + ctx.result, ctx.isError, ctx.outputBytes (pre-mutation), ctx.coercions? — mutate result/isError to modify.
   // Built-in tools already truncate; use this hook for consumer concerns the framework can't infer,
@@ -458,6 +486,30 @@ agent.hooks.hook('budget:exceeded', (ctx) => {
 })
 ```
 
+### Client-side context compaction (non-Anthropic)
+
+For non-Anthropic providers (cerebras / openai-compat / openrouter on OSS models), `behavior.compactStrategy: 'tail'` elides older `tool_result` blocks from the wire-level message list once their combined size exceeds `compactThreshold`. The newest `compactKeepTurns` messages stay intact so the model retains the freshest tool context.
+
+```ts
+const agent = createAgent({
+  ...basic,
+  provider: cerebras({ apiKey: '...' }),
+  behavior: {
+    compactStrategy: 'tail',
+    compactThreshold: 131_072,  // 128 KiB; default
+    compactKeepTurns: 4,        // default
+  },
+})
+```
+
+Anthropic users should prefer the server-side `context-management-2025-06-27` beta (token-accurate, configured via `anthropic({ extraBetas, contextManagement })`) — `'tail'` is a client-side approximation that exists because OSS-model providers have no server-side equivalent.
+
+### Read dedup + read-before-edit guard
+
+`behavior.dedupReads` (on by default) — `read_file` returns a short `"unchanged since the previous read"` stub instead of re-emitting bytes when the model re-reads the same file with the same slice. Per-session content-hash; requires a session.
+
+`behavior.requireReadBeforeEdit` (off by default) — `edit` and `multi_edit` reject when the file hasn't been read in the session, or when its on-disk content has drifted since the last read. Eliminates the silent-corruption case where a model edits against bytes it "remembers" but no longer reflect reality. Recommended on for stricter eval-grade runs.
+
 ## Steering and Follow-up
 
 ### Steering

package/dist/{agent-4zeSbdXy.d.ts → agent-Cq009tbG.d.ts}

@@ -1,5 +1,5 @@
 import { Hookable } from 'hookable';
-import { b as ExecutionContext, c as ExecutionHandle } from './types-BpvTmawk.js';
+import { b as ExecutionContext, c as ExecutionHandle } from './types-vA1a_ZX7.js';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 
 /**
@@ -216,6 +216,62 @@ interface AgentBehavior {
      * starting value for OSS-model integrations is `32768`.
      */
     toolOutputBudget?: number;
+    /**
+     * Deduplicate identical re-reads of the same file in `read_file`. When the
+     * model re-reads a file with the same slice and the bytes haven't changed
+     * since the last read in this session, the tool returns a short stub
+     * instead of re-emitting the full content. Pairs with the read-before-edit
+     * guard in `edit` / `multi_edit`.
+     *
+     * Requires a session (set via `createSession()`); without one, the flag is
+     * a no-op since per-session state has nowhere to live.
+     *
+     * Default: `true`.
+     */
+    dedupReads?: boolean;
+    /**
+     * Require `read_file` before `edit` / `multi_edit` on the same path, and
+     * reject edits when the file has changed on disk since the last read in
+     * this session. Eliminates the silent-corruption failure mode where a
+     * model "remembers" stale content and applies a substring edit against
+     * bytes that have moved.
+     *
+     * Requires a session. Off by default to preserve back-compat — turn it on
+     * for stricter eval-grade runs.
+     *
+     * Default: `false`.
+     */
+    requireReadBeforeEdit?: boolean;
+    /**
+     * Client-side context compaction strategy. Use this for non-Anthropic
+     * providers (OSS via cerebras / openai-compat / openrouter) that don't
+     * have a server-side equivalent. Anthropic users should prefer the
+     * server-side `context-management-2025-06-27` beta — see
+     * `AnthropicParams.contextManagement`.
+     *
+     * - `'off'` (default) — no client-side compaction.
+     * - `'tail'` — when total tool-output bytes in the persisted history
+     *   exceed `compactThreshold`, replace older `tool_result` outputs with a
+     *   short stub, keeping the newest `compactKeepTurns` turns intact. The
+     *   compaction is applied to the wire-level message list only; the
+     *   underlying session turns are not modified.
+     *
+     * Default: `'off'`.
+     */
+    compactStrategy?: 'off' | 'tail';
+    /**
+     * Soft byte threshold that triggers tail compaction when
+     * `compactStrategy === 'tail'`. Counts the post-`context:transform` bytes
+     * of `tool_result` outputs across all messages. Default: `131_072` (128
+     * KiB). Ignored when compaction is off.
+     */
+    compactThreshold?: number;
+    /**
+     * Number of trailing turns to leave untouched during tail compaction. The
+     * most-recent `compactKeepTurns` user/assistant messages are not eligible
+     * for elision so the model keeps the freshest tool context. Default: `4`.
+     */
+    compactKeepTurns?: number;
 }
 interface ImageContent {
     type: 'image';
@@ -395,8 +451,24 @@ interface AgentRunOptions {
      */
     depth?: number;
 }
-/** Reason the provider gave for stopping the turn */
-type TurnFinishReason = 'stop' | 'tool-calls' | 'length' | 'content-filter' | 'error' | 'other';
+/**
+ * Reason the provider gave for stopping the turn.
+ *
+ * - `'stop'` — natural turn end (`end_turn` / `stop_sequence`).
+ * - `'tool-calls'` — model emitted tool_use blocks.
+ * - `'length'` — `max_tokens` reached, or (Anthropic 4.6+) the response bumped
+ *   against the model's context window mid-stream
+ *   (`model_context_window_exceeded`). The partial response is preserved; the
+ *   loop emits this reason so consumers can prune/retry.
+ * - `'content-filter'` — model refused.
+ * - `'pause'` — Anthropic `pause_turn`: a server-side mid-turn pause for very
+ *   long thinking. The loop continues with a synthetic "Please continue."
+ *   user message rather than terminating; consumers see the pause via this
+ *   finish reason on the prior assistant turn.
+ * - `'error'` — provider classified the turn as failed.
+ * - `'other'` — unknown / unmapped.
+ */
+type TurnFinishReason = 'stop' | 'tool-calls' | 'length' | 'content-filter' | 'pause' | 'error' | 'other';
 interface TurnUsage {
     input: number;
     output: number;
@@ -541,6 +613,18 @@ interface OAuthRefreshHookContext {
 }
 type SessionEndStatus = 'completed' | 'aborted' | 'error';
 
+/**
+ * Server-side context-management config — the body of `context_management` on
+ * the Messages API. Typed loosely (Record-of-unknown) so we don't pin a specific
+ * SDK schema version: the v0.90 SDK does not yet type this field, but the wire
+ * format is stable behind the `context-management-2025-06-27` beta.
+ *
+ * See: https://docs.anthropic.com/en/docs/build-with-claude/context-management
+ */
+interface AnthropicContextManagement {
+    edits?: Array<Record<string, unknown>>;
+    [key: string]: unknown;
+}
 interface AnthropicParams {
     apiKey?: string;
     access?: string;
@@ -553,6 +637,43 @@ interface AnthropicParams {
      * gateways, internal router).
      */
     baseURL?: string;
+    /**
+     * Additional `anthropic-beta` flags to opt into. Merged with the OAuth-path
+     * defaults (`claude-code-20250219`, `oauth-2025-04-20`); duplicates are
+     * de-duped. Examples:
+     *
+     * - `'context-management-2025-06-27'` — server-side context compaction
+     *   (token-accurate; pair with {@link AnthropicParams.contextManagement}).
+     * - `'token-efficient-tools-2026-03-28'` — terser tool_use wire format.
+     * - `'interleaved-thinking-2025-05-14'` — think between tool calls within
+     *   one turn.
+     * - `'redact-thinking-2026-02-12'` — replace large thinking blocks with
+     *   stubs server-side.
+     * - `'prompt-caching-scope-2026-01-05'` — extended prompt-cache scope.
+     *
+     * Honored on both the OAuth and API-key paths.
+     */
+    extraBetas?: readonly string[];
+    /**
+     * Server-side context-management directive. Sent on the request body as
+     * `context_management`. Requires the `context-management-2025-06-27` beta —
+     * add it to {@link AnthropicParams.extraBetas}.
+     *
+     * Typed loosely so future Anthropic schema additions land without an SDK
+     * bump. A typical compaction edit:
+     *
+     * ```ts
+     * contextManagement: {
+     *   edits: [{
+     *     type: 'clear_tool_uses_20250919',
+     *     trigger: { type: 'input_tokens', value: 180_000 },
+     *     clear_at_least: { type: 'input_tokens', value: 140_000 },
+     *     clear_tool_inputs: ['Read', 'Bash', 'Grep'],
+     *   }],
+     * }
+     * ```
+     */
+    contextManagement?: AnthropicContextManagement;
 }
 declare function anthropic(anthropicParams?: AnthropicParams): Provider;
 
@@ -1466,8 +1587,18 @@ interface AgentHooks {
         outputBytes: number;
         coercions?: readonly string[];
     }) => void;
+    /**
+     * Fires when a tool throws during execution. Mutate `result` to substitute a
+     * tool-output payload that gets sent back to the model in place of the
+     * default `Tool error: <msg>` string — useful for OSS-model error rewriting
+     * (collapse stack traces, hide internal paths, prepend recovery hints).
+     *
+     * The post-hook value flows through `tool:transform` like a normal output, so
+     * downstream byte-budgeting and image-stripping still apply.
+     */
     'tool:error': (ctx: ToolHookContext & {
         error: Error;
+        result?: string | ToolResultContent[];
     }) => void;
     'tool:transform': (ctx: ToolHookContext & {
         result: string | ToolResultContent[];

package/dist/{chunk-D45PXTY2.js → chunk-3DUWP7YU.js}

@@ -132,6 +132,28 @@ async function loadAnthropicSdk() {
     );
   }
 }
+var OAUTH_DEFAULT_BETAS = ["claude-code-20250219", "oauth-2025-04-20"];
+function resolveAnthropicBetas(isOAuth, extraBetas) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  if (isOAuth) {
+    for (const b of OAUTH_DEFAULT_BETAS) {
+      if (!seen.has(b)) {
+        seen.add(b);
+        out.push(b);
+      }
+    }
+  }
+  if (extraBetas) {
+    for (const b of extraBetas) {
+      if (typeof b === "string" && b.length > 0 && !seen.has(b)) {
+        seen.add(b);
+        out.push(b);
+      }
+    }
+  }
+  return out.length > 0 ? out.join(",") : void 0;
+}
 function getConfiguredApiKey(anthropicParams) {
   if (anthropicParams?.apiKey)
     return anthropicParams.apiKey;
@@ -144,22 +166,31 @@ function getConfiguredApiKey(anthropicParams) {
     return access;
   throw new Error("No API key found. Run `bun run auth` first.");
 }
-function createClient(SDK, apiKey, isOAuth, baseURL) {
+function createClient(SDK, apiKey, isOAuth, baseURL, extraBetas) {
   const base = baseURL ? { baseURL } : {};
-  return new SDK(
-    isOAuth ? {
+  const betaHeader = resolveAnthropicBetas(isOAuth, extraBetas);
+  if (isOAuth) {
+    const defaultHeaders2 = {
+      "anthropic-dangerous-direct-browser-access": "true",
+      "user-agent": "zidane/2.0.0",
+      "x-app": "cli"
+    };
+    if (betaHeader)
+      defaultHeaders2["anthropic-beta"] = betaHeader;
+    return new SDK({
       apiKey: null,
       authToken: apiKey,
       dangerouslyAllowBrowser: true,
-      defaultHeaders: {
-        "anthropic-beta": "claude-code-20250219,oauth-2025-04-20",
-        "anthropic-dangerous-direct-browser-access": "true",
-        "user-agent": "zidane/2.0.0",
-        "x-app": "cli"
-      },
+      defaultHeaders: defaultHeaders2,
       ...base
-    } : { apiKey, ...base }
-  );
+    });
+  }
+  const defaultHeaders = betaHeader ? { "anthropic-beta": betaHeader } : void 0;
+  return new SDK({
+    apiKey,
+    ...defaultHeaders ? { defaultHeaders } : {},
+    ...base
+  });
 }
 var EFFORT_FOR_LEVEL = {
   minimal: "low",
@@ -170,8 +201,11 @@ var EFFORT_FOR_LEVEL = {
 function planAnthropicThinking(level, customBudget) {
   if (level === "off")
     return null;
-  if (level === "adaptive")
+  if (level === "adaptive") {
+    if (typeof customBudget === "number" && customBudget > 0)
+      return { kind: "adaptive", maxTokensCap: customBudget };
     return { kind: "adaptive" };
+  }
   if (customBudget !== void 0) {
     return { kind: "enabled", budgetTokens: customBudget, maxTokensBump: customBudget };
   }
@@ -187,11 +221,14 @@ function mapStopReason(stopReason) {
     case "tool_use":
       return "tool-calls";
     case "max_tokens":
+    case "model_context_window_exceeded":
       return "length";
     case "refusal":
       return "content-filter";
+    // 4.6+: server-side mid-turn pause for long thinking. The loop
+    // continues with a synthetic continue message rather than terminating.
     case "pause_turn":
-      return "other";
+      return "pause";
     default:
       return "other";
   }
@@ -384,7 +421,13 @@ function anthropic(anthropicParams) {
           }
         }
       );
-      const client = createClient(SDK, apiKey, apiKey.includes("sk-ant-oat"), anthropicParams?.baseURL);
+      const client = createClient(
+        SDK,
+        apiKey,
+        apiKey.includes("sk-ant-oat"),
+        anthropicParams?.baseURL,
+        anthropicParams?.extraBetas
+      );
       const system = isOAuth ? `You are Claude Code, Anthropic's official CLI for Claude.` : options.system;
       const messages = isOAuth && options.system ? [
         { role: "user", content: [{ type: "text", text: options.system }] },
@@ -401,6 +444,10 @@ function anthropic(anthropicParams) {
         messages: messages.map((m) => toAnthropic(m)),
         stream: true
       };
+      if (anthropicParams?.contextManagement) {
+        ;
+        params.context_management = anthropicParams.contextManagement;
+      }
       if (options.cache !== false)
         applyAnthropicCacheBreakpoints(params);
       const plan = planAnthropicThinking(thinking, options.thinkingBudget);
@@ -412,6 +459,8 @@ function anthropic(anthropicParams) {
           params.thinking = { type: "adaptive" };
           if (plan.effort)
             params.output_config = { effort: plan.effort };
+          if (typeof plan.maxTokensCap === "number" && plan.maxTokensCap > 0)
+            params.max_tokens = Math.min(params.max_tokens, plan.maxTokensCap);
         }
         params.temperature = 1;
       }
@@ -439,11 +488,12 @@ function anthropic(anthropicParams) {
       const response = await s.finalMessage();
       const toolCalls = response.content.filter((b) => b.type === "tool_use").map((b) => ({ id: b.id, name: b.name, input: b.input }));
       const finishReason = mapStopReason(response.stop_reason);
+      const isPause = response.stop_reason === "pause_turn";
       return {
         assistantMessage: fromAnthropic({ role: "assistant", content: response.content }),
         text,
         toolCalls,
-        done: response.stop_reason === "end_turn" || toolCalls.length === 0,
+        done: !isPause && (response.stop_reason === "end_turn" || toolCalls.length === 0),
         usage: {
           input: response.usage.input_tokens,
           output: response.usage.output_tokens,

package/dist/{chunk-2VM47IBI.js → chunk-ATMVSCGJ.js}

@@ -6,7 +6,7 @@ import {
   shell,
   spawn,
   writeFile
-} from "./chunk-QFHGWKK3.js";
+} from "./chunk-EBSFBIP3.js";
 
 // src/presets/basic.ts
 var basicTools = { shell, readFile, writeFile, listFiles, edit, multiEdit };