zidane 5.13.26 → 5.14.1

package/dist/prompt.js

@@ -0,0 +1,210 @@
+//#region src/system-prompt.ts
+/**
+* System-prompt boundary marker — splits a system prompt into a stable static
+* prefix (cached) and a per-turn dynamic suffix (NOT cached).
+*
+* Why this exists: providers attach `cache_control` markers on the last block
+* of the system prompt, so the cached prefix covers the entire system text.
+* Any byte change anywhere — including a per-turn `<env>` rewrite — busts the
+* cache for the doctrine that sits below. A literal marker in the system
+* string lets providers split it into:
+*
+*   ┌──────────────┐ cache_control: ephemeral
+*   │ STATIC half  │  — doctrine, skills catalog, tool catalog,
+*   │              │    user instructions
+*   ├──────────────┤  ← SYSTEM_PROMPT_BOUNDARY
+*   │ DYNAMIC half │  — env, cwd, mtimes, anything per-turn
+*   └──────────────┘ (no cache_control)
+*
+* The static prefix rides the prompt cache across turns/sessions; the dynamic
+* suffix re-bills per turn. Net effect: a cwd change between turns no longer
+* invalidates 4 KB of doctrine.
+*
+* Wire contract:
+*
+* - `splitSystemPrompt(s)` is pure; missing marker ⇒ entire string is static
+*   (current behavior — no caller is forced to opt in).
+* - `renderSystemForWire(s)` strips the marker so it never reaches the model;
+*   used by every provider before the bytes hit the wire, including the
+*   cache-disabled path on providers that DO support `cache_control`.
+* - The marker uses underscores rather than XML/punctuation so it's
+*   unambiguous when scanning prompts manually and unlikely to collide with
+*   model-written content.
+* - Providers handle the split internally (Anthropic emits a 2-block array;
+*   OpenAI-compat splits the leading `system` message into multi-part text).
+*   Callers always pass a single `string` — no API break.
+*/
+/**
+* Literal marker inserted in a system prompt to separate cacheable doctrine
+* from per-turn dynamic content. Providers split on this token.
+*
+* Underscored on both sides for visual distinctiveness — a stray instance in
+* model-written prose is implausible. Don't change the value without shipping
+* a migration; existing sessions carry the old marker in their cached
+* prompts.
+*/
+const SYSTEM_PROMPT_BOUNDARY = "__ZIDANE_SYSTEM_PROMPT_BOUNDARY__";
+/**
+* Split a system prompt around the first {@link SYSTEM_PROMPT_BOUNDARY}.
+*
+* Splits on the FIRST occurrence — subsequent markers are folded into the
+* dynamic half. This way callers can append additional `<env>` style blocks
+* with extra markers without each one creating a new cache layer (Anthropic
+* caps breakpoints; we use the budget elsewhere). The marker itself is
+* stripped from both sides — providers attach `cache_control` directly to
+* the static half's text content.
+*
+* A single blank line (`\n\n`) immediately adjacent to the marker on each
+* side is trimmed — callers conventionally write
+* `<doctrine>\n\n<MARKER>\n\n<env>` and expect the rendered wire bytes to
+* read as one logical paragraph. Blank lines beyond that immediate pair
+* (e.g. `\n\n\n<env>`) are preserved verbatim so callers composing their
+* own spacing don't lose intentional gaps.
+*
+* Pure / no I/O / no allocation when the marker is absent (returns the input
+* verbatim on the static side and the empty string on the dynamic side).
+*/
+function splitSystemPrompt(system) {
+	if (system.length === 0) return {
+		static: "",
+		dynamic: ""
+	};
+	const idx = system.indexOf(SYSTEM_PROMPT_BOUNDARY);
+	if (idx < 0) return {
+		static: system,
+		dynamic: ""
+	};
+	const staticPart = system.slice(0, idx);
+	const dynamicPart = system.slice(idx + 33);
+	return {
+		static: trimTrailingBlankLine(staticPart),
+		dynamic: trimLeadingBlankLine(dynamicPart)
+	};
+}
+/**
+* Compose a system prompt from a static prefix and an optional dynamic
+* suffix. Inserts {@link SYSTEM_PROMPT_BOUNDARY} between them only when the
+* dynamic side is non-empty — single-block prompts stay marker-free, so
+* callers that never opt in pay zero overhead and providers fall back to the
+* existing whole-string caching path.
+*
+* Spacing is `\n\n` on both sides of the marker so doctrine fragments,
+* which conventionally separate sections with a blank line, read cleanly
+* around the boundary.
+*/
+function joinSystemPrompt(staticPart, dynamicPart) {
+	if (dynamicPart.length === 0) return staticPart;
+	if (staticPart.length === 0) return `${SYSTEM_PROMPT_BOUNDARY}\n\n${dynamicPart}`;
+	return `${staticPart}\n\n${SYSTEM_PROMPT_BOUNDARY}\n\n${dynamicPart}`;
+}
+/**
+* Append `extra` to the STATIC half of a system prompt, preserving any
+* existing dynamic suffix.
+*
+* Used by the agent to fold in run-stable content (skills catalog, lazy tool
+* catalog) without bumping it into the dynamic half — both catalogs are
+* built once per run and remain byte-stable for the duration, so they
+* belong in the cached prefix.
+*
+* Returns a new string; the input is not mutated. When `extra` is empty,
+* returns the input verbatim.
+*/
+function appendStaticSection(system, extra) {
+	if (extra.length === 0) return system;
+	const { static: staticPart, dynamic } = splitSystemPrompt(system);
+	return joinSystemPrompt(staticPart.length === 0 ? extra : `${staticPart}\n\n${extra}`, dynamic);
+}
+/**
+* Append `extra` to the DYNAMIC half of a system prompt. Inserts the boundary
+* marker if the input didn't already carry one.
+*
+* Used by hosts (typically the TUI) to inject per-turn state — current cwd,
+* IDE selection, project root — without forcing every caller to know the
+* marker format. The host's `system:transform` hook rewrites the dynamic
+* half each turn; the static doctrine above stays byte-stable and rides the
+* cache.
+*
+* Returns a new string; the input is not mutated. When `extra` is empty,
+* returns the input verbatim.
+*/
+function appendDynamicSection(system, extra) {
+	if (extra.length === 0) return system;
+	const { static: staticPart, dynamic } = splitSystemPrompt(system);
+	return joinSystemPrompt(staticPart, dynamic.length === 0 ? extra : `${dynamic}\n\n${extra}`);
+}
+/**
+* Replace the entire dynamic half of a system prompt with `next`. Used by
+* the TUI's `<env>` rewriter where the entire dynamic section is regenerated
+* each turn rather than appended to.
+*
+* When `next` is empty, drops the dynamic half (and the marker) entirely.
+*/
+function replaceDynamicSection(system, next) {
+	const { static: staticPart } = splitSystemPrompt(system);
+	return joinSystemPrompt(staticPart, next);
+}
+/**
+* Strip the boundary marker so it never reaches the wire — collapses
+* `<static>${BOUNDARY}<dynamic>` into `<static>\n\n<dynamic>` for providers
+* that can't honor `cache_control` (vanilla OpenAI Chat Completions, Codex,
+* Cerebras, ...) or for the cache-disabled path on any provider.
+*
+* Cache-aware providers re-derive the split from the original (un-rendered)
+* system string via `splitSystemPrompt` — `renderSystemForWire` is the
+* marker-free counterpart used to build the actual wire bytes.
+*
+* No-op when the input has no marker. Pure / no I/O.
+*/
+function renderSystemForWire(system) {
+	if (system.length === 0) return system;
+	const parts = splitSystemPrompt(system);
+	if (parts.dynamic.length === 0) return parts.static;
+	if (parts.static.length === 0) return parts.dynamic;
+	return `${parts.static}\n\n${parts.dynamic}`;
+}
+/** True when `system` contains the boundary marker. */
+function hasSystemPromptBoundary(system) {
+	return system.includes(SYSTEM_PROMPT_BOUNDARY);
+}
+/** Strip a single trailing `\n\n` (and any leftover trailing whitespace within that pair). */
+function trimTrailingBlankLine(s) {
+	let end = s.length;
+	let newlines = 0;
+	while (end > 0 && newlines < 2) {
+		const ch = s.charCodeAt(end - 1);
+		if (ch === 10) {
+			newlines += 1;
+			end -= 1;
+			continue;
+		}
+		if (ch === 32 || ch === 9) {
+			end -= 1;
+			continue;
+		}
+		break;
+	}
+	return newlines > 0 ? s.slice(0, end) : s;
+}
+/** Strip a single leading `\n\n` (and any leftover leading whitespace within that pair). */
+function trimLeadingBlankLine(s) {
+	let start = 0;
+	let newlines = 0;
+	while (start < s.length && newlines < 2) {
+		const ch = s.charCodeAt(start);
+		if (ch === 10) {
+			newlines += 1;
+			start += 1;
+			continue;
+		}
+		if (ch === 32 || ch === 9) {
+			start += 1;
+			continue;
+		}
+		break;
+	}
+	return newlines > 0 ? s.slice(start) : s;
+}
+//#endregion
+export { SYSTEM_PROMPT_BOUNDARY, appendDynamicSection, appendStaticSection, hasSystemPromptBoundary, joinSystemPrompt, renderSystemForWire, replaceDynamicSection, splitSystemPrompt };
+
+//# sourceMappingURL=prompt.js.map

