zidane 7.2.5 → 8.0.4

package/dist/project-root-B8zADr4o.js

@@ -0,0 +1,167 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+//#region src/chat/project-root.ts
+/**
+* Git location — two different questions with two different answers once
+* linked worktrees exist:
+*
+*   - **Checkout root** ({@link findGitRoot}): the working tree `cwd` sits
+*     in — where its files are. Discovery reads here (`AGENTS.md`, skills,
+*     MCP configs, file completion): a worktree on another branch has its
+*     own copies, and those are the ones the agent works against.
+*   - **Project root** ({@link findProjectRoot} / {@link projectRootOf}):
+*     which project a session BELONGS to — the main checkout, for a linked
+*     worktree. Identity keys here: `SessionData.projectRoot`, session
+*     lists and grouping, the safelist, artifact scope, the project DB.
+*     Every worktree of a repo is one project.
+*
+* For a plain checkout the two are the same directory.
+*
+* Why parent-walk + file reads over `git rev-parse`:
+*
+*   - Zero dependencies (no shell-out, no git binary requirement,
+*     works even when `git` is missing from `PATH`).
+*   - Pure-sync, deterministic, easy to test against tmp dirs.
+*   - Equally fast in practice — most lookups are a single `existsSync`.
+*
+* Recognizes `.git` as either:
+*
+*   - A directory (standard repo layout).
+*   - A file containing `gitdir: …` (worktrees + submodules).
+*
+* Bare repos (no working tree) are intentionally NOT detected here —
+* the TUI's data dir contract is "project working tree", and a bare
+* repo has no working files to scope sessions against.
+*/
+/**
+* Walk parents of `cwd` looking for a `.git` entry. Returns the
+* absolute path of the directory containing `.git` — the CHECKOUT root
+* (a linked worktree's own dir, not its main checkout) — or `null` when
+* no git repo is found above `cwd`.
+*
+* Stops at the filesystem root (`/`) — no infinite loop on `dirname`'s
+* idempotent root case (`dirname('/')` returns `/`).
+*/
+function findGitRoot(cwd = process.cwd()) {
+	let dir = resolve(cwd);
+	for (let depth = 0; depth < 64; depth++) {
+		if (hasGitMarker(dir)) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+	return null;
+}
+/**
+* The main checkout a LINKED WORKTREE belongs to, or `null` when
+* `checkoutRoot` is not one. Does not walk: `checkoutRoot` must be a
+* checkout root (what {@link findGitRoot} returns).
+*
+* A linked worktree's `.git` is a file (`gitdir: <main>/.git/worktrees/<name>`)
+* and that gitdir holds a `commondir` file pointing back at the shared
+* `<main>/.git`. Everything else resolves to `null` and stays its own
+* project:
+*
+*   - a regular checkout (`.git` is a directory);
+*   - a submodule (its gitdir has no `commondir` — a submodule IS a
+*     separate repo);
+*   - a worktree of a bare repo or of a `--separate-git-dir` repo (the
+*     common dir isn't a `.git` inside a working tree, so there is no main
+*     checkout to belong to);
+*   - anything unreadable or malformed.
+*/
+function mainCheckoutRoot(checkoutRoot) {
+	const root = resolve(checkoutRoot);
+	const gitdir = readGitdirPointer(resolve(root, ".git"), root);
+	if (!gitdir) return null;
+	const commondir = readTrimmed(resolve(gitdir, "commondir"));
+	if (!commondir) return null;
+	const commonDir = resolve(gitdir, commondir);
+	if (basename(commonDir) !== ".git" || !isDirectory(commonDir)) return null;
+	const main = dirname(commonDir);
+	return main === root ? null : main;
+}
+/**
+* The project `cwd` belongs to: the main checkout for a linked worktree,
+* the checkout root otherwise, `null` outside git. See the module header
+* for when to use this vs {@link findGitRoot}.
+*/
+function findProjectRoot(cwd = process.cwd()) {
+	const checkout = findGitRoot(cwd);
+	return checkout ? mainCheckoutRoot(checkout) ?? checkout : null;
+}
+/**
+* {@link findProjectRoot} with the historical fallback: outside git, a
+* directory is its own project. The value to stamp as
+* `SessionData.projectRoot` and to key per-project state on.
+*/
+function projectRootOf(cwd) {
+	return findProjectRoot(cwd) ?? cwd;
+}
+/**
+* For persisted project roots that predate worktree-aware identity: the
+* `{ from, to }` pairs where a stored root is a linked worktree's checkout
+* root and should be its main checkout's. Only exact linked-worktree roots
+* remap — a plain directory that later ended up inside some repo keeps its
+* own identity (no parent walk here). Stores apply the pairs as a bulk
+* column update at open; idempotent, so a row reverted by a stale
+* full-document save converges on the next open.
+*/
+function planWorktreeProjectRootRemaps(roots) {
+	const remaps = [];
+	for (const from of new Set(roots)) {
+		if (!from) continue;
+		const to = mainCheckoutRoot(from);
+		if (to) remaps.push({
+			from,
+			to
+		});
+	}
+	return remaps;
+}
+/**
+* `.git` exists as a directory (standard repo) OR as a file containing
+* a `gitdir:` pointer (worktree / submodule). Tolerant on stat failures
+* — a permission error on a parent directory shouldn't crash the walk.
+*/
+function hasGitMarker(dir) {
+	const candidate = resolve(dir, ".git");
+	try {
+		if (!existsSync(candidate)) return false;
+		const stat = statSync(candidate);
+		return stat.isDirectory() || stat.isFile();
+	} catch {
+		return false;
+	}
+}
+/** Absolute gitdir from a `.git` FILE (`gitdir: <path>`, relative to `root`), else `null`. */
+function readGitdirPointer(dotGit, root) {
+	try {
+		if (!statSync(dotGit).isFile()) return null;
+	} catch {
+		return null;
+	}
+	const text = readTrimmed(dotGit);
+	if (!text?.startsWith("gitdir:")) return null;
+	const pointer = text.slice(7).split("\n", 1)[0].trim();
+	return pointer ? resolve(root, pointer) : null;
+}
+function readTrimmed(path) {
+	try {
+		const text = readFileSync(path, "utf8").trim();
+		return text.length > 0 ? text : null;
+	} catch {
+		return null;
+	}
+}
+function isDirectory(path) {
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { projectRootOf as a, planWorktreeProjectRootRemaps as i, findProjectRoot as n, mainCheckoutRoot as r, findGitRoot as t };
+
+//# sourceMappingURL=project-root-B8zADr4o.js.map

package/dist/project-root-B8zADr4o.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-root-B8zADr4o.js","names":[],"sources":["../src/chat/project-root.ts"],"sourcesContent":["/**\n * Git location — two different questions with two different answers once\n * linked worktrees exist:\n *\n *   - **Checkout root** ({@link findGitRoot}): the working tree `cwd` sits\n *     in — where its files are. Discovery reads here (`AGENTS.md`, skills,\n *     MCP configs, file completion): a worktree on another branch has its\n *     own copies, and those are the ones the agent works against.\n *   - **Project root** ({@link findProjectRoot} / {@link projectRootOf}):\n *     which project a session BELONGS to — the main checkout, for a linked\n *     worktree. Identity keys here: `SessionData.projectRoot`, session\n *     lists and grouping, the safelist, artifact scope, the project DB.\n *     Every worktree of a repo is one project.\n *\n * For a plain checkout the two are the same directory.\n *\n * Why parent-walk + file reads over `git rev-parse`:\n *\n *   - Zero dependencies (no shell-out, no git binary requirement,\n *     works even when `git` is missing from `PATH`).\n *   - Pure-sync, deterministic, easy to test against tmp dirs.\n *   - Equally fast in practice — most lookups are a single `existsSync`.\n *\n * Recognizes `.git` as either:\n *\n *   - A directory (standard repo layout).\n *   - A file containing `gitdir: …` (worktrees + submodules).\n *\n * Bare repos (no working tree) are intentionally NOT detected here —\n * the TUI's data dir contract is \"project working tree\", and a bare\n * repo has no working files to scope sessions against.\n */\n\nimport { existsSync, readFileSync, statSync } from 'node:fs'\nimport { basename, dirname, resolve } from 'node:path'\n\n/**\n * Walk parents of `cwd` looking for a `.git` entry. Returns the\n * absolute path of the directory containing `.git` — the CHECKOUT root\n * (a linked worktree's own dir, not its main checkout) — or `null` when\n * no git repo is found above `cwd`.\n *\n * Stops at the filesystem root (`/`) — no infinite loop on `dirname`'s\n * idempotent root case (`dirname('/')` returns `/`).\n */\nexport function findGitRoot(cwd: string = process.cwd()): string | null {\n  let dir = resolve(cwd)\n  // Guard against pathological inputs (junction loops, mount cycles)\n  // by bounding the walk. 64 levels is well past anything sane and\n  // avoids a pathological infinite loop on misconfigured volumes.\n  for (let depth = 0; depth < 64; depth++) {\n    if (hasGitMarker(dir))\n      return dir\n    const parent = dirname(dir)\n    if (parent === dir)\n      return null // reached filesystem root\n    dir = parent\n  }\n  return null\n}\n\n/**\n * The main checkout a LINKED WORKTREE belongs to, or `null` when\n * `checkoutRoot` is not one. Does not walk: `checkoutRoot` must be a\n * checkout root (what {@link findGitRoot} returns).\n *\n * A linked worktree's `.git` is a file (`gitdir: <main>/.git/worktrees/<name>`)\n * and that gitdir holds a `commondir` file pointing back at the shared\n * `<main>/.git`. Everything else resolves to `null` and stays its own\n * project:\n *\n *   - a regular checkout (`.git` is a directory);\n *   - a submodule (its gitdir has no `commondir` — a submodule IS a\n *     separate repo);\n *   - a worktree of a bare repo or of a `--separate-git-dir` repo (the\n *     common dir isn't a `.git` inside a working tree, so there is no main\n *     checkout to belong to);\n *   - anything unreadable or malformed.\n */\nexport function mainCheckoutRoot(checkoutRoot: string): string | null {\n  const root = resolve(checkoutRoot)\n  const gitdir = readGitdirPointer(resolve(root, '.git'), root)\n  if (!gitdir)\n    return null\n  const commondirFile = resolve(gitdir, 'commondir')\n  const commondir = readTrimmed(commondirFile)\n  if (!commondir)\n    return null\n  const commonDir = resolve(gitdir, commondir)\n  if (basename(commonDir) !== '.git' || !isDirectory(commonDir))\n    return null\n  const main = dirname(commonDir)\n  return main === root ? null : main\n}\n\n/**\n * The project `cwd` belongs to: the main checkout for a linked worktree,\n * the checkout root otherwise, `null` outside git. See the module header\n * for when to use this vs {@link findGitRoot}.\n */\nexport function findProjectRoot(cwd: string = process.cwd()): string | null {\n  const checkout = findGitRoot(cwd)\n  return checkout ? (mainCheckoutRoot(checkout) ?? checkout) : null\n}\n\n/**\n * {@link findProjectRoot} with the historical fallback: outside git, a\n * directory is its own project. The value to stamp as\n * `SessionData.projectRoot` and to key per-project state on.\n */\nexport function projectRootOf(cwd: string): string {\n  return findProjectRoot(cwd) ?? cwd\n}\n\n/**\n * For persisted project roots that predate worktree-aware identity: the\n * `{ from, to }` pairs where a stored root is a linked worktree's checkout\n * root and should be its main checkout's. Only exact linked-worktree roots\n * remap — a plain directory that later ended up inside some repo keeps its\n * own identity (no parent walk here). Stores apply the pairs as a bulk\n * column update at open; idempotent, so a row reverted by a stale\n * full-document save converges on the next open.\n */\nexport function planWorktreeProjectRootRemaps(roots: Iterable<string>): Array<{ from: string, to: string }> {\n  const remaps: Array<{ from: string, to: string }> = []\n  for (const from of new Set(roots)) {\n    if (!from)\n      continue\n    const to = mainCheckoutRoot(from)\n    if (to)\n      remaps.push({ from, to })\n  }\n  return remaps\n}\n\n/**\n * `.git` exists as a directory (standard repo) OR as a file containing\n * a `gitdir:` pointer (worktree / submodule). Tolerant on stat failures\n * — a permission error on a parent directory shouldn't crash the walk.\n */\nfunction hasGitMarker(dir: string): boolean {\n  const candidate = resolve(dir, '.git')\n  try {\n    if (!existsSync(candidate))\n      return false\n    const stat = statSync(candidate)\n    return stat.isDirectory() || stat.isFile()\n  }\n  catch {\n    return false\n  }\n}\n\n/** Absolute gitdir from a `.git` FILE (`gitdir: <path>`, relative to `root`), else `null`. */\nfunction readGitdirPointer(dotGit: string, root: string): string | null {\n  try {\n    if (!statSync(dotGit).isFile())\n      return null\n  }\n  catch {\n    return null\n  }\n  const text = readTrimmed(dotGit)\n  if (!text?.startsWith('gitdir:'))\n    return null\n  const pointer = text.slice('gitdir:'.length).split('\\n', 1)[0]!.trim()\n  return pointer ? resolve(root, pointer) : null\n}\n\nfunction readTrimmed(path: string): string | null {\n  try {\n    const text = readFileSync(path, 'utf8').trim()\n    return text.length > 0 ? text : null\n  }\n  catch {\n    return null\n  }\n}\n\nfunction isDirectory(path: string): boolean {\n  try {\n    return statSync(path).isDirectory()\n  }\n  catch {\n    return false\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,YAAY,MAAc,QAAQ,IAAI,GAAkB;CACtE,IAAI,MAAM,QAAQ,GAAG;CAIrB,KAAK,IAAI,QAAQ,GAAG,QAAQ,IAAI,SAAS;EACvC,IAAI,aAAa,GAAG,GAClB,OAAO;EACT,MAAM,SAAS,QAAQ,GAAG;EAC1B,IAAI,WAAW,KACb,OAAO;EACT,MAAM;CACR;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,iBAAiB,cAAqC;CACpE,MAAM,OAAO,QAAQ,YAAY;CACjC,MAAM,SAAS,kBAAkB,QAAQ,MAAM,MAAM,GAAG,IAAI;CAC5D,IAAI,CAAC,QACH,OAAO;CAET,MAAM,YAAY,YADI,QAAQ,QAAQ,WACI,CAAC;CAC3C,IAAI,CAAC,WACH,OAAO;CACT,MAAM,YAAY,QAAQ,QAAQ,SAAS;CAC3C,IAAI,SAAS,SAAS,MAAM,UAAU,CAAC,YAAY,SAAS,GAC1D,OAAO;CACT,MAAM,OAAO,QAAQ,SAAS;CAC9B,OAAO,SAAS,OAAO,OAAO;AAChC;;;;;;AAOA,SAAgB,gBAAgB,MAAc,QAAQ,IAAI,GAAkB;CAC1E,MAAM,WAAW,YAAY,GAAG;CAChC,OAAO,WAAY,iBAAiB,QAAQ,KAAK,WAAY;AAC/D;;;;;;AAOA,SAAgB,cAAc,KAAqB;CACjD,OAAO,gBAAgB,GAAG,KAAK;AACjC;;;;;;;;;;AAWA,SAAgB,8BAA8B,OAA8D;CAC1G,MAAM,SAA8C,CAAC;CACrD,KAAK,MAAM,QAAQ,IAAI,IAAI,KAAK,GAAG;EACjC,IAAI,CAAC,MACH;EACF,MAAM,KAAK,iBAAiB,IAAI;EAChC,IAAI,IACF,OAAO,KAAK;GAAE;GAAM;EAAG,CAAC;CAC5B;CACA,OAAO;AACT;;;;;;AAOA,SAAS,aAAa,KAAsB;CAC1C,MAAM,YAAY,QAAQ,KAAK,MAAM;CACrC,IAAI;EACF,IAAI,CAAC,WAAW,SAAS,GACvB,OAAO;EACT,MAAM,OAAO,SAAS,SAAS;EAC/B,OAAO,KAAK,YAAY,KAAK,KAAK,OAAO;CAC3C,QACM;EACJ,OAAO;CACT;AACF;;AAGA,SAAS,kBAAkB,QAAgB,MAA6B;CACtE,IAAI;EACF,IAAI,CAAC,SAAS,MAAM,CAAC,CAAC,OAAO,GAC3B,OAAO;CACX,QACM;EACJ,OAAO;CACT;CACA,MAAM,OAAO,YAAY,MAAM;CAC/B,IAAI,CAAC,MAAM,WAAW,SAAS,GAC7B,OAAO;CACT,MAAM,UAAU,KAAK,MAAM,CAAgB,CAAC,CAAC,MAAM,MAAM,CAAC,CAAC,CAAC,EAAE,CAAE,KAAK;CACrE,OAAO,UAAU,QAAQ,MAAM,OAAO,IAAI;AAC5C;AAEA,SAAS,YAAY,MAA6B;CAChD,IAAI;EACF,MAAM,OAAO,aAAa,MAAM,MAAM,CAAC,CAAC,KAAK;EAC7C,OAAO,KAAK,SAAS,IAAI,OAAO;CAClC,QACM;EACJ,OAAO;CACT;AACF;AAEA,SAAS,YAAY,MAAuB;CAC1C,IAAI;EACF,OAAO,SAAS,IAAI,CAAC,CAAC,YAAY;CACpC,QACM;EACJ,OAAO;CACT;AACF"}

package/dist/project-user-paths-BSgtrRxl.js

@@ -0,0 +1,58 @@
+import { t as findGitRoot } from "./project-root-B8zADr4o.js";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+//#region src/chat/project-user-paths.ts
+/**
+* Shared search-path builder for project + user config discovery.
+*
+* Both Skills (`skills/<name>/SKILL.md`) and MCP servers (`mcps.json`)
+* follow the same first-found-wins order:
+*
+*   1. `{project-root}/.agents/<sub>`   — project, agnostic convention
+*   2. `{project-root}/.{prefix}/<sub>` — project, zidane (`.zidane` default)
+*   3. `~/.agents/<sub>`                — user, agnostic
+*   4. `~/.{prefix}/<sub>`              — user, zidane
+*
+* `{project-root}` is the git root walked up from `cwd` when present,
+* else `cwd` itself. This pairs with the project-scoped session
+* storage (`resolveStoragePaths`) so all three project-aware surfaces
+* — sessions, mcps, skills — anchor at the same `.{prefix}/`.
+*
+* Centralizing the pattern keeps the four paths in one place — a third
+* discovery surface (hooks, rules, …) gets the same convention for free
+* and stays in lock-step on a prefix bump.
+*/
+/**
+* Resolve the four search paths for a given subdirectory (`skills`,
+* `mcps.json`, …). Returns absolute paths regardless of whether they
+* exist — the caller chooses to `existsSync`-filter or feed straight
+* into a tolerant discovery routine.
+*/
+function projectUserPaths(opts) {
+	const cwd = opts.cwd ?? process.cwd();
+	const home = opts.home ?? homedir();
+	const projectRoot = findGitRoot(cwd) ?? cwd;
+	const prefix = (opts.prefix ?? ".zidane").replace(/^\./, "");
+	return [
+		{
+			path: resolve(projectRoot, `.agents/${opts.subPath}`),
+			source: "project"
+		},
+		{
+			path: resolve(projectRoot, `.${prefix}/${opts.subPath}`),
+			source: "project"
+		},
+		{
+			path: resolve(home, `.agents/${opts.subPath}`),
+			source: "user"
+		},
+		{
+			path: resolve(home, `.${prefix}/${opts.subPath}`),
+			source: "user"
+		}
+	];
+}
+//#endregion
+export { projectUserPaths as t };
+
+//# sourceMappingURL=project-user-paths-BSgtrRxl.js.map

package/dist/project-user-paths-BSgtrRxl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-user-paths-BSgtrRxl.js","names":[],"sources":["../src/chat/project-user-paths.ts"],"sourcesContent":["/**\n * Shared search-path builder for project + user config discovery.\n *\n * Both Skills (`skills/<name>/SKILL.md`) and MCP servers (`mcps.json`)\n * follow the same first-found-wins order:\n *\n *   1. `{project-root}/.agents/<sub>`   — project, agnostic convention\n *   2. `{project-root}/.{prefix}/<sub>` — project, zidane (`.zidane` default)\n *   3. `~/.agents/<sub>`                — user, agnostic\n *   4. `~/.{prefix}/<sub>`              — user, zidane\n *\n * `{project-root}` is the git root walked up from `cwd` when present,\n * else `cwd` itself. This pairs with the project-scoped session\n * storage (`resolveStoragePaths`) so all three project-aware surfaces\n * — sessions, mcps, skills — anchor at the same `.{prefix}/`.\n *\n * Centralizing the pattern keeps the four paths in one place — a third\n * discovery surface (hooks, rules, …) gets the same convention for free\n * and stays in lock-step on a prefix bump.\n */\n\nimport { homedir } from 'node:os'\nimport { resolve } from 'node:path'\nimport { findGitRoot } from './project-root'\n\n/** A discovered path tagged with whether it lives in the project or the user dir. */\nexport interface ProjectUserPath {\n  path: string\n  source: 'project' | 'user'\n}\n\n/**\n * Resolve the four search paths for a given subdirectory (`skills`,\n * `mcps.json`, …). Returns absolute paths regardless of whether they\n * exist — the caller chooses to `existsSync`-filter or feed straight\n * into a tolerant discovery routine.\n */\nexport function projectUserPaths(opts: {\n  /** Subdirectory or filename relative to each search root. E.g. `'skills'`, `'mcps.json'`. */\n  subPath: string\n  /** Discovery cwd. Default: `process.cwd()`. */\n  cwd?: string\n  /** User home directory. Default: `os.homedir()`. */\n  home?: string\n  /** Storage prefix. Leading dot tolerated. Default: `'.zidane'`. */\n  prefix?: string\n}): ProjectUserPath[] {\n  const cwd = opts.cwd ?? process.cwd()\n  const home = opts.home ?? homedir()\n  // Anchor the project search at the git root when one exists — so a\n  // subdir invocation (e.g. `cd repo/packages/foo`) still finds the\n  // repo-level `.zidane/mcps.json`. Falls back to `cwd` outside git.\n  const projectRoot = findGitRoot(cwd) ?? cwd\n  // `prefix` arrives as `.zidane` in `ResolvedConfig`; trim the leading dot\n  // for the symmetric `.agents` / `.zidane` convention.\n  const prefix = (opts.prefix ?? '.zidane').replace(/^\\./, '')\n  return [\n    { path: resolve(projectRoot, `.agents/${opts.subPath}`), source: 'project' },\n    { path: resolve(projectRoot, `.${prefix}/${opts.subPath}`), source: 'project' },\n    { path: resolve(home, `.agents/${opts.subPath}`), source: 'user' },\n    { path: resolve(home, `.${prefix}/${opts.subPath}`), source: 'user' },\n  ]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAgB,iBAAiB,MASX;CACpB,MAAM,MAAM,KAAK,OAAO,QAAQ,IAAI;CACpC,MAAM,OAAO,KAAK,QAAQ,QAAQ;CAIlC,MAAM,cAAc,YAAY,GAAG,KAAK;CAGxC,MAAM,UAAU,KAAK,UAAU,UAAA,CAAW,QAAQ,OAAO,EAAE;CAC3D,OAAO;EACL;GAAE,MAAM,QAAQ,aAAa,WAAW,KAAK,SAAS;GAAG,QAAQ;EAAU;EAC3E;GAAE,MAAM,QAAQ,aAAa,IAAI,OAAO,GAAG,KAAK,SAAS;GAAG,QAAQ;EAAU;EAC9E;GAAE,MAAM,QAAQ,MAAM,WAAW,KAAK,SAAS;GAAG,QAAQ;EAAO;EACjE;GAAE,MAAM,QAAQ,MAAM,IAAI,OAAO,GAAG,KAAK,SAAS;GAAG,QAAQ;EAAO;CACtE;AACF"}

package/dist/{prompts-Pqc3JdW_.d.ts → prompts-DYcvqShf.d.ts}

@@ -28,12 +28,12 @@
  * against them is a precise edit.
  */
 declare const toolPrompts: {
-  readonly read_file: "Read a file by path. Text files return lines [offset..offset+limit). Default offset=1, limit=2000. Each line is prefixed with its 1-indexed line number followed by a tab (e.g. `42\\tconst foo = bar`); the prefix is metadata, not part of the file. Mirrors Claude Code's `cat -n`-style compact output for token efficiency. A trailing footer explains how to read the rest when truncated. Images (png/jpg/gif/webp) and PDFs return structured attachments for capable models; other binary files return a short marker rather than mojibake.";
-  readonly write_file: "Write `content` to `path`, creating any missing parent directories. Overwrites existing files in full; prefer `edit` / `multi_edit` for surgical changes when you only want to alter part of a file. Returns one of: `Created <path> (N bytes)` (file did not exist), `Updated <path> (N bytes)` (content differed), or `No change needed: <path> already at target state (N bytes)`, so the model can detect no-ops without a separate `read_file`.";
-  readonly edit: "Replace exact `old_string` with `new_string` in a file. Fails if `old_string` is not unique unless `replace_all: true`. Prefer over `write_file` for surgical changes: preserves the rest of the file. Tolerates `read_file` line-number prefixes (`<N>\\t…`, `<N>|…`, or `<N>→…`) in `old_string` / `new_string`; they are stripped before matching/writing, so you can paste a numbered chunk verbatim.";
-  readonly multi_edit: "Apply a sequential list of edits to a file. Each edit operates on the result of the previous APPLIED edit. Prefer this over multiple `edit` calls when several non-overlapping changes are needed in the same file. Edits run best-effort: a per-step failure (`old_string` not found, ambiguous match without `replace_all`, identical strings) is reported in the result but does NOT block the remaining steps. The file is written iff at least one step applied. The result lists per-hunk outcomes (`applied` / `failed`) so the model can re-issue just the failures without resending the whole batch. Each step tolerates `read_file` line-number prefixes (`<N>\\t…`, `<N>|…`, or `<N>→…`) in `old_string` / `new_string`.";
+  readonly read_file: "Read a file by path. Text files return lines [offset..offset+limit). Default offset=1, limit=2000; a negative offset reads from the end (`-50` = last 50 lines). Pass `paths` to read several files, or several ranges of one file, in one call. Each line is prefixed with its 1-indexed line number followed by a tab (e.g. `42\\tconst foo = bar`); the prefix is metadata, not part of the file. Mirrors Claude Code's `cat -n`-style compact output for token efficiency. A trailing footer explains how to read the rest when truncated. Images (png/jpg/gif/webp) and PDFs return structured attachments for capable models; other binary files return a short marker rather than mojibake.";
+  readonly write_file: "Write `content` to `path`, creating any missing parent directories. Overwrites existing files in full; prefer `edit` / `multi_edit` for surgical changes when you only want to alter part of a file. Returns one of: `Created <path> (N bytes)` (file did not exist), `Updated <path> (N bytes)` (content differed), or `No change needed: <path> already at target state (N bytes)`, so the model can detect no-ops without a separate `read_file`. Several `edit` / `multi_edit` / `write_file` calls and a verifying `shell` call (tests, typecheck) in one message run in order, in a single round-trip.";
+  readonly edit: "Replace exact `old_string` with `new_string` in a file. Fails if `old_string` is not unique unless `replace_all: true`. Prefer over `write_file` for surgical changes: preserves the rest of the file. Tolerates `read_file` line-number prefixes (`<N>\\t…`, `<N>|…`, or `<N>→…`) in `old_string` / `new_string`; they are stripped before matching/writing, so you can paste a numbered chunk verbatim. Several `edit` / `multi_edit` / `write_file` calls and a verifying `shell` call (tests, typecheck) in one message run in order, in a single round-trip.";
+  readonly multi_edit: "Apply a sequential list of edits to a file. Each edit operates on the result of the previous APPLIED edit. Prefer this over multiple `edit` calls when several non-overlapping changes are needed in the same file. Edits run best-effort: a per-step failure (`old_string` not found, ambiguous match without `replace_all`, identical strings) is reported in the result but does NOT block the remaining steps. The file is written iff at least one step applied. The result lists per-hunk outcomes (`applied` / `failed`) so the model can re-issue just the failures without resending the whole batch. Each step tolerates `read_file` line-number prefixes (`<N>\\t…`, `<N>|…`, or `<N>→…`) in `old_string` / `new_string`. Several `edit` / `multi_edit` / `write_file` calls and a verifying `shell` call (tests, typecheck) in one message run in order, in a single round-trip.";
   readonly glob: "Match files by glob pattern (supports **, *, ?). Relative to the execution context cwd; patterns may reach outside the workspace (e.g. \"../shared/**/*.ts\"). By default each row is `<path>\\t<size-bytes>\\t<mtime-iso>`; set `metadata: false` for a plain newline-separated list of paths. Always sorted.";
-  readonly grep: "Search file contents by regex. Returns matching paths (default), match content, or per-file counts. Backed by ripgrep when available, with a portable shell-listing + regex fallback when `rg` is absent.";
+  readonly grep: "Search file contents by regex. Returns matching paths (default), match content, or per-file counts. One call covers several patterns (`patterns`), several roots (`paths`), context lines, literal (`fixed_strings`) or whole-word (`-w`) matching, and dropping noise lines (`exclude`); `head_limit` caps output. Backed by ripgrep when available, with a portable shell-listing + regex fallback when `rg` is absent.";
   readonly list_files: "List the immediate entries (files and subdirectories) at literal directory `path`. Returns a newline-separated list; subdirectories carry a trailing `/`; or `(empty directory)` when the directory exists but is empty. Non-recursive: use `glob` for pattern matching across nested directories.";
   readonly fetch_url: "Fetch a public URL and return its body as plain text. HTML is reduced to text (scripts, styles, tags stripped; entities decoded). If a `web_search` tool is also available, use it first when you do not already know the exact URL. Only http(s) URLs are accepted; loopback, link-local, private, and cloud-metadata addresses are refused. Output is capped (default 200 KiB).";
   readonly shell_kill: string;
@@ -43,7 +43,8 @@ declare const toolPrompts: {
   readonly model_search: string;
   readonly skills_use: string;
   readonly skills_read: string;
-  readonly skills_run_script: string; /** Default for `createInteractionTool` when the host passes no `description`. */
+  readonly skills_run_script: string;
+  /** Default for `createInteractionTool` when the host passes no `description`. */
   readonly interaction: "Request structured input from the user or external system.";
   /**
    * `shell` is assembled per run by `createShellTool`: `core` always; the
@@ -53,11 +54,12 @@ declare const toolPrompts: {
    */
   readonly shell: {
     readonly core: string;
-    readonly preferDedicated: "When a dedicated tool fits, prefer it over shell:"; /** One `- <label>: use \`<tool>\` (not <instead>)` line per registered sibling. */
+    readonly preferDedicated: "When a dedicated tool fits, prefer it over shell:";
+    /** One `- <label>: use \`<tool>\` (not <instead>)` line per registered sibling. */
     readonly swapHints: readonly [{
       readonly canonical: "read_file";
       readonly label: "Read files";
-      readonly instead: "cat/head/tail";
+      readonly instead: "cat/head/tail/sed -n";
     }, {
       readonly canonical: "glob";
       readonly label: "File search";
@@ -73,7 +75,7 @@ declare const toolPrompts: {
     }, {
       readonly canonical: "edit";
       readonly label: "Edit files";
-      readonly instead: "sed/awk";
+      readonly instead: "sed/awk/python scripts";
     }, {
       readonly canonical: "write_file";
       readonly label: "Write files";
@@ -99,7 +101,8 @@ declare const toolPrompts: {
     readonly core: string;
     readonly callable: "Returned tools become callable for the rest of this run.";
     readonly callableVia: (dispatcher: string) => string;
-  }; /** `call_tool` names the discovery tool (`tool_search` or the host's wire name). */
+  };
+  /** `call_tool` names the discovery tool (`tool_search` or the host's wire name). */
   readonly call_tool: (discovery: string) => string;
   /**
    * `web_search`: `core` + `recency(monthYear)`, resolved on each spec read so
@@ -113,4 +116,4 @@ declare const toolPrompts: {
 type ToolPrompts = typeof toolPrompts;
 //#endregion
 export { toolPrompts as n, ToolPrompts as t };
-//# sourceMappingURL=prompts-Pqc3JdW_.d.ts.map
+//# sourceMappingURL=prompts-DYcvqShf.d.ts.map

package/dist/prompts-DYcvqShf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts-DYcvqShf.d.ts","names":[],"sources":["../src/tools/prompts.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6Ba;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAwHiB,cAAA;;;WAKL,YAAA;;;;;;;aAeA,UAAA;;;KAOb,qBAAqB"}

package/dist/protocol-DnhqqSmE.js

@@ -0,0 +1,13 @@
+//#region src/codemode/runtime/protocol.ts
+function isWorkerToHostMessage(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const type = value.type;
+	return type === "call" || type === "output" || type === "done" || type === "crash";
+}
+function isHostToWorkerMessage(value) {
+	return typeof value === "object" && value !== null && value.type === "result";
+}
+//#endregion
+export { isWorkerToHostMessage as n, isHostToWorkerMessage as t };
+
+//# sourceMappingURL=protocol-DnhqqSmE.js.map

package/dist/protocol-DnhqqSmE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol-DnhqqSmE.js","names":[],"sources":["../src/codemode/runtime/protocol.ts"],"sourcesContent":["import type { CodemodeDeterminism, CodemodeOutputItem } from '../types'\nimport type { CodemodeWasmModule } from '../wasm'\n\n/**\n * Messages between the host (main thread) and the worker. Tool arguments,\n * results, and values cross as JSON strings: the worker passes them into and\n * out of the QuickJS VM as strings and never builds structured values itself.\n */\n\nexport interface WorkerData {\n  code: string\n  /** `jsName` is the identifier the script uses; `description` is listed in `ALL_TOOLS`. */\n  tools: { name: string, jsName: string, description: string }[]\n  globals: { name: string, spread: boolean }[]\n  /** Compiled `quickjs-wasi` module. Structured clone shares the compiled code with the worker. */\n  wasm: CodemodeWasmModule\n  memoryLimitBytes: number | undefined\n  /** Snapshot for `load()`: key to JSON text. */\n  store: Record<string, string>\n  /**\n   * One Int32 the host sets to non-zero before terminating the worker. The VM's interrupt handler\n   * polls it, because Bun's `worker.terminate()` cannot stop a thread that is spinning in wasm.\n   */\n  interrupt: SharedArrayBuffer\n  determinism: CodemodeDeterminism | undefined\n}\n\n/** JSON-encoded `{ name?, message, stack? }` of an error thrown by the script. */\nexport type ScriptErrorJson = string\n\nexport type WorkerToHostMessage\n  /** `id` is the issue sequence number of the call (see `CodemodeToolContext.seq`). */\n  = | { type: 'call', id: number, target: 'tool' | 'global', name: string, args: string | undefined }\n    | { type: 'output', item: CodemodeOutputItem }\n  /** `writes` is a JSON array of `[key, json]` for `store()` and `[key]` for deletions. */\n    | { type: 'done', ok: true, value: string | undefined, writes: string }\n    | { type: 'done', ok: false, error: ScriptErrorJson }\n  /** The VM failed outside the script's control, for example a wasm trap. */\n    | { type: 'crash', message: string }\n\n/** `payload` is the JSON result when `ok`, otherwise the error message. */\nexport interface HostToWorkerMessage { type: 'result', id: number, ok: boolean, payload: string | undefined }\n\nexport function isWorkerToHostMessage(value: unknown): value is WorkerToHostMessage {\n  if (typeof value !== 'object' || value === null)\n    return false\n  const type = (value as { type?: unknown }).type\n  return type === 'call' || type === 'output' || type === 'done' || type === 'crash'\n}\n\nexport function isHostToWorkerMessage(value: unknown): value is HostToWorkerMessage {\n  return typeof value === 'object' && value !== null && (value as { type?: unknown }).type === 'result'\n}\n"],"mappings":";AA2CA,SAAgB,sBAAsB,OAA8C;CAClF,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,OAAO;CACT,MAAM,OAAQ,MAA6B;CAC3C,OAAO,SAAS,UAAU,SAAS,YAAY,SAAS,UAAU,SAAS;AAC7E;AAEA,SAAgB,sBAAsB,OAA8C;CAClF,OAAO,OAAO,UAAU,YAAY,UAAU,QAAS,MAA6B,SAAS;AAC/F"}

package/dist/providers/anthropic.d.ts

@@ -1,2 +1,2 @@
-import { Ag as planAnthropicThinking, Cg as anthropic, Dg as classifyAnthropicError, Eg as cacheWriteTtlMultiplier, Mg as resolveAnthropicBetas, Ng as resolveAnthropicMaxOutput, Og as credentialIdentity, Pg as resolveThinkingBinding, Sg as ThinkingBindingBehavior, Tg as buildAnthropicClientOptions, _g as AnthropicContextManagement, bg as EXTENDED_CACHE_TTL_BETA, gg as AnthropicBedrockConfig, jg as resolveAnthropicAuthShape, kg as defaultAnthropicMaxTokens, vg as AnthropicParams, wg as applyAnthropicCacheBreakpoints, xg as THINKING_BINDING_SETTING_ENV, yg as AnthropicThinkingPlan } from "../index-BgN1T3lk.js";
-export { AnthropicBedrockConfig, AnthropicContextManagement, AnthropicParams, AnthropicThinkingPlan, EXTENDED_CACHE_TTL_BETA, THINKING_BINDING_SETTING_ENV, ThinkingBindingBehavior, anthropic, applyAnthropicCacheBreakpoints, buildAnthropicClientOptions, cacheWriteTtlMultiplier, classifyAnthropicError, credentialIdentity, defaultAnthropicMaxTokens, planAnthropicThinking, resolveAnthropicAuthShape, resolveAnthropicBetas, resolveAnthropicMaxOutput, resolveThinkingBinding };
+import { $v as ThinkingBindingBehavior, Cv as resolveAnthropicAuthShape, Dv as AnthropicBedrockConfig, Ev as applyAnthropicCacheBreakpoints, Ov as AnthropicContextManagement, Qv as THINKING_BINDING_SETTING_ENV, Sv as credentialIdentity, Tv as EXTENDED_CACHE_TTL_BETA, Zv as AnthropicThinkingPlan, _v as cacheWriteTtlMultiplier, bv as classifyAnthropicError, ey as planAnthropicThinking, gv as anthropic, kv as AnthropicParams, ty as resolveThinkingBinding, vv as defaultAnthropicMaxTokens, wv as resolveAnthropicBetas, xv as buildAnthropicClientOptions, yv as resolveAnthropicMaxOutput } from "../index-BGe1fQT7.js";
+export { type AnthropicBedrockConfig, type AnthropicContextManagement, type AnthropicParams, type AnthropicThinkingPlan, EXTENDED_CACHE_TTL_BETA, THINKING_BINDING_SETTING_ENV, type ThinkingBindingBehavior, anthropic, applyAnthropicCacheBreakpoints, buildAnthropicClientOptions, cacheWriteTtlMultiplier, classifyAnthropicError, credentialIdentity, defaultAnthropicMaxTokens, planAnthropicThinking, resolveAnthropicAuthShape, resolveAnthropicBetas, resolveAnthropicMaxOutput, resolveThinkingBinding };

package/dist/providers/anthropic.js

@@ -1,2 +1 @@
-import { a as buildAnthropicClientOptions, c as credentialIdentity, d as resolveAnthropicAuthShape, f as resolveAnthropicBetas, i as applyAnthropicCacheBreakpoints, l as defaultAnthropicMaxTokens, m as resolveThinkingBinding, n as THINKING_BINDING_SETTING_ENV, o as cacheWriteTtlMultiplier, p as resolveAnthropicMaxOutput, r as anthropic, s as classifyAnthropicError, t as EXTENDED_CACHE_TTL_BETA, u as planAnthropicThinking } from "../anthropic-C2aole0G.js";
-export { EXTENDED_CACHE_TTL_BETA, THINKING_BINDING_SETTING_ENV, anthropic, applyAnthropicCacheBreakpoints, buildAnthropicClientOptions, cacheWriteTtlMultiplier, classifyAnthropicError, credentialIdentity, defaultAnthropicMaxTokens, planAnthropicThinking, resolveAnthropicAuthShape, resolveAnthropicBetas, resolveAnthropicMaxOutput, resolveThinkingBinding };
+export { d as EXTENDED_CACHE_TTL_BETA, c as THINKING_BINDING_SETTING_ENV, t as anthropic, f as applyAnthropicCacheBreakpoints, m as buildAnthropicClientOptions, r as cacheWriteTtlMultiplier, p as classifyAnthropicError, h as credentialIdentity, o as defaultAnthropicMaxTokens, l as planAnthropicThinking, g as resolveAnthropicAuthShape, _ as resolveAnthropicBetas, s as resolveAnthropicMaxOutput, u as resolveThinkingBinding } from "../anthropic-CD00LhUP.js";

package/dist/providers/arcee.d.ts

@@ -1,2 +1,2 @@
-import { hg as arcee, mg as ArceeParams } from "../index-BgN1T3lk.js";
+import { hv as arcee, mv as ArceeParams } from "../index-BGe1fQT7.js";
 export { ArceeParams, arcee };

package/dist/providers/arcee.js

@@ -1,4 +1,4 @@
-import { m as openaiCompat } from "../openai-compat-Dy56weK8.js";
+import { f as openaiCompat } from "../openai-compat-CFrpH7uq.js";
 //#region src/providers/arcee.ts
 const BASE_URL = "https://api.arcee.ai/api/v1";
 function getApiKey(params) {

package/dist/providers/baseten.d.ts

@@ -1,2 +1,2 @@
-import { dg as BasetenParams, fg as baseten, pg as planBasetenReasoning } from "../index-BgN1T3lk.js";
+import { dv as BasetenParams, fv as baseten, pv as planBasetenReasoning } from "../index-BGe1fQT7.js";
 export { BasetenParams, baseten, planBasetenReasoning };

package/dist/providers/baseten.js

@@ -1,4 +1,4 @@
-import { m as openaiCompat } from "../openai-compat-Dy56weK8.js";
+import { f as openaiCompat } from "../openai-compat-CFrpH7uq.js";
 //#region src/providers/baseten.ts
 const BASE_URL = "https://inference.baseten.co/v1";
 /**

package/dist/providers/cerebras.d.ts

@@ -1,2 +1,2 @@
-import { lg as CerebrasParams, ug as cerebras } from "../index-BgN1T3lk.js";
+import { lv as CerebrasParams, uv as cerebras } from "../index-BGe1fQT7.js";
 export { CerebrasParams, cerebras };

package/dist/providers/cerebras.js

@@ -1,4 +1,4 @@
-import { m as openaiCompat } from "../openai-compat-Dy56weK8.js";
+import { f as openaiCompat } from "../openai-compat-CFrpH7uq.js";
 //#region src/providers/cerebras.ts
 const BASE_URL = "https://api.cerebras.ai/v1";
 function getApiKey(params) {
@@ -13,9 +13,10 @@ function getApiKey(params) {
 * (base URL, default model).
 */
 function cerebras(params) {
+	const apiKey = getApiKey(params);
 	return openaiCompat({
 		name: "cerebras",
-		apiKey: getApiKey(params),
+		apiKey,
 		baseURL: BASE_URL,
 		defaultModel: params?.defaultModel || "gpt-oss-120b",
 		capabilities: params?.capabilities ?? {

package/dist/providers/cerebras.js.map

@@ -1 +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 || 'gpt-oss-120b',\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"}
+{"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 || 'gpt-oss-120b',\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;CAC1D,MAAM,SAAS,UAAU,MAAM;CAC/B,OAAO,aAAa;EAClB,MAAM;EACN;EACA,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

@@ -1,2 +1,2 @@
-import { ag as LocalParams, og as local } from "../index-BgN1T3lk.js";
+import { av as LocalParams, ov as local } from "../index-BGe1fQT7.js";
 export { LocalParams, local };

package/dist/providers/local.js

@@ -1,4 +1,4 @@
-import { m as openaiCompat } from "../openai-compat-Dy56weK8.js";
+import { f as openaiCompat } from "../openai-compat-CFrpH7uq.js";
 //#region src/providers/local.ts
 function getBaseURL(params) {
 	if (typeof params?.baseURL === "string" && params.baseURL.length > 0) return params.baseURL;

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

@@ -1,2 +1,2 @@
-import { Ah as ASSISTANT_TOOL_CALLS_TAG, Bh as assistantMessage, Fh as OpenAICompatParams, Gh as mapOAIFinishReason, Hh as classifyOpenAICompatError, Ih as OpenAICompatStreamError, Jh as toOAIMessages, Kh as openAICompatPromptMessage, Lh as TOOL_RESULTS_TAG, Mh as OAITool, Nh as OpenAICompatAuthHeader, Ph as OpenAICompatHttpError, Rh as applyOAICacheBreakpoints, Uh as consumeSSE, Vh as buildAssistantContent, Wh as formatTools, Xh as userMessage, Yh as toolResultsMessage, jh as OAIMessage, qh as openaiCompat, zh as applyOAIToolCacheBreakpoint } from "../index-BgN1T3lk.js";
+import { A_ as ASSISTANT_TOOL_CALLS_TAG, B_ as buildAssistantContent, F_ as OpenAICompatParams, G_ as openaiCompat, H_ as formatTools, I_ as TOOL_RESULTS_TAG, J_ as userMessage, K_ as toOAIMessages, L_ as applyOAICacheBreakpoints, M_ as OAITool, N_ as OpenAICompatAuthHeader, P_ as OpenAICompatHttpError, R_ as applyOAIToolCacheBreakpoint, U_ as mapOAIFinishReason, V_ as classifyOpenAICompatError, W_ as openAICompatPromptMessage, X_ as consumeSSE, Y_ as OpenAICompatStreamError, j_ as OAIMessage, q_ as toolResultsMessage, z_ as assistantMessage } from "../index-BGe1fQT7.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

@@ -1,2 +1 @@
-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-Dy56weK8.js";
-export { ASSISTANT_TOOL_CALLS_TAG, OpenAICompatHttpError, OpenAICompatStreamError, TOOL_RESULTS_TAG, applyOAICacheBreakpoints, applyOAIToolCacheBreakpoint, assistantMessage, buildAssistantContent, classifyOpenAICompatError, consumeSSE, formatTools, mapOAIFinishReason, openAICompatPromptMessage, openaiCompat, toOAIMessages, toolResultsMessage, userMessage };
+export { t as ASSISTANT_TOOL_CALLS_TAG, n as OpenAICompatHttpError, x as OpenAICompatStreamError, r as TOOL_RESULTS_TAG, i as applyOAICacheBreakpoints, a as applyOAIToolCacheBreakpoint, o as assistantMessage, s as buildAssistantContent, c as classifyOpenAICompatError, S as consumeSSE, l as formatTools, u as mapOAIFinishReason, d as openAICompatPromptMessage, f as openaiCompat, p as toOAIMessages, m as toolResultsMessage, h as userMessage } from "../openai-compat-CFrpH7uq.js";

package/dist/providers/openai.d.ts

@@ -1,2 +1,2 @@
-import { $h as mapCodexStopReason, Qh as classifyOpenAIError, Zh as OpenAIParams, eg as openai, tg as toPiMessages } from "../index-BgN1T3lk.js";
+import { $_ as mapCodexStopReason, Q_ as classifyOpenAIError, Z_ as OpenAIParams, ev as openai, tv as toPiMessages } from "../index-BGe1fQT7.js";
 export { OpenAIParams, classifyOpenAIError, mapCodexStopReason, openai, toPiMessages };

package/dist/providers/openai.js

@@ -1,9 +1,9 @@
-import { A as mergeCatalogEntry, F as unsupportedMediaError, T as aliasCatalogProviders, _ as userMessage, b as sanitizeToolSpecs, g as toolResultsMessage, k as lookupModel$1, s as assistantMessage, v as createToolNameBoundary, w as fillEstimatedCost } from "../openai-compat-Dy56weK8.js";
-import { a as documentBlockMarker, r as assertResolvedMediaBlock } from "../types-CWgENVLY.js";
 import { f as isRetryableHttpStatus, h as matchesToolPairingError, l as classifyErrorPrelude, m as matchesContextExceeded } from "../errors-DKiMrOKq.js";
+import { a as documentBlockMarker, r as assertResolvedMediaBlock } from "../types-Cu0ZGDu9.js";
+import { A as lookupModel$1, E as aliasCatalogProviders, I as unsupportedMediaError, T as fillEstimatedCost, g as createToolNameBoundary, h as userMessage, j as mergeCatalogEntry, m as toolResultsMessage, o as assistantMessage, v as sanitizeToolSpecs } from "../openai-compat-CFrpH7uq.js";
 import { renderSystemForWire } from "../prompt.js";
-import { f as reasoningWireAction, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER } from "../messages-2jcOA_5R.js";
-import { r as extractRuntimeCredentials, s as resolveOAuthApiKey } from "../oauth-DxHO17JE.js";
+import { m as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, s as reasoningWireAction } from "../messages-BqiwcD2Q.js";
+import { r as extractRuntimeCredentials, s as resolveOAuthApiKey } from "../oauth-Px_pBB9W.js";
 import { normalizeContext } from "@earendil-works/pi-ai";
 import { stream } from "@earendil-works/pi-ai/api/openai-codex-responses";
 import { stream as stream$1 } from "@earendil-works/pi-ai/api/openai-responses";
@@ -393,12 +393,14 @@ function toResponsesTools(tools) {
 }
 function applyPayloadOverrides(payload, options, toWireToolName = (name) => name) {
 	const body = payload;
-	if (options.toolChoice) if (options.toolChoice.type === "tool" && options.toolChoice.name) body.tool_choice = {
-		type: "function",
-		name: toWireToolName(options.toolChoice.name)
-	};
-	else if (options.toolChoice.type === "required") body.tool_choice = "required";
-	else body.tool_choice = "auto";
+	if (options.toolChoice) {
+		if (options.toolChoice.type === "tool" && options.toolChoice.name) body.tool_choice = {
+			type: "function",
+			name: toWireToolName(options.toolChoice.name)
+		};
+		else if (options.toolChoice.type === "required") body.tool_choice = "required";
+		else body.tool_choice = "auto";
+	}
 	return body;
 }
 function openai(params) {
@@ -485,14 +487,15 @@ function openai(params) {
 			const model = resolveModel(modelId, usePlatformApi ? PLATFORM_PROVIDER_ID : PROVIDER_ID, options.modelCatalog);
 			const tools = options.tools;
 			const nameBoundary = createToolNameBoundary(options.messages, tools.map((tool) => tool.name));
-			const context = normalizeContext({
+			const rawContext = {
 				systemPrompt: renderSystemForWire(options.system),
 				messages: toPiMessages(nameBoundary.messages, modelId),
 				tools: tools.map((tool) => ({
 					...tool,
 					name: nameBoundary.toWire(tool.name)
 				}))
-			});
+			};
+			const context = normalizeContext(rawContext);
 			const supportsMaxEffort = modelId.startsWith("gpt-5.6");
 			const reasoningLevel = options.thinking && options.thinking !== "off" && options.thinking !== "adaptive" ? options.thinking === "max" && !supportsMaxEffort ? "xhigh" : options.thinking : void 0;
 			const makeStream = (reasoningSummary) => {