@spinabot/brigade 0.1.2 → 1.0.1

package/dist/core/provider-quirks.js

@@ -1,285 +0,0 @@
-/**
- * Provider-specific message-shape transforms.
- *
- * Each provider has at least one quirk that breaks an otherwise-valid Pi
- * message before the API accepts it. The fixes here are surgical: each
- * transform is a pure function over `AgentMessage[]`, gated on the active
- * model so we don't pessimize providers that don't need them.
- *
- * Wired via `buildAgent`'s `transformContext` chain. The chain runs every
- * LLM call so the fixes apply to BOTH initial requests and resumed sessions.
- *
- * Quirks handled:
- *   - dropAnthropicThinkingBlocks   — strip stale thinking blocks in history
- *   - sanitizeMistralToolCallIds    — rewrite IDs to Mistral's 9-char format
- *   - downgradeOpenAIResponsesPairs — drop thinking when paired with toolCall
- *   - decodeXaiToolCallArgs (hook)  — decode HTML entities in xAI tool args
- */
-/* ─────────────────────────── 1. Strip stale thinking blocks ─────────────────────────── */
-/**
- * Strip `thinking` content blocks from assistant messages in history.
- * Always-on defensive cleanup with one nuance:
- *
- *   - When the ACTIVE model is Anthropic-compatible, the LATEST assistant
- *     message keeps its thinking block — Anthropic uses the signature for
- *     prompt-cache continuity on the next turn.
- *   - For every other active model (Gemini, OpenAI, Mistral, etc.) we strip
- *     ALL thinking blocks. They have no continuity reason to keep them and
- *     would otherwise reject `{type:"thinking"}` as an unknown content type.
- *
- * Why the nuance matters: the bug Brigade had before this fix was that a
- * /model switch from Anthropic → Gemini left history full of Anthropic
- * thinking blocks. With the OLD provider-conditional gate (only fires when
- * active model is Anthropic), Gemini received them. With this new shape
- * the strip happens for every NON-Anthropic active model, including the
- * mid-conversation switch case.
- *
- * `activeModel` is optional — passing `undefined` means "I don't know the
- * provider; strip everything to be safe." That's the correct default if
- * the caller can't reach session.model for any reason.
- *
- * The cross-provider strip (vs. unconditional Anthropic-shaped strip) is
- * what makes mid-conversation /model switches work cleanly.
- */
-export function dropAnthropicThinkingBlocks(messages, activeModel) {
-    if (!Array.isArray(messages) || messages.length === 0)
-        return messages;
-    // Only preserve the latest assistant's thinking when the active model is
-    // Anthropic-flavored (cache continuity matters). For any other model
-    // — including no model at all — strip every thinking block.
-    const preserveLatestIdx = isAnthropicLikeModel(activeModel)
-        ? findLastAssistantIndex(messages)
-        : -1;
-    let touched = false;
-    const out = messages.map((msg, i) => {
-        const m = msg;
-        if (m?.role !== "assistant" || !Array.isArray(m.content))
-            return msg;
-        if (i === preserveLatestIdx)
-            return msg; // preserve the last one for Anthropic cache
-        const filtered = m.content.filter((b) => b?.type !== "thinking");
-        if (filtered.length === m.content.length)
-            return msg; // nothing changed
-        touched = true;
-        // Anthropic rejects an assistant message with EMPTY content too.
-        // Replace with a single empty text block if dropping thinking left
-        // the message bare.
-        const content = filtered.length > 0 ? filtered : [{ type: "text", text: "" }];
-        return { ...m, content };
-    });
-    return touched ? out : messages;
-}
-function findLastAssistantIndex(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const m = messages[i];
-        if (m?.role === "assistant" && Array.isArray(m.content))
-            return i;
-    }
-    return -1;
-}
-/** Whether the active model is Anthropic-flavored (direct, Bedrock, Vertex, OpenRouter→Anthropic). */
-export function isAnthropicLikeModel(model) {
-    if (!model)
-        return false;
-    const provider = (model.provider ?? "").toLowerCase();
-    const api = (model.api ?? "").toLowerCase();
-    if (provider === "anthropic")
-        return true;
-    if (api === "anthropic-messages")
-        return true;
-    if (provider === "openrouter" && /claude|anthropic/i.test(model.id ?? ""))
-        return true;
-    if (provider === "bedrock" || provider === "vertex")
-        return /claude|anthropic/i.test(model.id ?? "");
-    return false;
-}
-/* ─────────────────────────── 2. Mistral tool-call ID format ─────────────────────────── */
-/**
- * Mistral's tool-call API requires IDs matching `[a-zA-Z0-9]{9}` exactly.
- * Pi/Anthropic emit `toolu_01a2b3c...` (longer, with underscores); OpenAI
- * emits `call_xyz...`. Mistral rejects both.
- *
- * The fix: rewrite IDs in BOTH the assistant's `toolCall` blocks AND the
- * matching `toolResult` messages, keeping the mapping consistent within
- * a single transformContext pass.
- *
- * The 9-char ID is generated deterministically from the original ID so the
- * mapping is stable across re-sends — same input, same output.
- */
-export function sanitizeMistralToolCallIds(messages) {
-    if (!Array.isArray(messages) || messages.length === 0)
-        return messages;
-    const idMap = new Map();
-    const mapId = (orig) => {
-        const cached = idMap.get(orig);
-        if (cached)
-            return cached;
-        // Deterministic 9-char id derived from the original. Hash → base36 → pad/slice.
-        let h = 0;
-        for (let i = 0; i < orig.length; i++) {
-            h = ((h << 5) - h + orig.charCodeAt(i)) | 0;
-        }
-        const positive = h < 0 ? h + 0x80000000 : h;
-        const id = positive.toString(36).padStart(9, "0").slice(-9);
-        idMap.set(orig, id);
-        return id;
-    };
-    const valid = /^[a-zA-Z0-9]{9}$/;
-    let touched = false;
-    const out = messages.map((msg) => {
-        const m = msg;
-        // toolResult messages carry the id at the message level.
-        if (m?.role === "toolResult" && typeof m.toolCallId === "string" && !valid.test(m.toolCallId)) {
-            touched = true;
-            return { ...m, toolCallId: mapId(m.toolCallId) };
-        }
-        // Assistant messages may carry toolCall blocks with ids inside content.
-        if (m?.role === "assistant" && Array.isArray(m.content)) {
-            let blockTouched = false;
-            const newContent = m.content.map((block) => {
-                if (block?.type === "toolCall" && typeof block.id === "string" && !valid.test(block.id)) {
-                    blockTouched = true;
-                    return { ...block, id: mapId(block.id) };
-                }
-                return block;
-            });
-            if (blockTouched) {
-                touched = true;
-                return { ...m, content: newContent };
-            }
-        }
-        return msg;
-    });
-    return touched ? out : messages;
-}
-/** Whether the active model is Mistral. */
-export function isMistralModel(model) {
-    if (!model)
-        return false;
-    const provider = (model.provider ?? "").toLowerCase();
-    if (provider === "mistral" || provider === "mistralai")
-        return true;
-    if (provider === "openrouter" && /mistral|mixtral|codestral/i.test(model.id ?? ""))
-        return true;
-    return false;
-}
-/* ─────────────────────────── 3. OpenAI Responses API downgrade ─────────────────────────── */
-/**
- * OpenAI's Responses API rejects assistant messages that contain BOTH a
- * reasoning block AND a function_call (tool_call) in the same message.
- *
- * The full fix is to strip the reasoning signature from the toolCall id
- * (the `fc_` prefix that pairs it with the reasoning) so OpenAI accepts
- * the call alone.
- *
- * Simpler approximation here: when a message has BOTH thinking AND toolCall,
- * drop the thinking block (the reasoning is gone, but the tool call lives).
- * This costs cache continuity but unblocks the call. Acceptable trade for v1.
- */
-export function downgradeOpenAIResponsesReasoningPairs(messages) {
-    if (!Array.isArray(messages) || messages.length === 0)
-        return messages;
-    let touched = false;
-    const out = messages.map((msg) => {
-        const m = msg;
-        if (m?.role !== "assistant" || !Array.isArray(m.content))
-            return msg;
-        const hasThinking = m.content.some((b) => b?.type === "thinking");
-        const hasToolCall = m.content.some((b) => b?.type === "toolCall");
-        if (!hasThinking || !hasToolCall)
-            return msg;
-        touched = true;
-        const filtered = m.content.filter((b) => b?.type !== "thinking");
-        const content = filtered.length > 0 ? filtered : [{ type: "text", text: "" }];
-        return { ...m, content };
-    });
-    return touched ? out : messages;
-}
-/** Whether the active model uses OpenAI's Responses API. */
-export function isOpenAIResponsesModel(model) {
-    if (!model)
-        return false;
-    const api = (model.api ?? "").toLowerCase();
-    if (api === "openai-responses" || api === "responses")
-        return true;
-    // Models whose ids hint at the Responses API (o1, o3 reasoning models route through it).
-    const provider = (model.provider ?? "").toLowerCase();
-    if (provider === "openai" && /^o[13](?:-|$)/i.test(model.id ?? ""))
-        return true;
-    return false;
-}
-/* ─────────────────────────── 4. xAI tool-call argument decode ─────────────────────────── */
-/**
- * xAI / Grok occasionally returns tool-call argument JSON where string values
- * are HTML-entity-encoded (`&quot;` for `"`, `&amp;` for `&`, etc.). Pi parses
- * the JSON OK but the args object then has unusable strings — `path:
- * "&#x2F;tmp&#x2F;file.txt"` instead of `path: "/tmp/file.txt"`.
- *
- * The cleanest fix is to decode at the stream level, but Brigade has no
- * streamFn hook in v1 (we don't fork Pi's auth wrapper), so we fix at
- * `beforeToolCall` instead: walk the args, decode every string recursively,
- * hand the cleaned args to Pi for execution.
- *
- * This is a function FACTORY because beforeToolCall hooks need to be wired
- * via `buildAgent`'s `beforeToolCall` option. The default unknownToolGuard
- * already runs there; this composes with it by mutating `ctx.toolCall.arguments`
- * in place before the guard sees it.
- */
-const HTML_ENTITY_MAP = {
-    "&quot;": '"',
-    "&amp;": "&",
-    "&lt;": "<",
-    "&gt;": ">",
-    "&#39;": "'",
-    "&apos;": "'",
-    "&nbsp;": " ",
-};
-const HTML_NUMERIC_HEX = /&#x([0-9a-fA-F]+);/g;
-const HTML_NUMERIC_DEC = /&#(\d+);/g;
-const HTML_NAMED = /&(?:quot|amp|lt|gt|apos|nbsp|#39);/g;
-/**
- * Decode HTML entities from a single string. Only fires when the input
- * actually contains entities — the no-entity fast path returns the input
- * unchanged with no allocations.
- */
-export function decodeHtmlEntities(s) {
-    if (typeof s !== "string" || s.indexOf("&") < 0)
-        return s;
-    let out = s.replace(HTML_NAMED, (m) => HTML_ENTITY_MAP[m] ?? m);
-    out = out.replace(HTML_NUMERIC_HEX, (_m, hex) => {
-        const code = parseInt(hex, 16);
-        return Number.isFinite(code) && code >= 0 && code <= 0x10ffff ? String.fromCodePoint(code) : _m;
-    });
-    out = out.replace(HTML_NUMERIC_DEC, (_m, dec) => {
-        const code = parseInt(dec, 10);
-        return Number.isFinite(code) && code >= 0 && code <= 0x10ffff ? String.fromCodePoint(code) : _m;
-    });
-    return out;
-}
-/** Recursively decode every string value in a tool-args object. */
-export function decodeXaiToolCallArgs(args) {
-    if (typeof args === "string")
-        return decodeHtmlEntities(args);
-    if (Array.isArray(args))
-        return args.map((v) => decodeXaiToolCallArgs(v));
-    if (args && typeof args === "object") {
-        const out = {};
-        for (const [k, v] of Object.entries(args)) {
-            out[k] = decodeXaiToolCallArgs(v);
-        }
-        return out;
-    }
-    return args;
-}
-/** Whether the active model is xAI / Grok (or routed via OpenRouter to Grok). */
-export function isXaiModel(model) {
-    if (!model)
-        return false;
-    const provider = (model.provider ?? "").toLowerCase();
-    if (provider === "xai" || provider === "x-ai")
-        return true;
-    if (provider === "openrouter" && /grok|xai|x-ai/i.test(model.id ?? ""))
-        return true;
-    return false;
-}
-//# sourceMappingURL=provider-quirks.js.map

package/dist/core/smart-compaction.js

@@ -1,209 +0,0 @@
-/**
- * Smart tool-result compaction — context-scaled, two-tier (oversized +
- * aggregate) shrinking with head+tail preservation.
- *
- * Brigade's older `truncateOversizedToolResults` was naïve: anything over a
- * fixed 8KB cap got head-truncated. That's fine when ONE tool dumped a big
- * stdout, but pathological when:
- *
- *   - The model has a 200K context — 8K per result is wastefully small
- *   - 30 small-medium tool results collectively bloat past the budget
- *     (each is under 8K so blind truncation does nothing)
- *   - The IMPORTANT part of a tool result is at the END (error tracebacks,
- *     test summary lines) — head-only truncation throws away the diagnostic
- *     and keeps the noisy preamble
- *
- * Smart compaction does three things differently:
- *
- *   1. Budgets are CONTEXT-SCALED — `maxCharsPerResult` defaults to
- *      30% of the model's context window, capped at 16KB.
- *
- *   2. Two-tier scoring:
- *      - PASS 1 (oversized): any single result over `maxCharsPerResult`
- *        is shrunk first. Highest reduction-potential wins.
- *      - PASS 2 (aggregate): if the SUM still exceeds `aggregateBudgetChars`,
- *        walk newest → oldest and shrink each by what's needed, leaving
- *        a `minKeepChars` floor.
- *
- *   3. Head+tail preservation when the truncated text contains error /
- *      summary patterns — keeps the first ~60% AND the last ~40% so a
- *      stack trace at the bottom of a long log is preserved.
- *
- * Pure function. Caller wires it via transformContext.
- */
-const DEFAULT_OVERSIZED_CAP = 16_000;
-const DEFAULT_AGGREGATE_CAP = 64_000;
-const CHARS_PER_TOKEN_ROUGH = 4;
-/**
- * Sane FLOORS so the per-result and aggregate budgets never collapse to
- * effectively-zero on tiny-context models (Cerebras 8K, Groq Llama-3.1-8B
- * 8K). Without these, a 4K context window would derive a 1.2KB per-result
- * cap and a 2KB aggregate budget — every tool result would shrink to almost
- * nothing on every transformContext pass, destroying the model's working
- * memory.
- *
- * Caller can override via explicit `maxCharsPerResult` / `aggregateBudgetChars`
- * options to take a more aggressive cap when they know better.
- */
-const MIN_OVERSIZED_CAP = 2_000;
-const MIN_AGGREGATE_CAP = 4_000;
-/**
- * Default context window assumption when the caller didn't pass one. We use
- * a CONSERVATIVE 32K instead of "Anthropic Sonnet's 200K" so a missing
- * value doesn't grant pathological budgets on a small model. 32K is the
- * common open-source baseline (Mistral, Llama, Qwen) — anything bigger and
- * the caller really should pass `contextWindowTokens` explicitly.
- */
-const SAFE_DEFAULT_CONTEXT_TOKENS = 32_000;
-const ERROR_TAIL_PATTERNS = [
-    /error\b/i,
-    /exception\b/i,
-    /traceback/i,
-    /\bfail(?:ed|ure)?\b/i,
-    /stack\s*trace/i,
-    /\bsegfault/i,
-    /panic\b/i,
-    /^.*(\d+\s+passed.*\d+\s+failed)/im, // pytest-style summary
-];
-/**
- * Walk message history, shrinking tool-result text blocks per the two-tier
- * algorithm. Returns a new array; never mutates the input.
- *
- * Image / non-text content blocks pass through untouched (truncating base64
- * would corrupt them).
- *
- * `transformContext` callers should run this BEFORE sanitizeMessages so
- * truncation markers added here don't get a surrogate-strip pass over them.
- */
-export function smartCompactToolResults(messages, options = {}) {
-    if (!Array.isArray(messages) || messages.length === 0) {
-        return { messages, stats: { oversizedCount: 0, aggregateReducibleChars: 0, totalSavedChars: 0 } };
-    }
-    // Defensive: a missing or non-positive contextWindow falls to a SAFE
-    // 32K default, not the previous 200K. Otherwise an 8K-context Groq /
-    // Cerebras model would inherit Anthropic-Sonnet-sized budgets and never
-    // compact. Negative / zero / NaN all collapse to the safe default.
-    const requestedCtx = options.contextWindowTokens;
-    const ctxTokens = typeof requestedCtx === "number" && Number.isFinite(requestedCtx) && requestedCtx > 0
-        ? requestedCtx
-        : SAFE_DEFAULT_CONTEXT_TOKENS;
-    const ctxChars = ctxTokens * CHARS_PER_TOKEN_ROUGH;
-    // Per-result cap: 30% of context, capped at the oversized ceiling AND
-    // floored at MIN_OVERSIZED_CAP so a 4K model still gets ~2KB per result
-    // (enough to keep one bash output + one read result legible).
-    const maxCharsPerResult = options.maxCharsPerResult ??
-        Math.max(MIN_OVERSIZED_CAP, Math.min(Math.floor(ctxChars * 0.3), DEFAULT_OVERSIZED_CAP));
-    // Aggregate: 50% of context, capped + floored.
-    const aggregateBudget = options.aggregateBudgetChars ??
-        Math.max(MIN_AGGREGATE_CAP, Math.min(Math.floor(ctxChars * 0.5), DEFAULT_AGGREGATE_CAP));
-    // minKeep clamped so it can never EXCEED maxCharsPerResult — that would
-    // cause Pass 2 to try to shrink a result BELOW its already-applied cap,
-    // hitting an infinite "no progress" loop or, worse, growing it back.
-    const requestedMinKeep = options.minKeepChars ?? 2_000;
-    const minKeep = Math.min(maxCharsPerResult, Math.max(200, requestedMinKeep));
-    const preserveTail = options.preserveImportantTail ?? true;
-    const slots = [];
-    for (let mi = 0; mi < messages.length; mi++) {
-        const m = messages[mi];
-        if (m?.role !== "toolResult" || !Array.isArray(m.content))
-            continue;
-        for (let bi = 0; bi < m.content.length; bi++) {
-            const block = m.content[bi];
-            if (block?.type === "text" && typeof block.text === "string") {
-                slots.push({ mi, bi, len: block.text.length });
-            }
-        }
-    }
-    if (slots.length === 0) {
-        return { messages, stats: { oversizedCount: 0, aggregateReducibleChars: 0, totalSavedChars: 0 } };
-    }
-    // Plan reductions per slot (slot key → target length).
-    const targetLength = new Map();
-    const slotKey = (s) => `${s.mi}:${s.bi}`;
-    // PASS 1 — oversized singles get capped to maxCharsPerResult.
-    let oversizedCount = 0;
-    for (const s of slots) {
-        if (s.len > maxCharsPerResult) {
-            oversizedCount++;
-            targetLength.set(slotKey(s), maxCharsPerResult);
-        }
-    }
-    // PASS 2 — aggregate. If the SUM (using post-pass-1 lengths) still
-    // exceeds the aggregate budget, shrink starting from NEWEST to OLDEST
-    // (newer = higher mi) by the amount needed, with a minKeep floor.
-    const lengthAfterPass1 = (s) => targetLength.get(slotKey(s)) ?? s.len;
-    let aggregate = slots.reduce((sum, s) => sum + lengthAfterPass1(s), 0);
-    let aggregateReducibleChars = Math.max(0, aggregate - aggregateBudget);
-    if (aggregate > aggregateBudget) {
-        // Sort newest-first (higher message index first).
-        const ordered = [...slots].sort((a, b) => b.mi - a.mi || b.bi - a.bi);
-        for (const s of ordered) {
-            if (aggregate <= aggregateBudget)
-                break;
-            const current = lengthAfterPass1(s);
-            const reducible = Math.max(0, current - minKeep);
-            if (reducible === 0)
-                continue;
-            const need = aggregate - aggregateBudget;
-            const cut = Math.min(reducible, need);
-            targetLength.set(slotKey(s), current - cut);
-            aggregate -= cut;
-        }
-    }
-    // Apply the plan. If no slot was changed, return the input unchanged.
-    if (targetLength.size === 0) {
-        return {
-            messages,
-            stats: { oversizedCount: 0, aggregateReducibleChars, totalSavedChars: 0 },
-        };
-    }
-    let totalSaved = 0;
-    const changedMsgIndices = new Set([...targetLength.keys()].map((k) => Number(k.split(":")[0])));
-    const out = messages.map((msg, mi) => {
-        if (!changedMsgIndices.has(mi))
-            return msg;
-        const m = msg;
-        const newContent = m.content.map((block, bi) => {
-            const target = targetLength.get(`${mi}:${bi}`);
-            if (target === undefined)
-                return block;
-            if (block?.type !== "text" || typeof block.text !== "string")
-                return block;
-            if (block.text.length <= target)
-                return block;
-            const original = block.text;
-            const truncated = preserveTail && hasErrorPattern(original)
-                ? headAndTail(original, target)
-                : headOnly(original, target);
-            totalSaved += original.length - truncated.length;
-            return { ...block, text: truncated };
-        });
-        return { ...m, content: newContent };
-    });
-    return {
-        messages: out,
-        stats: { oversizedCount, aggregateReducibleChars, totalSavedChars: totalSaved },
-    };
-}
-/* ─────────────────────────── helpers ─────────────────────────── */
-function hasErrorPattern(text) {
-    // Cheap check first — only scan the LAST 4KB where errors typically live.
-    const slice = text.length > 4_000 ? text.slice(-4_000) : text;
-    return ERROR_TAIL_PATTERNS.some((p) => p.test(slice));
-}
-function headOnly(text, targetLen) {
-    const marker = "\n\n⚠️ [...truncated...]\n";
-    const head = Math.max(0, targetLen - marker.length);
-    const cut = text.length - head;
-    return `${text.slice(0, head)}${marker} (${cut} chars removed)`;
-}
-function headAndTail(text, targetLen) {
-    const marker = "\n\n⚠️ [...middle truncated, tail preserved...]\n\n";
-    // 60% head, 40% tail (after marker overhead).
-    const usable = Math.max(0, targetLen - marker.length);
-    const headLen = Math.floor(usable * 0.6);
-    const tailLen = Math.max(0, usable - headLen);
-    const cut = text.length - headLen - tailLen;
-    return `${text.slice(0, headLen)}${marker}(${cut} chars removed)\n\n${text.slice(text.length - tailLen)}`;
-}
-//# sourceMappingURL=smart-compaction.js.map