zidane 5.6.11 → 5.6.13

package/dist/{messages-BfmXLDT4.js → messages-Dym8S_YH.js}

@@ -1,5 +1,212 @@
 import { c as errorMessage, l as matchesContextExceeded } from "./errors-DdZXnyXE.js";
-import { getModel } from "@mariozechner/pi-ai";
+import { getModel } from "@earendil-works/pi-ai";
+//#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
 //#region src/providers/cost.ts
 /**
 * Fill in `usage.cost` from pi-ai's bundled price registry when the
@@ -12,7 +219,7 @@ import { getModel } from "@mariozechner/pi-ai";
 * than fabricating a $0.
 *
 * The number is an estimate: token counts come from the API, rates from
-* the locally-bundled registry that refreshes with `@mariozechner/pi-ai`
+* the locally-bundled registry that refreshes with `@earendil-works/pi-ai`
 * version bumps. If a provider changes prices between bumps the figure
 * will drift until the dep updates.
 */
@@ -545,7 +752,7 @@ function summarizeToolResultOutput(output) {
 function toOAIMessages(system, messages, options = {}) {
 	const out = [{
 		role: "system",
-		content: system
+		content: renderSystemForWire(system)
 	}];
 	const nativeImageInTool = options.imageInToolResult === true;
 	const reasoningEnabled = options.supportsReasoning === true;
@@ -682,15 +889,62 @@ const EPHEMERAL = { type: "ephemeral" };
 * - Assistant messages with no text (tool-call-only) — attaching a cache marker to a
 *   `tool_calls` block has no defined semantics, so we skip and let the prior
 *   system/tools breakpoints carry caching.
+*
+* System-prompt boundary handling: when `originalSystem` (the un-rendered
+* system text passed to {@link toOAIMessages}) contains
+* {@link SYSTEM_PROMPT_BOUNDARY}, the leading system message is rewritten as
+* a two-part array — `cache_control` lands on the static prefix only, so
+* per-turn churn in the dynamic suffix doesn't invalidate the cached
+* doctrine above. `originalSystem` defaults to `undefined` for back-compat;
+* omit it (or pass a marker-free string) for the single-block historic
+* behavior.
 */
-function applyOAICacheBreakpoints(messages) {
+function applyOAICacheBreakpoints(messages, originalSystem) {
 	if (messages.length === 0) return;
 	const first = messages[0];
-	if (first.role === "system") markLastContentPart(first);
+	if (first.role === "system") markSystemMessage(first, originalSystem);
 	const lastIdx = messages.length - 1;
 	if (lastIdx > 0) markLastContentPart(messages[lastIdx]);
 }
 /**
+* Place the cache marker on the static prefix of the system message. When
+* `originalSystem` carried {@link SYSTEM_PROMPT_BOUNDARY}, the message becomes
+* a two-part array — static (cached) then dynamic (uncached). Otherwise falls
+* through to {@link markLastContentPart} for the historic single-block
+* treatment.
+*
+* String-only branch — system messages produced by {@link toOAIMessages} are
+* always plain strings (`{ role: 'system', content: <rendered> }`). Hosts
+* that supply pre-built multi-part system messages bypass this branch and
+* get the generic last-block treatment.
+*/
+function markSystemMessage(msg, originalSystem) {
+	if (typeof msg.content !== "string" || msg.content.length === 0) {
+		markLastContentPart(msg);
+		return;
+	}
+	const parts = splitSystemPrompt(originalSystem && originalSystem.length > 0 ? originalSystem : msg.content);
+	if (parts.dynamic.length === 0) {
+		msg.content = [{
+			type: "text",
+			text: parts.static,
+			cache_control: EPHEMERAL
+		}];
+		return;
+	}
+	const next = [];
+	if (parts.static.length > 0) next.push({
+		type: "text",
+		text: parts.static,
+		cache_control: EPHEMERAL
+	});
+	next.push({
+		type: "text",
+		text: parts.dynamic
+	});
+	msg.content = next;
+}
+/**
 * Mark the last content part of an OAI message with `cache_control`. Normalizes
 * string content into a `[{ type: 'text', text, cache_control }]` array so the
 * marker has a block to attach to.
@@ -948,7 +1202,7 @@ function openaiCompat(params) {
 				model: modelId
 			});
 			const shouldCache = cacheBreakpointsEnabled && options.cache !== false;
-			if (shouldCache) applyOAICacheBreakpoints(messages);
+			if (shouldCache) applyOAICacheBreakpoints(messages, options.system);
 			const maxTokens = options.thinkingBudget ? options.thinkingBudget + options.maxTokens : options.maxTokens;
 			const body = {
 				...params.extraBodyParams ?? {},
@@ -1737,6 +1991,47 @@ function ensureEndsWithUserMessage(messages, provider, directive = DEFAULT_USER_
 	if (messages[messages.length - 1].role === "user") return messages;
 	return [...messages, provider.userMessage(directive)];
 }
+/**
+* Build a wire-ready `SessionMessage[]` from raw persisted `SessionTurn[]`.
+*
+* **The canonical "I want to send these to a provider" projection.** Use
+* this — not raw `session.turns` / `store.getTurns()` — when constructing a
+* provider request outside `agent.run()`. The agent's own wire pipeline
+* (`executeTurn` in `src/loop.ts`) applies the same repair just-in-time;
+* downstream consumers that bypass the loop hit `tool_result must be
+* preceded by a tool_call` 400s precisely because they shipped raw turns.
+*
+* Pipeline:
+*   1. Filter `system`-role turns (the wire only carries user/assistant).
+*   2. {@link ensureToolResultPairing} — repairs all six orphan / dup
+*      corruption modes by inserting synthetic placeholders rather than
+*      dropping (preserves the model's tool_use shape).
+*   3. {@link ensureEndsWithUserMessage} when `options.provider` is set —
+*      guards against assistant-tail prefill rejection (opus 4.7, o-series).
+*
+* Pure + idempotent. Does not mutate the input turns. Re-running on the
+* output is a no-op.
+*
+* **Do not feed the result back into `session.setTurns` / `appendTurns`.**
+* The repair can insert `SYNTHETIC_TOOL_RESULT_PLACEHOLDER` / `[Orphaned
+* tool result removed …]` markers; round-tripping those into persisted
+* state contaminates the session's reasoning history and defeats the
+* "don't rewrite the past" invariant the wire-only repair was designed
+* around.
+*/
+function toWireMessages(turns, options = {}) {
+	const messages = [];
+	for (const t of turns) {
+		if (t.role === "system") continue;
+		messages.push({
+			role: t.role,
+			content: t.content
+		});
+	}
+	const paired = ensureToolResultPairing(messages, options.onRepair ? { onRepair: options.onRepair } : {});
+	if (!options.provider) return paired;
+	return ensureEndsWithUserMessage(paired, options.provider, options.userTailDirective);
+}
 function autoDetectAndConvert(msg) {
 	const c = msg.content;
 	if (c && typeof c === "object" && !Array.isArray(c)) {
@@ -1756,6 +2051,6 @@ function autoDetectAndConvert(msg) {
 	return fromAnthropic(msg);
 }
 //#endregion
-export { fillEstimatedCost as S, openaiCompat as _, detectTurnInterruption as a, sanitizeToolSchema as b, filterUnresolvedToolUses as c, toAnthropic as d, toOpenAI as f, mapOAIFinishReason as g, classifyOpenAICompatError as h, autoDetectAndConvert as i, fromAnthropic as l, assistantMessage as m, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as n, ensureEndsWithUserMessage as o, OpenAICompatHttpError as p, TOOL_USE_INTERRUPTED_MARKER as r, ensureToolResultPairing as s, ORPHANED_TOOL_RESULT_MARKER as t, fromOpenAI as u, toolResultsMessage as v, sanitizeToolSpecs as x, userMessage as y };
+export { replaceDynamicSection as A, fillEstimatedCost as C, hasSystemPromptBoundary as D, appendStaticSection as E, joinSystemPrompt as O, sanitizeToolSpecs as S, appendDynamicSection as T, mapOAIFinishReason as _, detectTurnInterruption as a, userMessage as b, filterUnresolvedToolUses as c, toAnthropic as d, toOpenAI as f, classifyOpenAICompatError as g, assistantMessage as h, autoDetectAndConvert as i, splitSystemPrompt as j, renderSystemForWire as k, fromAnthropic as l, OpenAICompatHttpError as m, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as n, ensureEndsWithUserMessage as o, toWireMessages as p, TOOL_USE_INTERRUPTED_MARKER as r, ensureToolResultPairing as s, ORPHANED_TOOL_RESULT_MARKER as t, fromOpenAI as u, openaiCompat as v, SYSTEM_PROMPT_BOUNDARY as w, sanitizeToolSchema as x, toolResultsMessage as y };
 
-//# sourceMappingURL=messages-BfmXLDT4.js.map
+//# sourceMappingURL=messages-Dym8S_YH.js.map