zidane 7.2.5 → 8.0.4

package/dist/turn-operations-B8sokwi5.js

@@ -0,0 +1,333 @@
+//#region src/chat/model-chain.ts
+/** Identity of a chain entry — the pair, not object identity. */
+function chainEntryKey(entry) {
+	return `${entry.provider}\u0000${entry.model}`;
+}
+/** Toggle `entry`: absent → appended, present → removed. Pure. */
+function toggleKeyed(chain, entry, keyOf) {
+	const key = keyOf(entry);
+	const idx = chain.findIndex((e) => keyOf(e) === key);
+	if (idx === -1) return [...chain, entry];
+	return [...chain.slice(0, idx), ...chain.slice(idx + 1)];
+}
+/**
+* Make `entry` the primary (position 0), keeping the rest in order. Inserts
+* when absent, promotes when present; no-op when it already leads.
+*
+* This is `↵` in the picker. It exists because toggling APPENDS: with a chain
+* of `[current]`, toggling a new model produced `[current, new]` — the pick
+* became a fallback and the active model never changed. "Highlight and ↵"
+* means "use this one", so that gesture promotes; building a fallback list is
+* the secondary gesture (`⇥`) and keeps toggle semantics.
+*/
+function pickPrimaryKeyed(chain, entry, keyOf) {
+	const key = keyOf(entry);
+	return [entry, ...chain.filter((e) => keyOf(e) !== key)];
+}
+/** 1-based position of `key` in the chain, or `null` when absent. */
+function positionKeyed(chain, key, keyOf) {
+	const idx = chain.findIndex((e) => keyOf(e) === key);
+	return idx === -1 ? null : idx + 1;
+}
+/** Same entries in the same order. */
+function chainsEqualKeyed(a, b, keyOf) {
+	return a.length === b.length && a.every((e, i) => keyOf(e) === keyOf(b[i]));
+}
+/** Move the entry with `key` by one priority slot; boundary or missing = identity. */
+function reorderKeyed(chain, key, delta, keyOf) {
+	const from = chain.findIndex((e) => keyOf(e) === key);
+	const to = from + delta;
+	if (from < 0 || to < 0 || to >= chain.length) return chain;
+	const next = [...chain];
+	const [entry] = next.splice(from, 1);
+	next.splice(to, 0, entry);
+	return next;
+}
+function toggleChainEntry(chain, entry) {
+	return toggleKeyed(chain, entry, chainEntryKey);
+}
+function pickChainPrimary(chain, entry) {
+	return pickPrimaryKeyed(chain, entry, chainEntryKey);
+}
+/** 1-based chain position of a provider+model pair, or `null` when not in the chain. */
+function chainPositionOf(chain, provider, model) {
+	return positionKeyed(chain, chainEntryKey({
+		provider,
+		model
+	}), chainEntryKey);
+}
+function chainsEqual(a, b) {
+	return chainsEqualKeyed(a, b, chainEntryKey);
+}
+/**
+* Did the SET of provider keys change between two chains? The agent is
+* built with one provider instance per distinct chain key, so a set
+* change requires a session re-activation (rebuild); a pure model /
+* order change within the same providers does not.
+*/
+function providerKeySetChanged(prev, next) {
+	const prevKeys = new Set(prev.map((e) => e.provider));
+	const nextKeys = new Set(next.map((e) => e.provider));
+	if (prevKeys.size !== nextKeys.size) return true;
+	for (const k of nextKeys) if (!prevKeys.has(k)) return true;
+	return false;
+}
+/**
+* Assemble the `agent.run` `model` option from a chain.
+*
+* - Single-entry chain → the bare model id string (byte-identical to the
+*   pre-chain behavior).
+* - Multi-entry chain → pinned `{ provider, model }` targets, where
+*   `provider` is the runtime `Provider.name` resolved via
+*   `providerNameFor` (chain entries carry chat-level `ProviderKey`s,
+*   which need not equal the instance names the agent loop matches on).
+*
+* Throws only on an empty chain — a programmer error, since chains
+* always carry a primary. Stale or unresolvable entries degrade
+* defensively instead (never throw, never produce an entry the agent
+* would reject):
+* - Entries whose key has no resolvable name (provider not constructed
+*   into the current agent) are dropped.
+* - If the PRIMARY itself doesn't resolve, or fewer than two entries
+*   survive, fall back to the bare primary model string.
+*
+* `contextWindowFor` (optional) stamps each target with its model's
+* context window from the host catalog, so the loop re-bases the
+* auto-compact trigger when a fallback advances onto it (the host's
+* explicit window is sized for the PRIMARY otherwise).
+*/
+function buildRunModel(chain, providerNameFor, contextWindowFor) {
+	const primary = chain[0];
+	if (!primary) throw new Error("buildRunModel: chain must not be empty");
+	if (chain.length === 1 || providerNameFor(primary.provider) === void 0) return primary.model;
+	const resolved = [];
+	for (const entry of chain) {
+		const name = providerNameFor(entry.provider);
+		if (name === void 0) continue;
+		const contextWindow = contextWindowFor?.(entry);
+		resolved.push({
+			provider: name,
+			model: entry.model,
+			...typeof contextWindow === "number" && contextWindow > 0 ? { contextWindow } : {}
+		});
+	}
+	return resolved.length > 1 ? resolved : primary.model;
+}
+/**
+* Validate a persisted chain read back from `state.json`. The state file
+* is user-editable JSON, so the value can be arbitrarily malformed —
+* return only the well-shaped `{ provider, model }` entries (both
+* non-empty strings), or `[]` for anything else. Never throws.
+*/
+function sanitizeModelChain(value) {
+	if (!Array.isArray(value)) return [];
+	const entries = [];
+	for (const item of value) {
+		if (typeof item !== "object" || item === null || !("provider" in item) || !("model" in item)) continue;
+		const { provider, model } = item;
+		if (typeof provider === "string" && provider.length > 0 && typeof model === "string" && model.length > 0) entries.push({
+			provider,
+			model
+		});
+	}
+	return entries;
+}
+/**
+* Restore the fallback tail of a persisted chain for a resolved primary
+* pair. Returns entries 1+ only when the persisted chain's entry 0
+* matches `primary` — a divergent chain belongs to a different selection
+* (e.g. a `--model` launch override) and silently attaching it would
+* surprise. Entries whose provider isn't registered, entries equal to
+* the primary, and exact duplicates drop. Accepts the raw persisted
+* value (`state.json` is user-editable) — shape validation included.
+*/
+function restoreChainFallbacks(saved, primary, isRegistered) {
+	const chain = sanitizeModelChain(saved);
+	const head = chain[0];
+	if (chain.length < 2 || !head || head.provider !== primary.provider || head.model !== primary.model) return [];
+	return filterChainFallbacks(chain.slice(1), primary, isRegistered);
+}
+/**
+* Filter candidate fallback entries against a primary pair, preserving
+* picked order: entries whose provider `isAvailable` rejects, entries
+* equal to the primary, and exact duplicates drop. Shared by the
+* picker's apply path (live-auth availability) and persisted-chain
+* restore (registry availability).
+*/
+function filterChainFallbacks(entries, primary, isAvailable) {
+	const fallbacks = [];
+	for (const entry of entries) {
+		if (!isAvailable(entry.provider)) continue;
+		if (entry.provider === primary.provider && entry.model === primary.model) continue;
+		if (fallbacks.some((f) => f.provider === entry.provider && f.model === entry.model)) continue;
+		fallbacks.push({
+			provider: entry.provider,
+			model: entry.model
+		});
+	}
+	return fallbacks;
+}
+/**
+* What of a model pick a window remembers as its default (`lastModelChain`:
+* the next new session's model, the next launch's). One rule for the TUI and
+* the GUI. A session on a server runs with the server's credentials, so its
+* pickers list the server's providers: a pick there is remembered only when
+* this computer can run its primary too (a provider only the server has
+* would leave the next local session without a usable model), and the
+* fallbacks this computer can't run are dropped. A pick on This computer is
+* remembered as made. `null`: nothing to remember.
+*/
+function rememberableChain(chain, providerOf, scope) {
+	const primary = chain[0];
+	if (primary === void 0) return null;
+	if (!scope.onServer) return [...chain];
+	if (!scope.canRunHere(providerOf(primary))) return null;
+	return chain.filter((entry) => scope.canRunHere(providerOf(entry)));
+}
+//#endregion
+//#region src/chat/turn-operations.ts
+/**
+* Fork — keep every turn up to and including `turnId`, then strip any
+* `tool_call` blocks left without a matching `tool_result` in the slice.
+*
+* Semantics:
+*   - Include the selected turn ("branch from HERE" mental model — the
+*     user wants the selected message to be the latest in the fork).
+*   - If the selected turn is an assistant turn with unresolved
+*     `tool_call` blocks (their `tool_result`s live in turns AFTER the
+*     slice), strip those calls. Otherwise the fork would post an
+*     assistant turn with no matching tool results, breaking the next
+*     provider call.
+*   - Drop turns that become empty (all blocks stripped).
+*
+* Returns `null` when `turnId` doesn't exist in `turns` — caller should
+* surface a "turn not found" error rather than silently no-op.
+*/
+function truncateTurnsAt(turns, turnId) {
+	const idx = turns.findIndex((t) => t.id === turnId);
+	if (idx === -1) return null;
+	return stripOrphanToolBlocks(turns.slice(0, idx + 1));
+}
+/**
+* Delete — remove the turn with `turnId` and any tool blocks left
+* orphaned by the removal. Returns `null` when `turnId` doesn't exist.
+*
+* Strategy:
+*   1. Drop the target turn.
+*   2. Scan the remaining turns for `tool_call`s without a matching
+*      `tool_result` (orphaned by removing the user turn that carried
+*      the result), and `tool_result`s without a matching `tool_call`
+*      (orphaned by removing the assistant turn that issued the call).
+*      Strip both sides.
+*   3. Drop turns whose content is now empty.
+*
+* This guarantees the resulting history is protocol-clean — a follow-up
+* `agent.run()` against the modified session can post turns without the
+* provider rejecting the history.
+*/
+function deleteTurnSafely(turns, turnId) {
+	const idx = turns.findIndex((t) => t.id === turnId);
+	if (idx === -1) return null;
+	return stripOrphanToolBlocks([...turns.slice(0, idx), ...turns.slice(idx + 1)]);
+}
+/**
+* Walk a turn list and remove any tool blocks whose counterpart is
+* missing. Drops turns left empty. Used by `truncateTurnsAt` (which can
+* leave `tool_call`s orphaned when their results are past the cut) and
+* `deleteTurnSafely` (which can orphan either side of a pair).
+*
+* Pure / total: returns a new array; never throws.
+*/
+function stripOrphanToolBlocks(turns) {
+	const callIds = /* @__PURE__ */ new Set();
+	const resultIds = /* @__PURE__ */ new Set();
+	for (const turn of turns) for (const block of turn.content) if (block.type === "tool_call") callIds.add(block.id);
+	else if (block.type === "tool_result") resultIds.add(block.callId);
+	const result = [];
+	for (const turn of turns) {
+		const filtered = [];
+		for (const block of turn.content) {
+			if (block.type === "tool_call") {
+				if (!resultIds.has(block.id)) continue;
+			} else if (block.type === "tool_result") {
+				if (!callIds.has(block.callId)) continue;
+			}
+			filtered.push(block);
+		}
+		if (filtered.length === 0) continue;
+		result.push(filtered.length === turn.content.length ? turn : {
+			...turn,
+			content: filtered
+		});
+	}
+	return result;
+}
+/**
+* Replace a turn's text with `newText`, keeping every non-text block (tool
+* calls, tool results, thinking, images) where it was. All text blocks
+* collapse into one, placed where the first text block was; an empty or
+* whitespace-only `newText` removes the text and keeps the rest.
+*
+* Returns `null` when the turn is missing or has no text to edit, so callers
+* can report it. Untouched turns keep their identity (a store can rewrite
+* only the edited row).
+*/
+function replaceTurnTextBlocks(turns, turnId, newText) {
+	const idx = turns.findIndex((turn) => turn.id === turnId);
+	if (idx === -1) return null;
+	const turn = turns[idx];
+	const firstTextIdx = turn.content.findIndex((block) => block.type === "text");
+	if (firstTextIdx === -1) return null;
+	const content = turn.content.filter((block) => block.type !== "text");
+	if (newText.trim()) content.splice(Math.min(firstTextIdx, content.length), 0, {
+		type: "text",
+		text: newText
+	});
+	const next = turns.slice();
+	next[idx] = {
+		...turn,
+		content
+	};
+	return next;
+}
+/**
+* Serialize a turn's content to a clean text representation suited for
+* the clipboard. Joins text + thinking blocks verbatim; tool calls and
+* tool results get bracketed labels so the user can paste a readable
+* record of what happened without losing structure.
+*
+* Empty turns return `''`.
+*/
+function turnAsText(turn) {
+	const parts = [];
+	for (const block of turn.content) if (block.type === "text" && block.text.trim()) parts.push(block.text);
+	else if (block.type === "thinking" && block.text.trim()) parts.push(`[thinking]\n${block.text}`);
+	else if (block.type === "tool_call") parts.push(`[tool call · ${block.name}]\n${stringifyArgs(block.input)}`);
+	else if (block.type === "tool_result") parts.push(`[tool result]\n${typeof block.output === "string" ? block.output : JSON.stringify(block.output, null, 2)}`);
+	else if (block.type === "compact-summary") parts.push(`[compaction summary · ${block.replacesTurnIds.length} turn${block.replacesTurnIds.length === 1 ? "" : "s"}]\n${block.summary}`);
+	return parts.join("\n\n");
+}
+function stringifyArgs(input) {
+	try {
+		return JSON.stringify(input, null, 2);
+	} catch {
+		return String(input);
+	}
+}
+/**
+* Count turns before / after the one identified by `turnId` in the
+* given list. Returns `null` when the id is missing. Used to label the
+* turn-details modal with `N before · M after`.
+*/
+function countNeighbors(turnIds, turnId) {
+	const idx = turnIds.indexOf(turnId);
+	if (idx === -1) return null;
+	return {
+		before: idx,
+		after: turnIds.length - 1 - idx
+	};
+}
+//#endregion
+export { reorderKeyed as _, turnAsText as a, toggleChainEntry as b, chainPositionOf as c, filterChainFallbacks as d, pickChainPrimary as f, rememberableChain as g, providerKeySetChanged as h, truncateTurnsAt as i, chainsEqual as l, positionKeyed as m, deleteTurnSafely as n, buildRunModel as o, pickPrimaryKeyed as p, replaceTurnTextBlocks as r, chainEntryKey as s, countNeighbors as t, chainsEqualKeyed as u, restoreChainFallbacks as v, toggleKeyed as x, sanitizeModelChain as y };
+
+//# sourceMappingURL=turn-operations-B8sokwi5.js.map