package/dist/prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.js","names":[],"sources":["../src/system-prompt.ts"],"sourcesContent":["/**\n * System-prompt boundary marker — splits a system prompt into a stable static\n * prefix (cached) and a per-turn dynamic suffix (NOT cached).\n *\n * Why this exists: providers attach `cache_control` markers on the last block\n * of the system prompt, so the cached prefix covers the entire system text.\n * Any byte change anywhere — including a per-turn `<env>` rewrite — busts the\n * cache for the doctrine that sits below. A literal marker in the system\n * string lets providers split it into:\n *\n *   ┌──────────────┐ cache_control: ephemeral\n *   │ STATIC half  │  — doctrine, skills catalog, tool catalog,\n *   │              │    user instructions\n *   ├──────────────┤  ← SYSTEM_PROMPT_BOUNDARY\n *   │ DYNAMIC half │  — env, cwd, mtimes, anything per-turn\n *   └──────────────┘ (no cache_control)\n *\n * The static prefix rides the prompt cache across turns/sessions; the dynamic\n * suffix re-bills per turn. Net effect: a cwd change between turns no longer\n * invalidates 4 KB of doctrine.\n *\n * Wire contract:\n *\n * - `splitSystemPrompt(s)` is pure; missing marker ⇒ entire string is static\n *   (current behavior — no caller is forced to opt in).\n * - `renderSystemForWire(s)` strips the marker so it never reaches the model;\n *   used by every provider before the bytes hit the wire, including the\n *   cache-disabled path on providers that DO support `cache_control`.\n * - The marker uses underscores rather than XML/punctuation so it's\n *   unambiguous when scanning prompts manually and unlikely to collide with\n *   model-written content.\n * - Providers handle the split internally (Anthropic emits a 2-block array;\n *   OpenAI-compat splits the leading `system` message into multi-part text).\n *   Callers always pass a single `string` — no API break.\n */\n\n/**\n * Literal marker inserted in a system prompt to separate cacheable doctrine\n * from per-turn dynamic content. Providers split on this token.\n *\n * Underscored on both sides for visual distinctiveness — a stray instance in\n * model-written prose is implausible. Don't change the value without shipping\n * a migration; existing sessions carry the old marker in their cached\n * prompts.\n */\nexport const SYSTEM_PROMPT_BOUNDARY = '__ZIDANE_SYSTEM_PROMPT_BOUNDARY__'\n\n/** Result of {@link splitSystemPrompt} — both halves stripped of the marker. */\nexport interface SystemPromptParts {\n  /** Bytes BEFORE the marker (or the entire string when no marker present). Cacheable. */\n  static: string\n  /** Bytes AFTER the marker. Empty when no marker present. NOT cached. */\n  dynamic: string\n}\n\n/**\n * Split a system prompt around the first {@link SYSTEM_PROMPT_BOUNDARY}.\n *\n * Splits on the FIRST occurrence — subsequent markers are folded into the\n * dynamic half. This way callers can append additional `<env>` style blocks\n * with extra markers without each one creating a new cache layer (Anthropic\n * caps breakpoints; we use the budget elsewhere). The marker itself is\n * stripped from both sides — providers attach `cache_control` directly to\n * the static half's text content.\n *\n * A single blank line (`\\n\\n`) immediately adjacent to the marker on each\n * side is trimmed — callers conventionally write\n * `<doctrine>\\n\\n<MARKER>\\n\\n<env>` and expect the rendered wire bytes to\n * read as one logical paragraph. Blank lines beyond that immediate pair\n * (e.g. `\\n\\n\\n<env>`) are preserved verbatim so callers composing their\n * own spacing don't lose intentional gaps.\n *\n * Pure / no I/O / no allocation when the marker is absent (returns the input\n * verbatim on the static side and the empty string on the dynamic side).\n */\nexport function splitSystemPrompt(system: string): SystemPromptParts {\n  if (system.length === 0)\n    return { static: '', dynamic: '' }\n  const idx = system.indexOf(SYSTEM_PROMPT_BOUNDARY)\n  if (idx < 0)\n    return { static: system, dynamic: '' }\n  const staticPart = system.slice(0, idx)\n  const dynamicPart = system.slice(idx + SYSTEM_PROMPT_BOUNDARY.length)\n  // Strip a single immediately-adjacent newline pair on each side. Callers\n  // typically write `<doctrine>\\n\\n<MARKER>\\n\\n<env>` and expect the rendered\n  // wire bytes to read as one logical paragraph. The trim is bounded so\n  // intentional blank lines further out (e.g. `\\n\\n\\n<env>`) are preserved\n  // for callers that compose their own spacing.\n  return {\n    static: trimTrailingBlankLine(staticPart),\n    dynamic: trimLeadingBlankLine(dynamicPart),\n  }\n}\n\n/**\n * Compose a system prompt from a static prefix and an optional dynamic\n * suffix. Inserts {@link SYSTEM_PROMPT_BOUNDARY} between them only when the\n * dynamic side is non-empty — single-block prompts stay marker-free, so\n * callers that never opt in pay zero overhead and providers fall back to the\n * existing whole-string caching path.\n *\n * Spacing is `\\n\\n` on both sides of the marker so doctrine fragments,\n * which conventionally separate sections with a blank line, read cleanly\n * around the boundary.\n */\nexport function joinSystemPrompt(staticPart: string, dynamicPart: string): string {\n  if (dynamicPart.length === 0)\n    return staticPart\n  if (staticPart.length === 0)\n    return `${SYSTEM_PROMPT_BOUNDARY}\\n\\n${dynamicPart}`\n  return `${staticPart}\\n\\n${SYSTEM_PROMPT_BOUNDARY}\\n\\n${dynamicPart}`\n}\n\n/**\n * Append `extra` to the STATIC half of a system prompt, preserving any\n * existing dynamic suffix.\n *\n * Used by the agent to fold in run-stable content (skills catalog, lazy tool\n * catalog) without bumping it into the dynamic half — both catalogs are\n * built once per run and remain byte-stable for the duration, so they\n * belong in the cached prefix.\n *\n * Returns a new string; the input is not mutated. When `extra` is empty,\n * returns the input verbatim.\n */\nexport function appendStaticSection(system: string, extra: string): string {\n  if (extra.length === 0)\n    return system\n  const { static: staticPart, dynamic } = splitSystemPrompt(system)\n  const nextStatic = staticPart.length === 0 ? extra : `${staticPart}\\n\\n${extra}`\n  return joinSystemPrompt(nextStatic, dynamic)\n}\n\n/**\n * Append `extra` to the DYNAMIC half of a system prompt. Inserts the boundary\n * marker if the input didn't already carry one.\n *\n * Used by hosts (typically the TUI) to inject per-turn state — current cwd,\n * IDE selection, project root — without forcing every caller to know the\n * marker format. The host's `system:transform` hook rewrites the dynamic\n * half each turn; the static doctrine above stays byte-stable and rides the\n * cache.\n *\n * Returns a new string; the input is not mutated. When `extra` is empty,\n * returns the input verbatim.\n */\nexport function appendDynamicSection(system: string, extra: string): string {\n  if (extra.length === 0)\n    return system\n  const { static: staticPart, dynamic } = splitSystemPrompt(system)\n  const nextDynamic = dynamic.length === 0 ? extra : `${dynamic}\\n\\n${extra}`\n  return joinSystemPrompt(staticPart, nextDynamic)\n}\n\n/**\n * Replace the entire dynamic half of a system prompt with `next`. Used by\n * the TUI's `<env>` rewriter where the entire dynamic section is regenerated\n * each turn rather than appended to.\n *\n * When `next` is empty, drops the dynamic half (and the marker) entirely.\n */\nexport function replaceDynamicSection(system: string, next: string): string {\n  const { static: staticPart } = splitSystemPrompt(system)\n  return joinSystemPrompt(staticPart, next)\n}\n\n/**\n * Strip the boundary marker so it never reaches the wire — collapses\n * `<static>${BOUNDARY}<dynamic>` into `<static>\\n\\n<dynamic>` for providers\n * that can't honor `cache_control` (vanilla OpenAI Chat Completions, Codex,\n * Cerebras, ...) or for the cache-disabled path on any provider.\n *\n * Cache-aware providers re-derive the split from the original (un-rendered)\n * system string via `splitSystemPrompt` — `renderSystemForWire` is the\n * marker-free counterpart used to build the actual wire bytes.\n *\n * No-op when the input has no marker. Pure / no I/O.\n */\nexport function renderSystemForWire(system: string): string {\n  if (system.length === 0)\n    return system\n  const parts = splitSystemPrompt(system)\n  if (parts.dynamic.length === 0)\n    return parts.static\n  if (parts.static.length === 0)\n    return parts.dynamic\n  return `${parts.static}\\n\\n${parts.dynamic}`\n}\n\n/** True when `system` contains the boundary marker. */\nexport function hasSystemPromptBoundary(system: string): boolean {\n  return system.includes(SYSTEM_PROMPT_BOUNDARY)\n}\n\n// ---------------------------------------------------------------------------\n// Internals\n// ---------------------------------------------------------------------------\n\n/** Strip a single trailing `\\n\\n` (and any leftover trailing whitespace within that pair). */\nfunction trimTrailingBlankLine(s: string): string {\n  // Walk back across at most two `\\n` separated only by spaces/tabs.\n  let end = s.length\n  let newlines = 0\n  while (end > 0 && newlines < 2) {\n    const ch = s.charCodeAt(end - 1)\n    if (ch === 0x0A) {\n      newlines += 1\n      end -= 1\n      continue\n    }\n    if (ch === 0x20 || ch === 0x09) {\n      end -= 1\n      continue\n    }\n    break\n  }\n  return newlines > 0 ? s.slice(0, end) : s\n}\n\n/** Strip a single leading `\\n\\n` (and any leftover leading whitespace within that pair). */\nfunction trimLeadingBlankLine(s: string): string {\n  let start = 0\n  let newlines = 0\n  while (start < s.length && newlines < 2) {\n    const ch = s.charCodeAt(start)\n    if (ch === 0x0A) {\n      newlines += 1\n      start += 1\n      continue\n    }\n    if (ch === 0x20 || ch === 0x09) {\n      start += 1\n      continue\n    }\n    break\n  }\n  return newlines > 0 ? s.slice(start) : s\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,MAAa,yBAAyB;;;;;;;;;;;;;;;;;;;;;AA8BtC,SAAgB,kBAAkB,QAAmC;CACnE,IAAI,OAAO,WAAW,GACpB,OAAO;EAAE,QAAQ;EAAI,SAAS;CAAG;CACnC,MAAM,MAAM,OAAO,QAAQ,sBAAsB;CACjD,IAAI,MAAM,GACR,OAAO;EAAE,QAAQ;EAAQ,SAAS;CAAG;CACvC,MAAM,aAAa,OAAO,MAAM,GAAG,GAAG;CACtC,MAAM,cAAc,OAAO,MAAM,MAAM,EAA6B;CAMpE,OAAO;EACL,QAAQ,sBAAsB,UAAU;EACxC,SAAS,qBAAqB,WAAW;CAC3C;AACF;;;;;;;;;;;;AAaA,SAAgB,iBAAiB,YAAoB,aAA6B;CAChF,IAAI,YAAY,WAAW,GACzB,OAAO;CACT,IAAI,WAAW,WAAW,GACxB,OAAO,GAAG,uBAAuB,MAAM;CACzC,OAAO,GAAG,WAAW,MAAM,uBAAuB,MAAM;AAC1D;;;;;;;;;;;;;AAcA,SAAgB,oBAAoB,QAAgB,OAAuB;CACzE,IAAI,MAAM,WAAW,GACnB,OAAO;CACT,MAAM,EAAE,QAAQ,YAAY,YAAY,kBAAkB,MAAM;CAEhE,OAAO,iBADY,WAAW,WAAW,IAAI,QAAQ,GAAG,WAAW,MAAM,SACrC,OAAO;AAC7C;;;;;;;;;;;;;;AAeA,SAAgB,qBAAqB,QAAgB,OAAuB;CAC1E,IAAI,MAAM,WAAW,GACnB,OAAO;CACT,MAAM,EAAE,QAAQ,YAAY,YAAY,kBAAkB,MAAM;CAEhE,OAAO,iBAAiB,YADJ,QAAQ,WAAW,IAAI,QAAQ,GAAG,QAAQ,MAAM,OACrB;AACjD;;;;;;;;AASA,SAAgB,sBAAsB,QAAgB,MAAsB;CAC1E,MAAM,EAAE,QAAQ,eAAe,kBAAkB,MAAM;CACvD,OAAO,iBAAiB,YAAY,IAAI;AAC1C;;;;;;;;;;;;;AAcA,SAAgB,oBAAoB,QAAwB;CAC1D,IAAI,OAAO,WAAW,GACpB,OAAO;CACT,MAAM,QAAQ,kBAAkB,MAAM;CACtC,IAAI,MAAM,QAAQ,WAAW,GAC3B,OAAO,MAAM;CACf,IAAI,MAAM,OAAO,WAAW,GAC1B,OAAO,MAAM;CACf,OAAO,GAAG,MAAM,OAAO,MAAM,MAAM;AACrC;;AAGA,SAAgB,wBAAwB,QAAyB;CAC/D,OAAO,OAAO,SAAS,sBAAsB;AAC/C;;AAOA,SAAS,sBAAsB,GAAmB;CAEhD,IAAI,MAAM,EAAE;CACZ,IAAI,WAAW;CACf,OAAO,MAAM,KAAK,WAAW,GAAG;EAC9B,MAAM,KAAK,EAAE,WAAW,MAAM,CAAC;EAC/B,IAAI,OAAO,IAAM;GACf,YAAY;GACZ,OAAO;GACP;EACF;EACA,IAAI,OAAO,MAAQ,OAAO,GAAM;GAC9B,OAAO;GACP;EACF;EACA;CACF;CACA,OAAO,WAAW,IAAI,EAAE,MAAM,GAAG,GAAG,IAAI;AAC1C;;AAGA,SAAS,qBAAqB,GAAmB;CAC/C,IAAI,QAAQ;CACZ,IAAI,WAAW;CACf,OAAO,QAAQ,EAAE,UAAU,WAAW,GAAG;EACvC,MAAM,KAAK,EAAE,WAAW,KAAK;EAC7B,IAAI,OAAO,IAAM;GACf,YAAY;GACZ,SAAS;GACT;EACF;EACA,IAAI,OAAO,MAAQ,OAAO,GAAM;GAC9B,SAAS;GACT;EACF;EACA;CACF;CACA,OAAO,WAAW,IAAI,EAAE,MAAM,KAAK,IAAI;AACzC"}

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,2 @@
+import { An as planAnthropicThinking, Dn as anthropic, En as AnthropicThinkingPlan, On as applyAnthropicCacheBreakpoints, Tn as AnthropicParams, jn as resolveAnthropicBetas, kn as classifyAnthropicError, wn as AnthropicContextManagement } from "../agent-EFWt6uQ_.js";
+export { AnthropicContextManagement, AnthropicParams, AnthropicThinkingPlan, anthropic, applyAnthropicCacheBreakpoints, classifyAnthropicError, planAnthropicThinking, resolveAnthropicBetas };

package/dist/providers/anthropic.js

@@ -0,0 +1,2 @@
+import { a as resolveAnthropicBetas, i as planAnthropicThinking, n as applyAnthropicCacheBreakpoints, r as classifyAnthropicError, t as anthropic } from "../anthropic-RGqsJlC8.js";
+export { anthropic, applyAnthropicCacheBreakpoints, classifyAnthropicError, planAnthropicThinking, resolveAnthropicBetas };

package/dist/providers/arcee.d.ts

@@ -0,0 +1,2 @@
+import { Cn as arcee, Sn as ArceeParams } from "../agent-EFWt6uQ_.js";
+export { ArceeParams, arcee };

package/dist/providers/arcee.js

@@ -0,0 +1,42 @@
+import { m as openaiCompat } from "../openai-compat-0Y7jcncn.js";
+//#region src/providers/arcee.ts
+const BASE_URL = "https://api.arcee.ai/api/v1";
+function getApiKey(params) {
+	if (typeof params?.apiKey === "string" && params.apiKey.length > 0) return params.apiKey;
+	if (process.env.ARCEE_API_KEY) return process.env.ARCEE_API_KEY;
+	throw new Error("No Arcee API key found. Pass `apiKey` or set ARCEE_API_KEY in your environment.");
+}
+/**
+* Arcee provider (Trinity-Large-Thinking and friends).
+*
+* Thin wrapper around {@link openaiCompat} pinned to the `reasoning_content`
+* round-trip mode: Trinity emits chain-of-thought in `<think>…</think>` blocks
+* that vLLM parses into a plain `reasoning_content` string. We capture it and
+* echo it back on every assistant message so the model resumes its prior
+* reasoning across tool calls — without this, tool calls leak into the
+* reasoning field as raw XML (Arcee's `xml_in_reasoning` pitfall). `content` is
+* also normalized from `null` → `''` on tool-call turns per the same guidance.
+*
+* See https://docs.arcee.ai/capabilities/reasoning-traces.
+*/
+function arcee(params) {
+	return openaiCompat({
+		name: "arcee",
+		apiKey: getApiKey(params),
+		baseURL: params?.baseURL || BASE_URL,
+		defaultModel: params?.defaultModel || "trinity-large-thinking",
+		capabilities: params?.capabilities ?? {
+			vision: false,
+			imageInToolResult: false
+		},
+		supportsReasoning: true,
+		reasoningMode: "reasoning_content",
+		reasoningContentField: params?.reasoningContentField ?? "reasoning",
+		normalizeNullContent: true,
+		extraHeaders: params?.extraHeaders
+	});
+}
+//#endregion
+export { arcee };
+
+//# sourceMappingURL=arcee.js.map

package/dist/providers/arcee.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arcee.js","names":[],"sources":["../../src/providers/arcee.ts"],"sourcesContent":["import type { Provider, ProviderCapabilities } from '.'\nimport { openaiCompat } from './openai-compat'\n\n// Arcee Platform API (OpenAI-compatible). Exposes Trinity models by plain\n// slug (`trinity-large-thinking`, `trinity-mini`, …) and returns reasoning in\n// the `reasoning_content` / `reasoning` field. NOTE: this is the Platform API\n// (`api.arcee.ai/api/v1`), not Conductor (`conductor.arcee.ai/v1`) — the latter\n// routes via different model names (`auto`, `blitz`). For self-hosted vLLM,\n// override `baseURL` and use the HF slug (`arcee-ai/Trinity-Large-Thinking`).\nconst BASE_URL = 'https://api.arcee.ai/api/v1'\n\nexport interface ArceeParams {\n  apiKey?: string\n  defaultModel?: string\n  /**\n   * Override the base URL — e.g. point at a self-hosted vLLM deployment serving\n   * Trinity-Thinking instead of Arcee's hosted Platform API.\n   */\n  baseURL?: string\n  /**\n   * Provider capability flags. Trinity models are text-only — default:\n   * `{ vision: false, imageInToolResult: false }`.\n   */\n  capabilities?: ProviderCapabilities\n  /**\n   * Wire field used to echo plain reasoning back across turns. Arcee's hosted\n   * API accepts both names; some self-hosted vLLM versions only read `reasoning`\n   * on input (vllm#38488). Default: `'reasoning'`.\n   */\n  reasoningContentField?: 'reasoning_content' | 'reasoning'\n  /**\n   * Extra HTTP headers sent on every request. Forwarded to the underlying\n   * {@link openaiCompat} client — use for routing/attribution headers a proxy\n   * in front of `baseURL` consumes.\n   */\n  extraHeaders?: Record<string, string>\n}\n\nfunction getApiKey(params?: ArceeParams): string {\n  // Resolution order aligned with the other providers: explicit > env > fail.\n  if (typeof params?.apiKey === 'string' && params.apiKey.length > 0)\n    return params.apiKey\n\n  if (process.env.ARCEE_API_KEY)\n    return process.env.ARCEE_API_KEY\n\n  throw new Error('No Arcee API key found. Pass `apiKey` or set ARCEE_API_KEY in your environment.')\n}\n\n/**\n * Arcee provider (Trinity-Large-Thinking and friends).\n *\n * Thin wrapper around {@link openaiCompat} pinned to the `reasoning_content`\n * round-trip mode: Trinity emits chain-of-thought in `<think>…</think>` blocks\n * that vLLM parses into a plain `reasoning_content` string. We capture it and\n * echo it back on every assistant message so the model resumes its prior\n * reasoning across tool calls — without this, tool calls leak into the\n * reasoning field as raw XML (Arcee's `xml_in_reasoning` pitfall). `content` is\n * also normalized from `null` → `''` on tool-call turns per the same guidance.\n *\n * See https://docs.arcee.ai/capabilities/reasoning-traces.\n */\nexport function arcee(params?: ArceeParams): Provider {\n  return openaiCompat({\n    name: 'arcee',\n    apiKey: getApiKey(params),\n    baseURL: params?.baseURL || BASE_URL,\n    defaultModel: params?.defaultModel || 'trinity-large-thinking',\n    capabilities: params?.capabilities ?? { vision: false, imageInToolResult: false },\n    supportsReasoning: true,\n    reasoningMode: 'reasoning_content',\n    reasoningContentField: params?.reasoningContentField ?? 'reasoning',\n    normalizeNullContent: true,\n    extraHeaders: params?.extraHeaders,\n  })\n}\n"],"mappings":";;AASA,MAAM,WAAW;AA6BjB,SAAS,UAAU,QAA8B;CAE/C,IAAI,OAAO,QAAQ,WAAW,YAAY,OAAO,OAAO,SAAS,GAC/D,OAAO,OAAO;CAEhB,IAAI,QAAQ,IAAI,eACd,OAAO,QAAQ,IAAI;CAErB,MAAM,IAAI,MAAM,iFAAiF;AACnG;;;;;;;;;;;;;;AAeA,SAAgB,MAAM,QAAgC;CACpD,OAAO,aAAa;EAClB,MAAM;EACN,QAAQ,UAAU,MAAM;EACxB,SAAS,QAAQ,WAAW;EAC5B,cAAc,QAAQ,gBAAgB;EACtC,cAAc,QAAQ,gBAAgB;GAAE,QAAQ;GAAO,mBAAmB;EAAM;EAChF,mBAAmB;EACnB,eAAe;EACf,uBAAuB,QAAQ,yBAAyB;EACxD,sBAAsB;EACtB,cAAc,QAAQ;CACxB,CAAC;AACH"}

package/dist/providers/baseten.d.ts

@@ -0,0 +1,2 @@
+import { bn as baseten, xn as planBasetenReasoning, yn as BasetenParams } from "../agent-EFWt6uQ_.js";
+export { BasetenParams, baseten, planBasetenReasoning };

package/dist/providers/baseten.js

@@ -0,0 +1,66 @@
+import { m as openaiCompat } from "../openai-compat-0Y7jcncn.js";
+//#region src/providers/baseten.ts
+const BASE_URL = "https://inference.baseten.co/v1";
+/**
+* Models that take OpenAI-style `reasoning_effort` (low/medium/high) and
+* reason by default. Everything else on Model APIs (Kimi, GLM, Nemotron) is
+* opt-in via `chat_template_args: { enable_thinking: true }`.
+* See https://docs.baseten.co/inference/model-apis/reasoning.
+*/
+const EFFORT_MODELS = new Set(["deepseek-ai/DeepSeek-V4-Pro", "openai/gpt-oss-120b"]);
+function getApiKey(params) {
+	if (typeof params?.apiKey === "string" && params.apiKey.length > 0) return params.apiKey;
+	if (process.env.BASETEN_API_KEY) return process.env.BASETEN_API_KEY;
+	throw new Error("No Baseten API key found. Pass `apiKey` or set BASETEN_API_KEY in your environment.");
+}
+/**
+* Map zidane's thinking level to Baseten's per-model reasoning request shape:
+*
+* - `reasoning_effort` models (DeepSeek V4 Pro, GPT-OSS 120B) reason by
+*   default; the effort string tunes depth. `'minimal'` maps to `'low'`,
+*   Anthropic-only upper tiers map to `'high'`, `'adaptive'` sends nothing
+*   (server default = medium); `'off'` sends nothing (cannot be disabled).
+* - All other models opt in via `chat_template_args.enable_thinking` — any
+*   non-off level enables it (the template arg is boolean, no depth knob).
+*
+* Exported for tests.
+*/
+function planBasetenReasoning(ctx) {
+	const { model, thinking } = ctx;
+	if (!thinking || thinking === "off") return void 0;
+	if (EFFORT_MODELS.has(model)) {
+		if (thinking === "adaptive") return void 0;
+		return { reasoning_effort: thinking === "minimal" ? "low" : thinking === "xhigh" || thinking === "max" ? "high" : thinking };
+	}
+	return { chat_template_args: { enable_thinking: true } };
+}
+/**
+* Baseten Model APIs provider.
+*
+* Thin wrapper around {@link openaiCompat} pinned to the `reasoning_content`
+* round-trip mode: thinking arrives in the `reasoning_content` delta field and
+* is echoed back on assistant messages under the same name so reasoning
+* models resume their chain-of-thought across tool calls. The thinking level
+* maps to Baseten's request shape via {@link planBasetenReasoning}.
+*/
+function baseten(params) {
+	return openaiCompat({
+		name: "baseten",
+		apiKey: getApiKey(params),
+		baseURL: params?.baseURL || BASE_URL,
+		defaultModel: params?.defaultModel || "zai-org/GLM-5.1",
+		capabilities: params?.capabilities ?? {
+			vision: false,
+			imageInToolResult: false
+		},
+		supportsReasoning: true,
+		reasoningMode: "reasoning_content",
+		reasoningContentField: "reasoning_content",
+		planReasoningRequest: planBasetenReasoning,
+		extraHeaders: params?.extraHeaders
+	});
+}
+//#endregion
+export { baseten, planBasetenReasoning };
+
+//# sourceMappingURL=baseten.js.map

package/dist/providers/baseten.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseten.js","names":[],"sources":["../../src/providers/baseten.ts"],"sourcesContent":["import type { Provider, ProviderCapabilities } from '.'\nimport type { ThinkingLevel } from '../types'\nimport { openaiCompat } from './openai-compat'\n\n// Baseten Model APIs (OpenAI-compatible, shared infrastructure). Models are\n// addressed by HF-style slugs (`zai-org/GLM-5.1`, `moonshotai/Kimi-K2.6`, …)\n// and reasoning text streams in the `reasoning_content` delta field.\n// See https://docs.baseten.co/inference/model-apis/overview.\nconst BASE_URL = 'https://inference.baseten.co/v1'\n\n/**\n * Models that take OpenAI-style `reasoning_effort` (low/medium/high) and\n * reason by default. Everything else on Model APIs (Kimi, GLM, Nemotron) is\n * opt-in via `chat_template_args: { enable_thinking: true }`.\n * See https://docs.baseten.co/inference/model-apis/reasoning.\n */\nconst EFFORT_MODELS = new Set([\n  'deepseek-ai/DeepSeek-V4-Pro',\n  'openai/gpt-oss-120b',\n])\n\nexport interface BasetenParams {\n  apiKey?: string\n  defaultModel?: string\n  /**\n   * Override the base URL — e.g. point at a dedicated Baseten deployment's\n   * OpenAI-compatible bridge instead of the shared Model APIs endpoint.\n   */\n  baseURL?: string\n  /**\n   * Provider capability flags. Default: `{ vision: false, imageInToolResult: false }`\n   * — conservative, since most Model APIs are text-only. Set `vision: true`\n   * when pinning a Kimi K2.x model (the only vision-capable ones).\n   */\n  capabilities?: ProviderCapabilities\n  /**\n   * Extra HTTP headers sent on every request. Forwarded to the underlying\n   * {@link openaiCompat} client.\n   */\n  extraHeaders?: Record<string, string>\n}\n\nfunction getApiKey(params?: BasetenParams): string {\n  // Resolution order aligned with the other providers: explicit > env > fail.\n  if (typeof params?.apiKey === 'string' && params.apiKey.length > 0)\n    return params.apiKey\n\n  if (process.env.BASETEN_API_KEY)\n    return process.env.BASETEN_API_KEY\n\n  throw new Error('No Baseten API key found. Pass `apiKey` or set BASETEN_API_KEY in your environment.')\n}\n\n/**\n * Map zidane's thinking level to Baseten's per-model reasoning request shape:\n *\n * - `reasoning_effort` models (DeepSeek V4 Pro, GPT-OSS 120B) reason by\n *   default; the effort string tunes depth. `'minimal'` maps to `'low'`,\n *   Anthropic-only upper tiers map to `'high'`, `'adaptive'` sends nothing\n *   (server default = medium); `'off'` sends nothing (cannot be disabled).\n * - All other models opt in via `chat_template_args.enable_thinking` — any\n *   non-off level enables it (the template arg is boolean, no depth knob).\n *\n * Exported for tests.\n */\nexport function planBasetenReasoning(\n  ctx: { model: string, thinking?: ThinkingLevel },\n): Record<string, unknown> | undefined {\n  const { model, thinking } = ctx\n  if (!thinking || thinking === 'off')\n    return undefined\n  if (EFFORT_MODELS.has(model)) {\n    if (thinking === 'adaptive')\n      return undefined\n    const effort = thinking === 'minimal' ? 'low' : thinking === 'xhigh' || thinking === 'max' ? 'high' : thinking\n    return { reasoning_effort: effort }\n  }\n  return { chat_template_args: { enable_thinking: true } }\n}\n\n/**\n * Baseten Model APIs provider.\n *\n * Thin wrapper around {@link openaiCompat} pinned to the `reasoning_content`\n * round-trip mode: thinking arrives in the `reasoning_content` delta field and\n * is echoed back on assistant messages under the same name so reasoning\n * models resume their chain-of-thought across tool calls. The thinking level\n * maps to Baseten's request shape via {@link planBasetenReasoning}.\n */\nexport function baseten(params?: BasetenParams): Provider {\n  return openaiCompat({\n    name: 'baseten',\n    apiKey: getApiKey(params),\n    baseURL: params?.baseURL || BASE_URL,\n    defaultModel: params?.defaultModel || 'zai-org/GLM-5.1',\n    capabilities: params?.capabilities ?? { vision: false, imageInToolResult: false },\n    supportsReasoning: true,\n    reasoningMode: 'reasoning_content',\n    reasoningContentField: 'reasoning_content',\n    planReasoningRequest: planBasetenReasoning,\n    extraHeaders: params?.extraHeaders,\n  })\n}\n"],"mappings":";;AAQA,MAAM,WAAW;;;;;;;AAQjB,MAAM,gBAAgB,IAAI,IAAI,CAC5B,+BACA,qBACF,CAAC;AAuBD,SAAS,UAAU,QAAgC;CAEjD,IAAI,OAAO,QAAQ,WAAW,YAAY,OAAO,OAAO,SAAS,GAC/D,OAAO,OAAO;CAEhB,IAAI,QAAQ,IAAI,iBACd,OAAO,QAAQ,IAAI;CAErB,MAAM,IAAI,MAAM,qFAAqF;AACvG;;;;;;;;;;;;;AAcA,SAAgB,qBACd,KACqC;CACrC,MAAM,EAAE,OAAO,aAAa;CAC5B,IAAI,CAAC,YAAY,aAAa,OAC5B,OAAO,KAAA;CACT,IAAI,cAAc,IAAI,KAAK,GAAG;EAC5B,IAAI,aAAa,YACf,OAAO,KAAA;EAET,OAAO,EAAE,kBADM,aAAa,YAAY,QAAQ,aAAa,WAAW,aAAa,QAAQ,SAAS,SACpE;CACpC;CACA,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,KAAK,EAAE;AACzD;;;;;;;;;;AAWA,SAAgB,QAAQ,QAAkC;CACxD,OAAO,aAAa;EAClB,MAAM;EACN,QAAQ,UAAU,MAAM;EACxB,SAAS,QAAQ,WAAW;EAC5B,cAAc,QAAQ,gBAAgB;EACtC,cAAc,QAAQ,gBAAgB;GAAE,QAAQ;GAAO,mBAAmB;EAAM;EAChF,mBAAmB;EACnB,eAAe;EACf,uBAAuB;EACvB,sBAAsB;EACtB,cAAc,QAAQ;CACxB,CAAC;AACH"}

package/dist/providers/cerebras.d.ts

@@ -0,0 +1,2 @@
+import { _n as CerebrasParams, vn as cerebras } from "../agent-EFWt6uQ_.js";
+export { CerebrasParams, cerebras };

package/dist/providers/cerebras.js

@@ -0,0 +1,31 @@
+import { m as openaiCompat } from "../openai-compat-0Y7jcncn.js";
+//#region src/providers/cerebras.ts
+const BASE_URL = "https://api.cerebras.ai/v1";
+function getApiKey(params) {
+	if (typeof params?.apiKey === "string" && params.apiKey.length > 0) return params.apiKey;
+	if (process.env.CEREBRAS_API_KEY) return process.env.CEREBRAS_API_KEY;
+	throw new Error("No Cerebras API key found. Pass `apiKey` or set CEREBRAS_API_KEY in your environment.");
+}
+/**
+* Cerebras provider.
+*
+* Thin wrapper around {@link openaiCompat} with Cerebras-specific defaults
+* (base URL, default model).
+*/
+function cerebras(params) {
+	return openaiCompat({
+		name: "cerebras",
+		apiKey: getApiKey(params),
+		baseURL: BASE_URL,
+		defaultModel: params?.defaultModel || "zai-glm-4.7",
+		capabilities: params?.capabilities ?? {
+			vision: false,
+			imageInToolResult: false
+		},
+		extraHeaders: params?.extraHeaders
+	});
+}
+//#endregion
+export { cerebras };
+
+//# sourceMappingURL=cerebras.js.map

package/dist/providers/cerebras.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cerebras.js","names":[],"sources":["../../src/providers/cerebras.ts"],"sourcesContent":["import type { Provider, ProviderCapabilities } from '.'\nimport { openaiCompat } from './openai-compat'\n\nconst BASE_URL = 'https://api.cerebras.ai/v1'\n\nexport interface CerebrasParams {\n  apiKey?: string\n  defaultModel?: string\n  /**\n   * Provider capability flags. Cerebras currently serves text-only OSS models\n   * (GLM, Llama-family, Qwen-family) — default: `{ vision: false, imageInToolResult: false }`.\n   * Override when routing to a vision-capable deployment.\n   */\n  capabilities?: ProviderCapabilities\n  /**\n   * Extra HTTP headers sent on every request. Forwarded to the underlying\n   * {@link openaiCompat} client — use for routing/attribution headers a proxy\n   * in front of `baseURL` consumes.\n   */\n  extraHeaders?: Record<string, string>\n}\n\nfunction getApiKey(params?: CerebrasParams): string {\n  // Resolution order is intentionally aligned with `anthropic` + `openai` —\n  // explicit params > env var > fail. Host code that composes providers from\n  // config (e.g. a YAML-driven CLI) relies on `params.apiKey` winning in all\n  // providers, not just some.\n  if (typeof params?.apiKey === 'string' && params.apiKey.length > 0)\n    return params.apiKey\n\n  if (process.env.CEREBRAS_API_KEY)\n    return process.env.CEREBRAS_API_KEY\n\n  throw new Error('No Cerebras API key found. Pass `apiKey` or set CEREBRAS_API_KEY in your environment.')\n}\n\n/**\n * Cerebras provider.\n *\n * Thin wrapper around {@link openaiCompat} with Cerebras-specific defaults\n * (base URL, default model).\n */\nexport function cerebras(params?: CerebrasParams): Provider {\n  const apiKey = getApiKey(params)\n  return openaiCompat({\n    name: 'cerebras',\n    apiKey,\n    baseURL: BASE_URL,\n    defaultModel: params?.defaultModel || 'zai-glm-4.7',\n    capabilities: params?.capabilities ?? { vision: false, imageInToolResult: false },\n    extraHeaders: params?.extraHeaders,\n  })\n}\n"],"mappings":";;AAGA,MAAM,WAAW;AAmBjB,SAAS,UAAU,QAAiC;CAKlD,IAAI,OAAO,QAAQ,WAAW,YAAY,OAAO,OAAO,SAAS,GAC/D,OAAO,OAAO;CAEhB,IAAI,QAAQ,IAAI,kBACd,OAAO,QAAQ,IAAI;CAErB,MAAM,IAAI,MAAM,uFAAuF;AACzG;;;;;;;AAQA,SAAgB,SAAS,QAAmC;CAE1D,OAAO,aAAa;EAClB,MAAM;EACN,QAHa,UAAU,MAGlB;EACL,SAAS;EACT,cAAc,QAAQ,gBAAgB;EACtC,cAAc,QAAQ,gBAAgB;GAAE,QAAQ;GAAO,mBAAmB;EAAM;EAChF,cAAc,QAAQ;CACxB,CAAC;AACH"}

package/dist/providers/local.d.ts

@@ -0,0 +1,2 @@
+import { mn as local, pn as LocalParams } from "../agent-EFWt6uQ_.js";
+export { LocalParams, local };

package/dist/providers/local.js

@@ -0,0 +1,44 @@
+import { m as openaiCompat } from "../openai-compat-0Y7jcncn.js";
+//#region src/providers/local.ts
+function getBaseURL(params) {
+	if (typeof params?.baseURL === "string" && params.baseURL.length > 0) return params.baseURL;
+	if (process.env.LOCAL_LLM_BASE_URL) return process.env.LOCAL_LLM_BASE_URL;
+	throw new Error("No local LLM base URL found. Pass `baseURL` or set LOCAL_LLM_BASE_URL (e.g. http://localhost:11434/v1 for Ollama, http://localhost:8000/v1 for vLLM).");
+}
+function getApiKey(params) {
+	if (typeof params?.apiKey === "string" && params.apiKey.length > 0) return params.apiKey;
+	if (process.env.LOCAL_LLM_API_KEY) return process.env.LOCAL_LLM_API_KEY;
+	return "no-key";
+}
+function getDefaultModel(params) {
+	if (typeof params?.defaultModel === "string" && params.defaultModel.length > 0) return params.defaultModel;
+	if (process.env.LOCAL_LLM_DEFAULT_MODEL) return process.env.LOCAL_LLM_DEFAULT_MODEL;
+}
+/**
+* Local OpenAI-compatible LLM provider.
+*
+* Thin wrapper around {@link openaiCompat} for self-hosted runtimes that
+* speak the standard `POST /chat/completions` + SSE dialect: Ollama, vLLM,
+* LM Studio, Lemonade, llama.cpp's server, text-generation-webui, etc.
+*
+* Caching and reasoning are left off — local runtimes typically strict-
+* validate the request schema and would 400 on the extra fields. Override
+* `capabilities` when pointing at a vision-capable deployment.
+*/
+function local(params) {
+	return openaiCompat({
+		name: "local",
+		apiKey: getApiKey(params),
+		baseURL: getBaseURL(params),
+		defaultModel: getDefaultModel(params),
+		capabilities: params?.capabilities ?? {
+			vision: false,
+			imageInToolResult: false
+		},
+		extraHeaders: params?.extraHeaders
+	});
+}
+//#endregion
+export { local };
+
+//# sourceMappingURL=local.js.map

package/dist/providers/local.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.js","names":[],"sources":["../../src/providers/local.ts"],"sourcesContent":["import type { Provider, ProviderCapabilities } from '.'\nimport { openaiCompat } from './openai-compat'\n\nexport interface LocalParams {\n  /**\n   * Base URL of the local OpenAI-compatible server. `/chat/completions` is\n   * appended. Examples:\n   *   - Ollama:    `http://localhost:11434/v1`\n   *   - vLLM:      `http://localhost:8000/v1`\n   *   - LM Studio: `http://localhost:1234/v1`\n   *   - Lemonade:  `http://localhost:8000/api/v1`\n   *   - llama.cpp: `http://localhost:8080/v1`\n   *\n   * Resolution order: explicit `params.baseURL` > `LOCAL_LLM_BASE_URL` env >\n   * throw.\n   */\n  baseURL?: string\n  /**\n   * Optional bearer key. Most local servers don't authenticate; some (vLLM\n   * with `--api-key`, gateway proxies, llama.cpp with `--api-key`) do.\n   * Falls back to `LOCAL_LLM_API_KEY`, then to a placeholder string accepted\n   * by unauthenticated endpoints.\n   */\n  apiKey?: string\n  /**\n   * Default model id. Local runtimes have no fixed catalogue — whatever the\n   * user has loaded (e.g. `llama3.1:8b`, `qwen2.5-coder`, a HF repo path).\n   * Falls back to `LOCAL_LLM_DEFAULT_MODEL`.\n   */\n  defaultModel?: string\n  /**\n   * Provider capability flags. Defaults to text-only — typical OSS local\n   * deployment. Override when pointing at a vision-capable runtime (e.g.\n   * Ollama serving a multimodal model, vLLM with a VLM).\n   */\n  capabilities?: ProviderCapabilities\n  /**\n   * Extra HTTP headers sent on every request. Forwarded to the underlying\n   * {@link openaiCompat} client — use for auth/routing headers a self-hosted\n   * gateway in front of `baseURL` consumes.\n   */\n  extraHeaders?: Record<string, string>\n}\n\nfunction getBaseURL(params?: LocalParams): string {\n  if (typeof params?.baseURL === 'string' && params.baseURL.length > 0)\n    return params.baseURL\n  if (process.env.LOCAL_LLM_BASE_URL)\n    return process.env.LOCAL_LLM_BASE_URL\n  throw new Error(\n    'No local LLM base URL found. Pass `baseURL` or set LOCAL_LLM_BASE_URL '\n    + '(e.g. http://localhost:11434/v1 for Ollama, http://localhost:8000/v1 for vLLM).',\n  )\n}\n\nfunction getApiKey(params?: LocalParams): string {\n  if (typeof params?.apiKey === 'string' && params.apiKey.length > 0)\n    return params.apiKey\n  if (process.env.LOCAL_LLM_API_KEY)\n    return process.env.LOCAL_LLM_API_KEY\n  // Most local servers don't authenticate; send a placeholder so the factory's\n  // Authorization header is well-formed (servers that ignore the header are\n  // unaffected; servers that strict-check will be configured via env anyway).\n  return 'no-key'\n}\n\nfunction getDefaultModel(params?: LocalParams): string | undefined {\n  if (typeof params?.defaultModel === 'string' && params.defaultModel.length > 0)\n    return params.defaultModel\n  if (process.env.LOCAL_LLM_DEFAULT_MODEL)\n    return process.env.LOCAL_LLM_DEFAULT_MODEL\n  return undefined\n}\n\n/**\n * Local OpenAI-compatible LLM provider.\n *\n * Thin wrapper around {@link openaiCompat} for self-hosted runtimes that\n * speak the standard `POST /chat/completions` + SSE dialect: Ollama, vLLM,\n * LM Studio, Lemonade, llama.cpp's server, text-generation-webui, etc.\n *\n * Caching and reasoning are left off — local runtimes typically strict-\n * validate the request schema and would 400 on the extra fields. Override\n * `capabilities` when pointing at a vision-capable deployment.\n */\nexport function local(params?: LocalParams): Provider {\n  return openaiCompat({\n    name: 'local',\n    apiKey: getApiKey(params),\n    baseURL: getBaseURL(params),\n    defaultModel: getDefaultModel(params),\n    capabilities: params?.capabilities ?? { vision: false, imageInToolResult: false },\n    extraHeaders: params?.extraHeaders,\n  })\n}\n"],"mappings":";;AA4CA,SAAS,WAAW,QAA8B;CAChD,IAAI,OAAO,QAAQ,YAAY,YAAY,OAAO,QAAQ,SAAS,GACjE,OAAO,OAAO;CAChB,IAAI,QAAQ,IAAI,oBACd,OAAO,QAAQ,IAAI;CACrB,MAAM,IAAI,MACR,uJAEF;AACF;AAEA,SAAS,UAAU,QAA8B;CAC/C,IAAI,OAAO,QAAQ,WAAW,YAAY,OAAO,OAAO,SAAS,GAC/D,OAAO,OAAO;CAChB,IAAI,QAAQ,IAAI,mBACd,OAAO,QAAQ,IAAI;CAIrB,OAAO;AACT;AAEA,SAAS,gBAAgB,QAA0C;CACjE,IAAI,OAAO,QAAQ,iBAAiB,YAAY,OAAO,aAAa,SAAS,GAC3E,OAAO,OAAO;CAChB,IAAI,QAAQ,IAAI,yBACd,OAAO,QAAQ,IAAI;AAEvB;;;;;;;;;;;;AAaA,SAAgB,MAAM,QAAgC;CACpD,OAAO,aAAa;EAClB,MAAM;EACN,QAAQ,UAAU,MAAM;EACxB,SAAS,WAAW,MAAM;EAC1B,cAAc,gBAAgB,MAAM;EACpC,cAAc,QAAQ,gBAAgB;GAAE,QAAQ;GAAO,mBAAmB;EAAM;EAChF,cAAc,QAAQ;CACxB,CAAC;AACH"}

package/dist/providers/openai-compat.d.ts

@@ -0,0 +1,2 @@
+import { $t as classifyOpenAICompatError, Gt as OpenAICompatHttpError, Ht as OAIMessage, Jt as TOOL_RESULTS_TAG, Kt as OpenAICompatParams, Qt as buildAssistantContent, Ut as OAITool, Vt as ASSISTANT_TOOL_CALLS_TAG, Wt as OpenAICompatAuthHeader, Xt as applyOAIToolCacheBreakpoint, Yt as applyOAICacheBreakpoints, Zt as assistantMessage, an as toOAIMessages, en as consumeSSE, in as openaiCompat, nn as mapOAIFinishReason, on as toolResultsMessage, qt as OpenAICompatStreamError, rn as openAICompatPromptMessage, sn as userMessage, tn as formatTools } from "../agent-EFWt6uQ_.js";
+export { ASSISTANT_TOOL_CALLS_TAG, OAIMessage, OAITool, OpenAICompatAuthHeader, OpenAICompatHttpError, OpenAICompatParams, OpenAICompatStreamError, TOOL_RESULTS_TAG, applyOAICacheBreakpoints, applyOAIToolCacheBreakpoint, assistantMessage, buildAssistantContent, classifyOpenAICompatError, consumeSSE, formatTools, mapOAIFinishReason, openAICompatPromptMessage, openaiCompat, toOAIMessages, toolResultsMessage, userMessage };

package/dist/providers/openai-compat.js

@@ -0,0 +1,2 @@
+import { _ as userMessage, a as applyOAICacheBreakpoints, c as buildAssistantContent, d as formatTools, f as mapOAIFinishReason, g as toolResultsMessage, h as toOAIMessages, i as TOOL_RESULTS_TAG, l as classifyOpenAICompatError, m as openaiCompat, n as OpenAICompatHttpError, o as applyOAIToolCacheBreakpoint, p as openAICompatPromptMessage, r as OpenAICompatStreamError, s as assistantMessage, t as ASSISTANT_TOOL_CALLS_TAG, u as consumeSSE } from "../openai-compat-0Y7jcncn.js";
+export { ASSISTANT_TOOL_CALLS_TAG, OpenAICompatHttpError, OpenAICompatStreamError, TOOL_RESULTS_TAG, applyOAICacheBreakpoints, applyOAIToolCacheBreakpoint, assistantMessage, buildAssistantContent, classifyOpenAICompatError, consumeSSE, formatTools, mapOAIFinishReason, openAICompatPromptMessage, openaiCompat, toOAIMessages, toolResultsMessage, userMessage };

package/dist/providers/openai.d.ts

@@ -0,0 +1,2 @@
+import { cn as OpenAIParams, dn as openai, fn as toPiMessages, ln as classifyOpenAIError, un as mapCodexStopReason } from "../agent-EFWt6uQ_.js";
+export { OpenAIParams, classifyOpenAIError, mapCodexStopReason, openai, toPiMessages };