codeep 2.14.0 → 2.16.0

package/dist/utils/skillBundles.js

@@ -42,7 +42,7 @@ import { homedir } from 'os';
  * unquoted. We don't ship a real YAML dep for this — the keys we care
  * about are scalars or simple arrays.
  */
-function parseFrontmatter(raw) {
+export function parseFrontmatter(raw) {
     // BOM + CRLF normalisation. Real-world files copy/paste from various
     // editors and pick up either; YAML strictly forbids tabs in scalars
     // but we don't care for the keys we read.
@@ -94,7 +94,7 @@ function parseFrontmatter(raw) {
     }
     return { meta, body: match[2].trimStart() };
 }
-function stripQuotes(s) {
+export function stripQuotes(s) {
     return s.replace(/^["']|["']$/g, '');
 }
 function loadFromDir(dir, scope) {
@@ -158,7 +158,7 @@ function loadFromDir(dir, scope) {
     }
     return bundles;
 }
-function asStringArray(v) {
+export function asStringArray(v) {
     if (Array.isArray(v))
         return v.filter(x => typeof x === 'string');
     if (typeof v === 'string')

package/dist/utils/skillBundlesCloud.d.ts

@@ -10,6 +10,7 @@
  * Auth uses the same `x-sync-token` header `codeepCloud.ts` already sends
  * for /api/tasks and friends.
  */
+import { type SkillBundle } from './skillBundles.js';
 export interface RemoteSkill {
     id: number;
     github_id: string;
@@ -63,6 +64,12 @@ export declare function unpublishBundle(idOrPath: string): Promise<{
     ok: boolean;
     error?: string;
 }>;
+/**
+ * Re-serialise a loaded SkillBundle back into the SKILL.md text format.
+ * Used by publish so the round-trip is lossless (sort of — we drop
+ * unknown frontmatter keys for now to keep the published format stable).
+ */
+export declare function serialiseSkillMd(bundle: SkillBundle): string;
 /** Read raw SKILL.md from disk — used when we want the unmodified bytes. */
 export declare function readRawSkillMd(workspaceRoot: string, slug: string): string | null;
 /** Delete the local copy of an installed skill bundle (for /skills uninstall). */

package/dist/utils/skillBundlesCloud.js

@@ -144,7 +144,7 @@ export async function unpublishBundle(idOrPath) {
  * Used by publish so the round-trip is lossless (sort of — we drop
  * unknown frontmatter keys for now to keep the published format stable).
  */
-function serialiseSkillMd(bundle) {
+export function serialiseSkillMd(bundle) {
     const meta = ['---'];
     meta.push(`name: ${bundle.name}`);
     meta.push(`description: ${bundle.description}`);

package/dist/utils/tokenTracker.js

@@ -11,12 +11,15 @@ const MODEL_CONTEXT_WINDOWS = {
     'glm-5.2': 200_000,
     'glm-5-turbo': 202_752,
     // OpenAI
+    'gpt-5.6-sol': 1_050_000,
+    'gpt-5.6-terra': 1_050_000,
+    'gpt-5.6-luna': 1_050_000,
     'gpt-5.5': 1_200_000,
     'gpt-5.4': 1_050_000,
     'gpt-5.4-mini': 400_000,
     // Anthropic
     'claude-fable-5': 1_000_000,
-    'claude-opus-4-8': 1_000_000,
+    'claude-opus-5': 1_000_000,
     'claude-sonnet-4-6': 1_000_000,
     'claude-sonnet-5': 1_000_000,
     'claude-haiku-4-5-20251001': 200_000,
@@ -26,16 +29,21 @@ const MODEL_CONTEXT_WINDOWS = {
     // Google
     'gemini-3.1-pro-preview': 1_048_576,
     'gemini-3.5-flash': 1_000_000,
+    'gemini-3.1-flash-lite': 1_048_576,
     'gemini-3-flash-preview': 1_000_000,
     // MiniMax
     'MiniMax-M3': 524_288,
-    // Kimi (Moonshot) — 256K across the K2.x line
+    // Kimi (Moonshot) — 1M on the K3 line, 256K across K2.x
+    'kimi-k3-code': 1_000_000,
+    'kimi-k3-code-highspeed': 1_000_000,
+    'kimi-k3-thinking': 1_000_000,
     'kimi-k2.7-code': 262_144,
     'kimi-k2.7-code-highspeed': 262_144,
     'kimi-k2.6': 262_144,
     'kimi-k2.5': 262_144,
     'kimi-for-coding': 262_144,
     // Grok (xAI)
+    'grok-4.5': 500_000,
     'grok-build-0.1': 256_000,
     'grok-4.3': 1_000_000,
     'grok-code-fast-1': 256_000,
@@ -44,7 +52,7 @@ const MODEL_CONTEXT_WINDOWS = {
     'qwen3-coder-plus': 262_144,
     'qwen3-coder-next': 262_144,
     'qwen3-coder-flash': 262_144,
-    'qwen3-max': 262_144,
+    'qwen3.7-max': 1_000_000,
     'Qwen/Qwen3-Coder-480B-A35B-Instruct': 262_144,
 };
 const DEFAULT_CONTEXT_WINDOW = 128_000;
@@ -66,12 +74,15 @@ const MODEL_PRICING = {
     'glm-5.2': { inputPer1M: 1.00, outputPer1M: 3.20 },
     'glm-5-turbo': { inputPer1M: 1.20, outputPer1M: 4.00 },
     // OpenAI
+    'gpt-5.6-sol': { inputPer1M: 5.00, outputPer1M: 30.00 },
+    'gpt-5.6-terra': { inputPer1M: 2.50, outputPer1M: 15.00 },
+    'gpt-5.6-luna': { inputPer1M: 1.00, outputPer1M: 6.00 },
     'gpt-5.5': { inputPer1M: 5.00, outputPer1M: 30.00 },
     'gpt-5.4': { inputPer1M: 2.50, outputPer1M: 15.00 },
     'gpt-5.4-mini': { inputPer1M: 0.75, outputPer1M: 4.50 },
     // Anthropic
     'claude-fable-5': { inputPer1M: 10.00, outputPer1M: 50.00 },
-    'claude-opus-4-8': { inputPer1M: 5.00, outputPer1M: 25.00 },
+    'claude-opus-5': { inputPer1M: 5.00, outputPer1M: 25.00 },
     'claude-sonnet-4-6': { inputPer1M: 3.00, outputPer1M: 15.00 },
     'claude-sonnet-5': { inputPer1M: 3.00, outputPer1M: 15.00 },
     'claude-haiku-4-5-20251001': { inputPer1M: 1.00, outputPer1M: 5.00 },
@@ -81,17 +92,22 @@ const MODEL_PRICING = {
     // Google
     'gemini-3.1-pro-preview': { inputPer1M: 2.00, outputPer1M: 12.00 },
     'gemini-3.5-flash': { inputPer1M: 1.50, outputPer1M: 9.00 },
+    'gemini-3.1-flash-lite': { inputPer1M: 0.25, outputPer1M: 1.50 },
     'gemini-3-flash-preview': { inputPer1M: 0.50, outputPer1M: 3.00 },
     // MiniMax
     'MiniMax-M3': { inputPer1M: 0.60, outputPer1M: 2.40 },
     // Kimi (Moonshot) — pay-per-use cache-miss rates; `kimi-for-coding` is the
     // subscription alias (flat-fee in reality, priced notionally like K2.7 Code).
+    'kimi-k3-code': { inputPer1M: 0.60, outputPer1M: 2.50 },
+    'kimi-k3-code-highspeed': { inputPer1M: 0.60, outputPer1M: 2.50 },
+    'kimi-k3-thinking': { inputPer1M: 0.60, outputPer1M: 2.50 },
     'kimi-k2.7-code': { inputPer1M: 0.60, outputPer1M: 2.50 },
     'kimi-k2.7-code-highspeed': { inputPer1M: 0.60, outputPer1M: 2.50 },
     'kimi-k2.6': { inputPer1M: 0.55, outputPer1M: 2.20 },
     'kimi-k2.5': { inputPer1M: 0.40, outputPer1M: 1.90 },
     'kimi-for-coding': { inputPer1M: 0.60, outputPer1M: 2.50 },
     // Grok (xAI)
+    'grok-4.5': { inputPer1M: 2.00, outputPer1M: 6.00 },
     'grok-build-0.1': { inputPer1M: 1.00, outputPer1M: 2.00 },
     'grok-4.3': { inputPer1M: 1.25, outputPer1M: 2.50 },
     'grok-code-fast-1': { inputPer1M: 0.20, outputPer1M: 1.50 },
@@ -101,7 +117,7 @@ const MODEL_PRICING = {
     'qwen3-coder-plus': { inputPer1M: 0.28, outputPer1M: 1.65 },
     'qwen3-coder-next': { inputPer1M: 0.28, outputPer1M: 1.65 },
     'qwen3-coder-flash': { inputPer1M: 0.10, outputPer1M: 0.50 },
-    'qwen3-max': { inputPer1M: 1.20, outputPer1M: 6.00 },
+    'qwen3.7-max': { inputPer1M: 2.50, outputPer1M: 7.50 },
     // ModelScope free tier — no per-token charge.
     'Qwen/Qwen3-Coder-480B-A35B-Instruct': { inputPer1M: 0, outputPer1M: 0 },
 };

package/dist/utils/toolParsing.d.ts

@@ -9,10 +9,21 @@ import { ToolCall } from './tools';
  * Normalize tool name to lowercase with underscores
  */
 export declare function normalizeToolName(name: string): string;
+/**
+ * Extract parameters from truncated/partial JSON for tool calls.
+ * Fallback when JSON.parse fails due to API truncation.
+ */
+declare function extractPartialToolParams(toolName: string, rawArgs: string): Record<string, unknown> | null;
 export declare function parseOpenAIToolCalls(toolCalls: unknown[]): ToolCall[];
 export declare function parseAnthropicToolCalls(content: unknown[]): ToolCall[];
+declare function tryExtractParams(str: string): Record<string, unknown> | null;
+declare function tryParseToolCall(str: string): ToolCall | null;
 /**
  * Parse tool calls from LLM response text.
  * Supports: <tool_call>, <toolcall>, ```tool blocks, inline JSON.
  */
 export declare function parseToolCalls(response: string): ToolCall[];
+export declare const _extractPartialToolParamsForTest: typeof extractPartialToolParams;
+export declare const _tryExtractParamsForTest: typeof tryExtractParams;
+export declare const _tryParseToolCallForTest: typeof tryParseToolCall;
+export {};

package/dist/utils/toolParsing.js

@@ -319,3 +319,9 @@ export function parseToolCalls(response) {
     }
     return toolCalls;
 }
+// Test seams — these helpers are otherwise file-private; export them under
+// a `_forTest` suffix so the parser internals can be exercised directly
+// without going through the full response-parsing pipeline.
+export const _extractPartialToolParamsForTest = extractPartialToolParams;
+export const _tryExtractParamsForTest = tryExtractParams;
+export const _tryParseToolCallForTest = tryParseToolCall;

package/dist/utils/webFetch.d.ts

@@ -0,0 +1,101 @@
+/**
+ * `@web <url>` inline context — fetch a web page and attach its text
+ * content to the prompt, the same way `@file` attaches a file.
+ *
+ * Supported forms (anywhere in the message, like file mentions):
+ *   @web https://example.com/docs       → full URL
+ *   @web example.com/docs               → https:// is auto-prepended
+ *   @web http://localhost:3000/api      → dev servers work too
+ *
+ * The fetch is best-effort:
+ *   - HTML is stripped to readable text (tags, scripts, styles removed).
+ *   - Output is capped at `MAX_WEB_BYTES` (default 32 KB) so a single
+ *     page can't blow the context window.
+ *   - Markdown conversion is lightweight (headings, links, lists) — we
+ *     don't run a full HTML→Markdown pipeline; the goal is "agent can
+ *     read the page", not "pretty render".
+ *   - Failures (network, non-2xx, non-text content type) surface as
+ *     inline notifications, same as missing files.
+ *
+ * The fetcher is async, so `expandWebMentions` is async — unlike the
+ * sync `expandMentions` for files. Callers await it.
+ */
+/** Max bytes of text we'll inline from a fetched page (32 KB). */
+export declare const MAX_WEB_BYTES: number;
+/** Result of expanding `@web` mentions in a prompt. */
+export interface WebExpansionResult {
+    /** The prompt with fetched page text prepended. */
+    enrichedPrompt: string;
+    /** Successfully fetched pages. */
+    loaded: Array<{
+        url: string;
+        title: string;
+        content: string;
+    }>;
+    /** Mentions that couldn't be fetched, with a human-readable reason. */
+    failures: Array<{
+        mention: string;
+        reason: string;
+    }>;
+}
+/** One `@web` mention match. */
+interface WebToken {
+    /** Full match including `@web `, for display. */
+    raw: string;
+    /** The URL (normalized: `https://` prepended if missing a scheme). */
+    url: string;
+    /** Start index of `raw` in the source. */
+    start: number;
+    /** End index (exclusive). */
+    end: number;
+}
+/**
+ * Extract all `@web` mentions from `text`. Pure (no network).
+ * Returns them in document order.
+ */
+export declare function extractWebMentions(text: string): WebToken[];
+export interface WebFetchOptions {
+    /**
+     * The fetch implementation. Defaults to the global `fetch` (Node 18+).
+     * Injected so tests can mock without hitting the network.
+     */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Expand all `@web` mentions in `prompt`: fetch each URL, convert the
+ * HTML to readable text, and prepend it as a `[Web pages]` block.
+ * Failures are collected, not thrown.
+ */
+export declare function expandWebMentions(prompt: string, opts?: WebFetchOptions): Promise<WebExpansionResult>;
+/**
+ * Reset the session web cache. Public so callers (e.g. `/web-cache clear`
+ * command, or tests) can force a fresh fetch.
+ */
+export declare function clearWebCache(): void;
+/**
+ * Stats about the session web cache — for `/web-cache status`.
+ */
+export declare function webCacheStats(): {
+    entries: number;
+    maxEntries: number;
+    ttlMinutes: number;
+};
+/**
+ * Convert HTML to readable plain text + a title.
+ *
+ * Lightweight — no full parser dependency. Strips `<script>`, `<style>`,
+ * and tags, collapses whitespace, extracts `<title>` and the first
+ * `<h1>` as the page title. Good enough for the agent to read docs;
+ * not a faithful rendering.
+ */
+export declare function htmlToText(html: string): {
+    title: string;
+    content: string;
+};
+/** Format the `[Web pages]` block prepended to the enriched prompt. */
+export declare function formatWebBlock(pages: Array<{
+    url: string;
+    title: string;
+    content: string;
+}>): string;
+export {};

package/dist/utils/webFetch.js

@@ -0,0 +1,375 @@
+/**
+ * `@web <url>` inline context — fetch a web page and attach its text
+ * content to the prompt, the same way `@file` attaches a file.
+ *
+ * Supported forms (anywhere in the message, like file mentions):
+ *   @web https://example.com/docs       → full URL
+ *   @web example.com/docs               → https:// is auto-prepended
+ *   @web http://localhost:3000/api      → dev servers work too
+ *
+ * The fetch is best-effort:
+ *   - HTML is stripped to readable text (tags, scripts, styles removed).
+ *   - Output is capped at `MAX_WEB_BYTES` (default 32 KB) so a single
+ *     page can't blow the context window.
+ *   - Markdown conversion is lightweight (headings, links, lists) — we
+ *     don't run a full HTML→Markdown pipeline; the goal is "agent can
+ *     read the page", not "pretty render".
+ *   - Failures (network, non-2xx, non-text content type) surface as
+ *     inline notifications, same as missing files.
+ *
+ * The fetcher is async, so `expandWebMentions` is async — unlike the
+ * sync `expandMentions` for files. Callers await it.
+ */
+/** Max bytes of text we'll inline from a fetched page (32 KB). */
+export const MAX_WEB_BYTES = 32 * 1024;
+/** Fetch timeout — don't hang the chat on a slow server. */
+const FETCH_TIMEOUT_MS = 12_000;
+/** User-Agent — some sites block the default `node` UA. */
+const USER_AGENT = `Codeep/1 (+https://codeep.dev)`;
+/**
+ * Regex matching a `@web <url>` mention.
+ *
+ * `@web` must be followed by whitespace, then a URL-like token (no
+ * spaces). We accept `http://`, `https://`, or bare host/path. The
+ * bare form (`example.com/docs`) gets `https://` auto-prepended.
+ */
+const WEB_MENTION_RE = /(?:^|[\s([{<,;])@web\s+(https?:\/\/[^\s<>"]+|[a-z0-9][a-z0-9.-]*\.[a-z]{2,}[^\s<>"]*)/gi;
+/**
+ * Extract all `@web` mentions from `text`. Pure (no network).
+ * Returns them in document order.
+ */
+export function extractWebMentions(text) {
+    const tokens = [];
+    WEB_MENTION_RE.lastIndex = 0;
+    let m;
+    while ((m = WEB_MENTION_RE.exec(text)) !== null) {
+        let url = m[1];
+        if (!url)
+            continue;
+        // Auto-prepend https:// for bare hosts (e.g. "example.com/docs").
+        if (!/^https?:\/\//i.test(url)) {
+            url = 'https://' + url;
+        }
+        // The match may include a leading boundary char (space, `(`, …);
+        // `tok.start` should point at the `@` so stripping leaves the
+        // boundary char in place.
+        const matchText = m[0];
+        const atIdx = matchText.indexOf('@');
+        const start = m.index + (atIdx >= 0 ? atIdx : 0);
+        tokens.push({ raw: matchText.slice(atIdx).trim(), url, start, end: m.index + m[0].length });
+    }
+    return tokens;
+}
+/**
+ * Expand all `@web` mentions in `prompt`: fetch each URL, convert the
+ * HTML to readable text, and prepend it as a `[Web pages]` block.
+ * Failures are collected, not thrown.
+ */
+export async function expandWebMentions(prompt, opts = {}) {
+    const tokens = extractWebMentions(prompt);
+    if (tokens.length === 0) {
+        return { enrichedPrompt: prompt, loaded: [], failures: [] };
+    }
+    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    const loaded = [];
+    const failures = [];
+    const seen = new Set();
+    // Fetch sequentially — avoids hammering a server and keeps failure
+    // order stable (matches the order in the prompt).
+    for (const tok of tokens) {
+        if (seen.has(tok.url))
+            continue;
+        seen.add(tok.url);
+        // Session cache: skip the network if we fetched this URL recently.
+        const cached = cacheGet(tok.url);
+        if (cached) {
+            loaded.push({ url: tok.url, title: cached.title, content: cached.content });
+            continue;
+        }
+        const result = await safeFetch(tok.url, fetchImpl);
+        if (!result.ok) {
+            failures.push({ mention: tok.raw, reason: result.reason });
+            continue;
+        }
+        // Cache successful fetches for the rest of the session.
+        cacheSet(tok.url, result);
+        loaded.push({ url: tok.url, title: result.title, content: result.content });
+    }
+    // Strip the `@web ` and the URL from the visible prompt, leaving a
+    // bare URL (readable, and the agent still sees what was referenced).
+    let stripped = prompt;
+    for (let i = tokens.length - 1; i >= 0; i--) {
+        const tok = tokens[i];
+        stripped = stripped.slice(0, tok.start) + tok.url + stripped.slice(tok.end);
+    }
+    const block = formatWebBlock(loaded);
+    return {
+        enrichedPrompt: block ? block + stripped.trimStart() : stripped,
+        loaded,
+        failures,
+    };
+}
+/** Session cache: normalized URL → entry. */
+const webCache = new Map();
+/** Cache TTL: 30 minutes. Docs rarely change faster than that. */
+const WEB_CACHE_TTL_MS = 30 * 60 * 1000;
+/** Max entries — prevents unbounded growth in long sessions. */
+const WEB_CACHE_MAX = 50;
+/**
+ * Normalize a URL for cache keying: lowercase host, strip trailing
+ * slash, drop fragments. Query strings are kept (they can change
+ * content).
+ */
+function normalizeUrlForCache(url) {
+    try {
+        const u = new URL(url);
+        // The fragment is deliberately excluded: it never reaches the server, so
+        // `#a` and `#b` on the same URL are one cache entry.
+        return `${u.protocol}//${u.host.toLowerCase()}${u.pathname.replace(/\/$/, '')}${u.search}`;
+    }
+    catch {
+        // Not a parseable URL — fall back to the raw string.
+        return url;
+    }
+}
+/** Look up a cached successful fetch. Returns `null` if missing/expired. */
+function cacheGet(url) {
+    const key = normalizeUrlForCache(url);
+    const entry = webCache.get(key);
+    if (!entry)
+        return null;
+    if (Date.now() - entry.writtenAt > WEB_CACHE_TTL_MS) {
+        webCache.delete(key);
+        return null;
+    }
+    return entry.result;
+}
+/** Store a successful fetch in the cache (evicting oldest if full). */
+function cacheSet(url, result) {
+    const key = normalizeUrlForCache(url);
+    // Evict oldest if at capacity. Map preserves insertion order, so the
+    // first key is the oldest.
+    if (webCache.size >= WEB_CACHE_MAX && !webCache.has(key)) {
+        const oldest = webCache.keys().next().value;
+        if (oldest !== undefined)
+            webCache.delete(oldest);
+    }
+    webCache.set(key, { result, writtenAt: Date.now() });
+}
+/**
+ * Reset the session web cache. Public so callers (e.g. `/web-cache clear`
+ * command, or tests) can force a fresh fetch.
+ */
+export function clearWebCache() {
+    webCache.clear();
+}
+/**
+ * Stats about the session web cache — for `/web-cache status`.
+ */
+export function webCacheStats() {
+    return { entries: webCache.size, maxEntries: WEB_CACHE_MAX, ttlMinutes: WEB_CACHE_TTL_MS / 60000 };
+}
+/**
+ * Hosts that only make sense from *inside* the machine or network: loopback,
+ * RFC1918, link-local (which covers the 169.254.169.254 cloud-metadata
+ * endpoint), and `.internal`-style names.
+ *
+ * A user typing `@web http://localhost:3000` is a documented, intended use, so
+ * this is NOT a blanket block — it's only applied to where a fetch *ended up*
+ * after redirects, so a public URL can't bounce us into the private network.
+ */
+function isPrivateHost(hostname) {
+    const h = hostname.toLowerCase().replace(/^\[|\]$/g, '');
+    if (h === 'localhost' || h.endsWith('.localhost') || h.endsWith('.internal') || h.endsWith('.local'))
+        return true;
+    if (h === '::1' || h.startsWith('fc') || h.startsWith('fd') || h.startsWith('fe80:'))
+        return true;
+    const m = h.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+    if (!m)
+        return false;
+    const [a, b] = [Number(m[1]), Number(m[2])];
+    return a === 127 || a === 10 || a === 0
+        || (a === 192 && b === 168)
+        || (a === 172 && b >= 16 && b <= 31)
+        || (a === 169 && b === 254);
+}
+/** Hard ceiling on bytes read from the network, before any text decoding. */
+const MAX_WEB_FETCH_BYTES = MAX_WEB_BYTES * 4;
+async function safeFetch(url, fetchImpl) {
+    const controller = new AbortController();
+    // Kept alive until the BODY is read, not just the headers — clearing it on
+    // header arrival let a slow-drip response hang the chat forever. Cleared in
+    // `finally` so a throw can't leak the timer either.
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const requestedPrivate = (() => {
+            try {
+                return isPrivateHost(new URL(url).hostname);
+            }
+            catch {
+                return false;
+            }
+        })();
+        const res = await fetchImpl(url, {
+            signal: controller.signal,
+            headers: { 'User-Agent': USER_AGENT, Accept: 'text/html, text/plain, */*' },
+            redirect: 'follow',
+        });
+        if (!res.ok) {
+            return { ok: false, reason: `HTTP ${res.status}` };
+        }
+        // SSRF guard: the user vouched for the host they typed, not for wherever
+        // it redirected us. Refuse a public → private hop (cloud metadata, LAN).
+        if (!requestedPrivate && res.url) {
+            try {
+                if (isPrivateHost(new URL(res.url).hostname)) {
+                    return { ok: false, reason: 'redirected to a private/internal address — refused' };
+                }
+            }
+            catch { /* unparseable res.url — fall through */ }
+        }
+        const declared = Number(res.headers.get('content-length') ?? '');
+        if (Number.isFinite(declared) && declared > MAX_WEB_FETCH_BYTES) {
+            return { ok: false, reason: `response too large (${Math.round(declared / 1024)}KB)` };
+        }
+        const contentType = res.headers.get('content-type') ?? '';
+        const text = await readCapped(res);
+        // Plain text or JSON — keep as-is (capped).
+        if (contentType.includes('text/plain') || contentType.includes('application/json')) {
+            const capped = text.length > MAX_WEB_BYTES ? text.slice(0, MAX_WEB_BYTES) + '\n…(truncated)' : text;
+            return { ok: true, title: url, content: capped };
+        }
+        // HTML — strip to readable text.
+        if (contentType.includes('text/html') || contentType.includes('application/xhtml')) {
+            const { title, content } = htmlToText(text);
+            const capped = content.length > MAX_WEB_BYTES ? content.slice(0, MAX_WEB_BYTES) + '\n…(truncated)' : content;
+            return { ok: true, title: title || url, content: capped };
+        }
+        // Anything else (images, PDFs, …) — we can't usefully inline it.
+        return { ok: false, reason: `unsupported content type (${contentType || 'unknown'})` };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('abort'))
+            return { ok: false, reason: `timed out after ${FETCH_TIMEOUT_MS / 1000}s` };
+        return { ok: false, reason: msg };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Read a response body, stopping once `MAX_WEB_FETCH_BYTES` have arrived.
+ *
+ * `res.text()` buffers the whole body first and only then truncates, so a
+ * server streaming gigabytes would OOM the CLI before the cap was applied.
+ * Falls back to `res.text()` when the body isn't a stream (test doubles).
+ */
+async function readCapped(res) {
+    const body = res.body;
+    if (!body || typeof body.getReader !== 'function') {
+        const whole = await res.text();
+        return whole.length > MAX_WEB_FETCH_BYTES ? whole.slice(0, MAX_WEB_FETCH_BYTES) : whole;
+    }
+    const reader = body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value)
+                continue;
+            chunks.push(value);
+            total += value.byteLength;
+            if (total >= MAX_WEB_FETCH_BYTES)
+                break; // stop pulling; cap reached
+        }
+    }
+    finally {
+        try {
+            await reader.cancel();
+        }
+        catch { /* already closed */ }
+    }
+    const joined = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) {
+        joined.set(c, offset);
+        offset += c.byteLength;
+    }
+    return new TextDecoder('utf-8').decode(joined);
+}
+/**
+ * Convert HTML to readable plain text + a title.
+ *
+ * Lightweight — no full parser dependency. Strips `<script>`, `<style>`,
+ * and tags, collapses whitespace, extracts `<title>` and the first
+ * `<h1>` as the page title. Good enough for the agent to read docs;
+ * not a faithful rendering.
+ */
+export function htmlToText(html) {
+    // Title: prefer <title>, fall back to first <h1>.
+    let title = '';
+    const titleMatch = html.match(/<title[^>]*>([^<]*)<\/title>/i);
+    if (titleMatch)
+        title = decodeEntities(titleMatch[1].trim());
+    if (!title) {
+        const h1 = html.match(/<h1[^>]*>([^<]*)<\/h1>/i);
+        if (h1)
+            title = decodeEntities(h1[1].trim());
+    }
+    // Remove script/style/noscript blocks entirely.
+    let body = html
+        .replace(/<script[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[\s\S]*?<\/style>/gi, '')
+        .replace(/<noscript[\s\S]*?<\/noscript>/gi, '')
+        .replace(/<!--[\s\S]*?-->/g, '');
+    // Drop the <head> (we already have the title).
+    body = body.replace(/<head[\s\S]*?<\/head>/gi, '');
+    // Convert block-level tags to newlines so text doesn't run together.
+    body = body.replace(/<\/(p|div|section|article|li|h[1-6]|tr|blockquote|pre)>/gi, '\n');
+    body = body.replace(/<br\s*\/?>/gi, '\n');
+    // Convert links to "text (url)" so the agent keeps the reference.
+    body = body.replace(/<a\s+[^>]*href=["']([^"']+)["'][^>]*>([^<]*)<\/a>/gi, (_m, href, text) => {
+        const t = text.trim();
+        return t ? `${t} (${href})` : '';
+    });
+    // Strip all remaining tags.
+    body = body.replace(/<[^>]+>/g, '');
+    // Decode common HTML entities.
+    body = decodeEntities(body);
+    // Collapse runs of whitespace (but preserve newlines).
+    body = body
+        .split('\n')
+        .map((line) => line.replace(/[ \t]+/g, ' ').trim())
+        .filter((line) => line.length > 0)
+        .join('\n');
+    return { title, content: body };
+}
+/** Decode the handful of HTML entities we're likely to see. */
+function decodeEntities(s) {
+    return s
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&apos;/g, "'")
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&#(\d+);/g, (_m, code) => String.fromCharCode(Number(code)))
+        .replace(/&#x([0-9a-f]+);/gi, (_m, code) => String.fromCharCode(parseInt(code, 16)));
+}
+// ─── Formatting ───────────────────────────────────────────────────────────────
+/** Format the `[Web pages]` block prepended to the enriched prompt. */
+export function formatWebBlock(pages) {
+    if (pages.length === 0)
+        return '';
+    const parts = ['[Web pages]'];
+    for (const p of pages) {
+        const heading = p.title && p.title !== p.url ? `${p.title} — ${p.url}` : p.url;
+        parts.push(`\nURL: ${heading}\n${p.content}`);
+    }
+    return parts.join('\n') + '\n\n';
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "2.14.0";
+export declare const VERSION = "2.16.0";

package/dist/version.js

@@ -1,4 +1,4 @@
 // AUTO-GENERATED by scripts/gen-version.js — do not edit by hand.
 // Baked from package.json at build time so the bun-compiled binary reports
 // the right version (it has no package.json on disk to read at runtime).
-export const VERSION = '2.14.0';
+export const VERSION = '2.16.0';