package/dist/turn-operations-B8sokwi5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-operations-B8sokwi5.js","names":[],"sources":["../src/chat/model-chain.ts","../src/chat/turn-operations.ts"],"sourcesContent":["/**\n * Model fallback chains — pure helpers for the ordered multi-model picker.\n *\n * A chain is an ordered list of provider+model pairs: entry 0 is the\n * PRIMARY (drives provider swap, effort, options, context-window display),\n * entries 1+ are run-level fallbacks forwarded to `agent.run` as pinned\n * `{ provider, model }` targets (see `AgentRunOptions.model`).\n *\n * Renderer-agnostic and side-effect free, mirroring `model-catalog.ts`:\n * the TUI picker drives toggling/numbering through these, and the chat\n * host uses them for persistence validation and run-option assembly.\n */\n\nimport type { ProviderKey } from './auth'\n\n/** One provider+model pair in a fallback chain. */\nexport interface ModelChainEntry {\n  provider: ProviderKey\n  model: string\n}\n\n/** Identity of a chain entry — the pair, not object identity. */\nexport function chainEntryKey(entry: ModelChainEntry): string {\n  return `${entry.provider}\\u0000${entry.model}`\n}\n\n// ---------------------------------------------------------------------------\n// Keyed generics — the ONE implementation of each chain edit.\n//\n// Both clients hold chains, but in different shapes: the TUI in\n// `ModelChainEntry` (`provider`/`model`), the GUI in its wire\n// `ModelFallbackRef` (`providerKey`/`modelId`). Before this, the GUI carried\n// five hand-mirrored copies of these functions on its own shape, which is how\n// a picker gesture could diverge between surfaces. The generics take the key\n// function and know nothing about the shape; the `ModelChainEntry` wrappers\n// below keep the existing names for existing callers.\n// ---------------------------------------------------------------------------\n\n/** Toggle `entry`: absent → appended, present → removed. Pure. */\nexport function toggleKeyed<T>(chain: readonly T[], entry: T, keyOf: (e: T) => string): T[] {\n  const key = keyOf(entry)\n  const idx = chain.findIndex(e => keyOf(e) === key)\n  if (idx === -1)\n    return [...chain, entry]\n  return [...chain.slice(0, idx), ...chain.slice(idx + 1)]\n}\n\n/**\n * Make `entry` the primary (position 0), keeping the rest in order. Inserts\n * when absent, promotes when present; no-op when it already leads.\n *\n * This is `↵` in the picker. It exists because toggling APPENDS: with a chain\n * of `[current]`, toggling a new model produced `[current, new]` — the pick\n * became a fallback and the active model never changed. \"Highlight and ↵\"\n * means \"use this one\", so that gesture promotes; building a fallback list is\n * the secondary gesture (`⇥`) and keeps toggle semantics.\n */\nexport function pickPrimaryKeyed<T>(chain: readonly T[], entry: T, keyOf: (e: T) => string): T[] {\n  const key = keyOf(entry)\n  return [entry, ...chain.filter(e => keyOf(e) !== key)]\n}\n\n/** 1-based position of `key` in the chain, or `null` when absent. */\nexport function positionKeyed<T>(chain: readonly T[], key: string, keyOf: (e: T) => string): number | null {\n  const idx = chain.findIndex(e => keyOf(e) === key)\n  return idx === -1 ? null : idx + 1\n}\n\n/** Same entries in the same order. */\nexport function chainsEqualKeyed<T>(a: readonly T[], b: readonly T[], keyOf: (e: T) => string): boolean {\n  return a.length === b.length && a.every((e, i) => keyOf(e) === keyOf(b[i]!))\n}\n\n/** Move the entry with `key` by one priority slot; boundary or missing = identity. */\nexport function reorderKeyed<T>(chain: readonly T[], key: string, delta: -1 | 1, keyOf: (e: T) => string): readonly T[] {\n  const from = chain.findIndex(e => keyOf(e) === key)\n  const to = from + delta\n  if (from < 0 || to < 0 || to >= chain.length)\n    return chain\n  const next = [...chain]\n  const [entry] = next.splice(from, 1)\n  next.splice(to, 0, entry as T)\n  return next\n}\n\n// ---------------------------------------------------------------------------\n// `ModelChainEntry` wrappers — existing public names, unchanged contracts.\n// ---------------------------------------------------------------------------\n\nexport function toggleChainEntry(chain: readonly ModelChainEntry[], entry: ModelChainEntry): ModelChainEntry[] {\n  return toggleKeyed(chain, entry, chainEntryKey)\n}\n\nexport function pickChainPrimary(chain: readonly ModelChainEntry[], entry: ModelChainEntry): ModelChainEntry[] {\n  return pickPrimaryKeyed(chain, entry, chainEntryKey)\n}\n\n/** 1-based chain position of a provider+model pair, or `null` when not in the chain. */\nexport function chainPositionOf(chain: readonly ModelChainEntry[], provider: ProviderKey, model: string): number | null {\n  return positionKeyed(chain, chainEntryKey({ provider, model }), chainEntryKey)\n}\n\nexport function chainsEqual(a: readonly ModelChainEntry[], b: readonly ModelChainEntry[]): boolean {\n  return chainsEqualKeyed(a, b, chainEntryKey)\n}\n\n/**\n * Did the SET of provider keys change between two chains? The agent is\n * built with one provider instance per distinct chain key, so a set\n * change requires a session re-activation (rebuild); a pure model /\n * order change within the same providers does not.\n */\nexport function providerKeySetChanged(\n  prev: readonly ModelChainEntry[],\n  next: readonly ModelChainEntry[],\n): boolean {\n  const prevKeys = new Set(prev.map(e => e.provider))\n  const nextKeys = new Set(next.map(e => e.provider))\n  if (prevKeys.size !== nextKeys.size)\n    return true\n  for (const k of nextKeys) {\n    if (!prevKeys.has(k))\n      return true\n  }\n  return false\n}\n\n/**\n * Assemble the `agent.run` `model` option from a chain.\n *\n * - Single-entry chain → the bare model id string (byte-identical to the\n *   pre-chain behavior).\n * - Multi-entry chain → pinned `{ provider, model }` targets, where\n *   `provider` is the runtime `Provider.name` resolved via\n *   `providerNameFor` (chain entries carry chat-level `ProviderKey`s,\n *   which need not equal the instance names the agent loop matches on).\n *\n * Throws only on an empty chain — a programmer error, since chains\n * always carry a primary. Stale or unresolvable entries degrade\n * defensively instead (never throw, never produce an entry the agent\n * would reject):\n * - Entries whose key has no resolvable name (provider not constructed\n *   into the current agent) are dropped.\n * - If the PRIMARY itself doesn't resolve, or fewer than two entries\n *   survive, fall back to the bare primary model string.\n *\n * `contextWindowFor` (optional) stamps each target with its model's\n * context window from the host catalog, so the loop re-bases the\n * auto-compact trigger when a fallback advances onto it (the host's\n * explicit window is sized for the PRIMARY otherwise).\n */\nexport function buildRunModel(\n  chain: readonly ModelChainEntry[],\n  providerNameFor: (key: ProviderKey) => string | undefined,\n  contextWindowFor?: (entry: ModelChainEntry) => number | undefined,\n): string | Array<{ provider: string, model: string, contextWindow?: number }> {\n  const primary = chain[0]\n  if (!primary)\n    throw new Error('buildRunModel: chain must not be empty')\n  if (chain.length === 1 || providerNameFor(primary.provider) === undefined)\n    return primary.model\n  const resolved: Array<{ provider: string, model: string, contextWindow?: number }> = []\n  for (const entry of chain) {\n    const name = providerNameFor(entry.provider)\n    if (name === undefined)\n      continue\n    const contextWindow = contextWindowFor?.(entry)\n    resolved.push({\n      provider: name,\n      model: entry.model,\n      ...(typeof contextWindow === 'number' && contextWindow > 0 ? { contextWindow } : {}),\n    })\n  }\n  return resolved.length > 1 ? resolved : primary.model\n}\n\n/**\n * Validate a persisted chain read back from `state.json`. The state file\n * is user-editable JSON, so the value can be arbitrarily malformed —\n * return only the well-shaped `{ provider, model }` entries (both\n * non-empty strings), or `[]` for anything else. Never throws.\n */\nexport function sanitizeModelChain(value: unknown): ModelChainEntry[] {\n  if (!Array.isArray(value))\n    return []\n  const entries: ModelChainEntry[] = []\n  for (const item of value) {\n    if (typeof item !== 'object' || item === null || !('provider' in item) || !('model' in item))\n      continue\n    const { provider, model } = item\n    if (typeof provider === 'string' && provider.length > 0 && typeof model === 'string' && model.length > 0)\n      entries.push({ provider, model })\n  }\n  return entries\n}\n\n/**\n * Restore the fallback tail of a persisted chain for a resolved primary\n * pair. Returns entries 1+ only when the persisted chain's entry 0\n * matches `primary` — a divergent chain belongs to a different selection\n * (e.g. a `--model` launch override) and silently attaching it would\n * surprise. Entries whose provider isn't registered, entries equal to\n * the primary, and exact duplicates drop. Accepts the raw persisted\n * value (`state.json` is user-editable) — shape validation included.\n */\nexport function restoreChainFallbacks(\n  saved: unknown,\n  primary: ModelChainEntry,\n  isRegistered: (key: ProviderKey) => boolean,\n): ModelChainEntry[] {\n  const chain = sanitizeModelChain(saved)\n  const head = chain[0]\n  if (chain.length < 2 || !head || head.provider !== primary.provider || head.model !== primary.model)\n    return []\n  return filterChainFallbacks(chain.slice(1), primary, isRegistered)\n}\n\n/**\n * Filter candidate fallback entries against a primary pair, preserving\n * picked order: entries whose provider `isAvailable` rejects, entries\n * equal to the primary, and exact duplicates drop. Shared by the\n * picker's apply path (live-auth availability) and persisted-chain\n * restore (registry availability).\n */\nexport function filterChainFallbacks(\n  entries: readonly ModelChainEntry[],\n  primary: ModelChainEntry,\n  isAvailable: (key: ProviderKey) => boolean,\n): ModelChainEntry[] {\n  const fallbacks: ModelChainEntry[] = []\n  for (const entry of entries) {\n    if (!isAvailable(entry.provider))\n      continue\n    if (entry.provider === primary.provider && entry.model === primary.model)\n      continue\n    if (fallbacks.some(f => f.provider === entry.provider && f.model === entry.model))\n      continue\n    fallbacks.push({ provider: entry.provider, model: entry.model })\n  }\n  return fallbacks\n}\n\n/**\n * What of a model pick a window remembers as its default (`lastModelChain`:\n * the next new session's model, the next launch's). One rule for the TUI and\n * the GUI. A session on a server runs with the server's credentials, so its\n * pickers list the server's providers: a pick there is remembered only when\n * this computer can run its primary too (a provider only the server has\n * would leave the next local session without a usable model), and the\n * fallbacks this computer can't run are dropped. A pick on This computer is\n * remembered as made. `null`: nothing to remember.\n */\nexport function rememberableChain<T>(\n  chain: readonly T[],\n  providerOf: (entry: T) => string,\n  scope: { onServer: boolean, canRunHere: (providerKey: string) => boolean },\n): T[] | null {\n  const primary = chain[0]\n  if (primary === undefined)\n    return null\n  if (!scope.onServer)\n    return [...chain]\n  if (!scope.canRunHere(providerOf(primary)))\n    return null\n  return chain.filter(entry => scope.canRunHere(providerOf(entry)))\n}\n","/**\n * Pure transforms on `SessionTurn[]` used by the TUI's turn-selection\n * modal actions (fork / delete / copy). Each helper is renderer- and\n * store-agnostic so it composes the same in TUI, SDK, or test code.\n *\n * Tool-call protocol invariant the helpers preserve:\n *\n *   Every `tool_call` block emitted by an assistant turn MUST be matched\n *   by a `tool_result` block (same `callId`) in a later turn before the\n *   next assistant turn. Providers reject histories that violate this —\n *   so any operation that mutates the turn list must either keep pairs\n *   intact or strip both sides.\n */\n\nimport type { SessionContentBlock, SessionTurn } from '../types'\n\n/**\n * Fork — keep every turn up to and including `turnId`, then strip any\n * `tool_call` blocks left without a matching `tool_result` in the slice.\n *\n * Semantics:\n *   - Include the selected turn (\"branch from HERE\" mental model — the\n *     user wants the selected message to be the latest in the fork).\n *   - If the selected turn is an assistant turn with unresolved\n *     `tool_call` blocks (their `tool_result`s live in turns AFTER the\n *     slice), strip those calls. Otherwise the fork would post an\n *     assistant turn with no matching tool results, breaking the next\n *     provider call.\n *   - Drop turns that become empty (all blocks stripped).\n *\n * Returns `null` when `turnId` doesn't exist in `turns` — caller should\n * surface a \"turn not found\" error rather than silently no-op.\n */\nexport function truncateTurnsAt(turns: readonly SessionTurn[], turnId: string): SessionTurn[] | null {\n  const idx = turns.findIndex(t => t.id === turnId)\n  if (idx === -1)\n    return null\n  const slice = turns.slice(0, idx + 1)\n  return stripOrphanToolBlocks(slice)\n}\n\n/**\n * Delete — remove the turn with `turnId` and any tool blocks left\n * orphaned by the removal. Returns `null` when `turnId` doesn't exist.\n *\n * Strategy:\n *   1. Drop the target turn.\n *   2. Scan the remaining turns for `tool_call`s without a matching\n *      `tool_result` (orphaned by removing the user turn that carried\n *      the result), and `tool_result`s without a matching `tool_call`\n *      (orphaned by removing the assistant turn that issued the call).\n *      Strip both sides.\n *   3. Drop turns whose content is now empty.\n *\n * This guarantees the resulting history is protocol-clean — a follow-up\n * `agent.run()` against the modified session can post turns without the\n * provider rejecting the history.\n */\nexport function deleteTurnSafely(turns: readonly SessionTurn[], turnId: string): SessionTurn[] | null {\n  const idx = turns.findIndex(t => t.id === turnId)\n  if (idx === -1)\n    return null\n  const without = [...turns.slice(0, idx), ...turns.slice(idx + 1)]\n  return stripOrphanToolBlocks(without)\n}\n\n/**\n * Walk a turn list and remove any tool blocks whose counterpart is\n * missing. Drops turns left empty. Used by `truncateTurnsAt` (which can\n * leave `tool_call`s orphaned when their results are past the cut) and\n * `deleteTurnSafely` (which can orphan either side of a pair).\n *\n * Pure / total: returns a new array; never throws.\n */\nfunction stripOrphanToolBlocks(turns: readonly SessionTurn[]): SessionTurn[] {\n  const callIds = new Set<string>()\n  const resultIds = new Set<string>()\n  for (const turn of turns) {\n    for (const block of turn.content) {\n      if (block.type === 'tool_call')\n        callIds.add(block.id)\n      else if (block.type === 'tool_result')\n        resultIds.add(block.callId)\n    }\n  }\n  const result: SessionTurn[] = []\n  for (const turn of turns) {\n    const filtered: SessionContentBlock[] = []\n    for (const block of turn.content) {\n      if (block.type === 'tool_call') {\n        if (!resultIds.has(block.id))\n          continue // call lost its result\n      }\n      else if (block.type === 'tool_result') {\n        if (!callIds.has(block.callId))\n          continue // result lost its call\n      }\n      filtered.push(block)\n    }\n    if (filtered.length === 0)\n      continue // turn is now empty — drop it\n    result.push(filtered.length === turn.content.length ? turn : { ...turn, content: filtered })\n  }\n  return result\n}\n\n/**\n * Replace a turn's text with `newText`, keeping every non-text block (tool\n * calls, tool results, thinking, images) where it was. All text blocks\n * collapse into one, placed where the first text block was; an empty or\n * whitespace-only `newText` removes the text and keeps the rest.\n *\n * Returns `null` when the turn is missing or has no text to edit, so callers\n * can report it. Untouched turns keep their identity (a store can rewrite\n * only the edited row).\n */\nexport function replaceTurnTextBlocks(turns: readonly SessionTurn[], turnId: string, newText: string): SessionTurn[] | null {\n  const idx = turns.findIndex(turn => turn.id === turnId)\n  if (idx === -1)\n    return null\n  const turn = turns[idx]!\n  const firstTextIdx = turn.content.findIndex(block => block.type === 'text')\n  if (firstTextIdx === -1)\n    return null\n  const content: SessionContentBlock[] = turn.content.filter(block => block.type !== 'text')\n  if (newText.trim())\n    content.splice(Math.min(firstTextIdx, content.length), 0, { type: 'text', text: newText })\n  const next = turns.slice()\n  next[idx] = { ...turn, content }\n  return next\n}\n\n/**\n * Serialize a turn's content to a clean text representation suited for\n * the clipboard. Joins text + thinking blocks verbatim; tool calls and\n * tool results get bracketed labels so the user can paste a readable\n * record of what happened without losing structure.\n *\n * Empty turns return `''`.\n */\nexport function turnAsText(turn: SessionTurn): string {\n  const parts: string[] = []\n  for (const block of turn.content) {\n    if (block.type === 'text' && block.text.trim())\n      parts.push(block.text)\n    else if (block.type === 'thinking' && block.text.trim())\n      parts.push(`[thinking]\\n${block.text}`)\n    else if (block.type === 'tool_call')\n      parts.push(`[tool call · ${block.name}]\\n${stringifyArgs(block.input)}`)\n    else if (block.type === 'tool_result')\n      parts.push(`[tool result]\\n${typeof block.output === 'string' ? block.output : JSON.stringify(block.output, null, 2)}`)\n    else if (block.type === 'compact-summary')\n      parts.push(`[compaction summary · ${block.replacesTurnIds.length} turn${block.replacesTurnIds.length === 1 ? '' : 's'}]\\n${block.summary}`)\n  }\n  return parts.join('\\n\\n')\n}\n\nfunction stringifyArgs(input: Record<string, unknown>): string {\n  try {\n    return JSON.stringify(input, null, 2)\n  }\n  catch {\n    return String(input)\n  }\n}\n\n/**\n * Count turns before / after the one identified by `turnId` in the\n * given list. Returns `null` when the id is missing. Used to label the\n * turn-details modal with `N before · M after`.\n */\nexport function countNeighbors(\n  turnIds: readonly string[],\n  turnId: string,\n): { before: number, after: number } | null {\n  const idx = turnIds.indexOf(turnId)\n  if (idx === -1)\n    return null\n  return { before: idx, after: turnIds.length - 1 - idx }\n}\n"],"mappings":"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"}