@animalabs/membrane 0.5.80 → 0.5.81

package/dist/utils/cache-marker-budget.js

@@ -0,0 +1,189 @@
+/**
+ * One recount of the cache_control markers actually present on a wire
+ * request, plus the clamp that keeps that count legal.
+ *
+ * Anthropic accepts at most 4 cache_control breakpoints per request and
+ * rejects the fifth with a non-retryable 400 ("A maximum of 4 blocks with
+ * cache_control may be provided. Found 5." — measured live 2026-08-25).
+ * Markers arrive from many sites (context strategy breakpoints, block-level
+ * passthrough on imported histories, the tools/system fallback, the floating
+ * tool-loop marker, caller-marked system blocks, and any beforeRequest hook),
+ * and every one of them is invisible to the others' running tallies. The
+ * only trustworthy number is a recount of the constructed artifacts, so this
+ * module owns it and every site calls it.
+ *
+ * A marker can also ride a block NESTED inside another block's content array
+ * (`tool_result.content` is `string | ContentBlock[]`, passed through to the
+ * wire verbatim), so discovery recurses. A belt that cannot see a marker
+ * cannot clamp it, and a top-level-only count would report four while five
+ * shipped — the request rejected outright with the belt's blessing.
+ */
+/** Anthropic's hard limit on cache_control breakpoints per request. */
+export const MAX_CACHE_BREAKPOINTS = 4;
+/**
+ * How many levels of nested `content` arrays marker discovery descends below
+ * a top-level block.
+ *
+ * A marker can ride a block inside another block's own content array —
+ * `ToolResultContent.content` is typed `string | ContentBlock[]` and every
+ * builder passes it through verbatim, so a caller-built tool_result whose
+ * members carry `cache_control` puts real markers on the wire. The API's own
+ * nesting is one level deep; 4 is headroom for shapes it grows later, and it
+ * is also what makes this walk TOTAL — a caller-built structure that points
+ * back at itself terminates at the cap instead of hanging the request.
+ * Markers below the cap are outside the belt's reach, by construction.
+ */
+export const MAX_NESTED_CONTENT_DEPTH = 4;
+/**
+ * Walk one candidate block and everything nested under it, in document order
+ * (a block before its own content), applying `visitBlock` to each object.
+ *
+ * This is the single traversal law: marker discovery and the ownership copy
+ * that protects caller-owned blocks from it both descend exactly here, so
+ * the clamp can never reach a grain that ownership did not copy.
+ */
+function walkBlockTree(candidate, depth, visitBlock) {
+    if (!candidate || typeof candidate !== 'object')
+        return;
+    const block = candidate;
+    visitBlock(block);
+    const nested = nestedContentBlocks(block, depth);
+    if (!nested)
+        return;
+    for (const child of nested)
+        walkBlockTree(child, depth + 1, visitBlock);
+}
+/**
+ * The one rule for what counts as nested content: an array-valued `content`
+ * on a block, while still above the depth cap. Discovery and the ownership
+ * copy both ask here, so neither can descend where the other does not.
+ */
+function nestedContentBlocks(block, depth) {
+    if (depth >= MAX_NESTED_CONTENT_DEPTH)
+        return undefined;
+    return Array.isArray(block.content) ? block.content : undefined;
+}
+/**
+ * Every marker-bearing block on the request, in WIRE ORDER (tools, then
+ * system blocks, then message blocks) and, within each, in DOCUMENT order —
+ * a block before anything nested inside its own content. Order is what makes
+ * "deepest" mean anything: a deeper marker caches a longer prefix.
+ *
+ * ONE walk serves both the count and the clamp's strip, so a marker the
+ * counter can see is always a marker the clamp can strip. A collector that
+ * stopped at the top level would count four while five rode to the wire, and
+ * the provider would reject the request the belt just declared legal.
+ */
+function collectMarkedBlocks(surfaces) {
+    const marked = [];
+    const collectIfMarked = (candidate) => walkBlockTree(candidate, 0, (block) => {
+        if (block.cache_control)
+            marked.push(block);
+    });
+    if (Array.isArray(surfaces.tools)) {
+        for (const tool of surfaces.tools)
+            collectIfMarked(tool);
+    }
+    if (Array.isArray(surfaces.system)) {
+        for (const block of surfaces.system)
+            collectIfMarked(block);
+    }
+    if (Array.isArray(surfaces.messages)) {
+        for (const message of surfaces.messages) {
+            const content = message?.content;
+            if (Array.isArray(content)) {
+                for (const block of content)
+                    collectIfMarked(block);
+            }
+            else {
+                collectIfMarked(content);
+            }
+        }
+    }
+    return marked;
+}
+/**
+ * Take ownership of a system surface before it can reach the clamp.
+ *
+ * `request.system` accepts caller-marked blocks, and the builders pass that
+ * array through by reference when they add no marker of their own. The clamp
+ * strips markers IN PLACE at the wire boundary — correct for blocks membrane
+ * built, catastrophic for the caller's own array, which a long-lived caller
+ * reuses turn after turn: one over-budget request would silently delete the
+ * caller's breakpoints for the life of that object. Copying the array and its
+ * blocks at build time keeps the clamp's mutations inside the request.
+ *
+ * The copy descends exactly as far as marker discovery does: a shallow
+ * `{...block}` leaves any nested `content` array shared with the caller, and
+ * the clamp now strips markers at that grain, so ownership has to reach it
+ * too or the leak just moves one level down.
+ */
+export function ownSystemBlocks(system) {
+    if (!Array.isArray(system))
+        return system;
+    return system.map((block) => copyBlockTree(block, 0));
+}
+/**
+ * Shallow-copy a block and, recursively, its nested content blocks, to the
+ * same depth marker discovery walks. Non-objects pass through untouched.
+ */
+function copyBlockTree(candidate, depth) {
+    if (!candidate || typeof candidate !== 'object')
+        return candidate;
+    const copy = { ...candidate };
+    const nested = nestedContentBlocks(copy, depth);
+    if (nested)
+        copy.content = nested.map((child) => copyBlockTree(child, depth + 1));
+    return copy;
+}
+/** How many cache_control markers this request would actually put on the wire. */
+export function countWireCacheMarkers(surfaces) {
+    return collectMarkedBlocks(surfaces).length;
+}
+/**
+ * Bring a request inside the breakpoint budget, in place, at the last exit
+ * before the adapter call. Two repairs, both loud:
+ *
+ *  1. a marker riding a thinking / redacted_thinking block is stripped — the
+ *     API rejects those outright ("thinking.cache_control: Extra inputs are
+ *     not permitted"), and the three builders' `lastCacheableBlockIndex`
+ *     discipline is only as good as its last caller. This is the runtime
+ *     assertion; a fourth builder can no longer repeat that history.
+ *  2. markers past the limit are dropped SHALLOWEST-FIRST, keeping the 4
+ *     deepest — the deepest marker caches the longest prefix, and every
+ *     shallower prefix it subsumes.
+ *
+ * Dropping loudly beats a 400: the request still ships, cached less than the
+ * caller asked for, with the overspend named.
+ */
+export function clampCacheMarkers(surfaces, site) {
+    const marked = collectMarkedBlocks(surfaces);
+    let strippedFromThinking = 0;
+    const cacheable = [];
+    for (const block of marked) {
+        if (block.type === 'thinking' || block.type === 'redacted_thinking') {
+            delete block.cache_control;
+            strippedFromThinking++;
+            continue;
+        }
+        cacheable.push(block);
+    }
+    let dropped = 0;
+    if (cacheable.length > MAX_CACHE_BREAKPOINTS) {
+        for (const block of cacheable.slice(0, cacheable.length - MAX_CACHE_BREAKPOINTS)) {
+            delete block.cache_control;
+            dropped++;
+        }
+    }
+    if (strippedFromThinking > 0) {
+        console.warn(`[membrane] ${site}: stripped ${strippedFromThinking} cache_control marker(s) from ` +
+            `thinking blocks — the API rejects cache_control on thinking/redacted_thinking.`);
+    }
+    if (dropped > 0) {
+        console.warn(`[membrane] ${site}: ${cacheable.length} cache_control markers exceed the limit of ` +
+            `${MAX_CACHE_BREAKPOINTS} — dropped the ${dropped} shallowest and kept the deepest ` +
+            `${MAX_CACHE_BREAKPOINTS}. The request would otherwise have been rejected outright.`);
+    }
+    return { total: cacheable.length - dropped, dropped, strippedFromThinking };
+}
+//# sourceMappingURL=cache-marker-budget.js.map

package/dist/utils/cache-marker-budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-marker-budget.js","sourceRoot":"","sources":["../../src/utils/cache-marker-budget.ts"],"names":[],"mappings":"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"}

package/dist/utils/cost.d.ts

@@ -6,5 +6,27 @@ export interface CostableUsage {
     cacheCreationTokens?: number;
     cacheReadTokens?: number;
 }
+/**
+ * Say once, per model, that membrane has no rates for it — so an omitted
+ * `estimatedCost` reads as "unknown" rather than "free" to a caller who only
+ * ever sees the absence.
+ */
+export declare function warnUnpricedModel(modelId: string): void;
+/** Test seam: the once-per-model warn latch is process-wide otherwise. */
+export declare function resetUnpricedModelWarnings(): void;
+/**
+ * Add two breakdowns that may have been priced at DIFFERENT rates — the
+ * multi-round case, where each round is priced under the model that served it
+ * and the turn total is their sum.
+ *
+ * `pricingAsOf` takes the OLDER of the two: a total is only as fresh as its
+ * stalest input, and a round whose source vouches for NO date is stalest of
+ * all — one unstamped round leaves the sum unstamped. A currency mismatch is
+ * not summable at all (the caller's
+ * registry priced two rounds in different currencies and membrane has no rate
+ * to convert with), so it returns undefined rather than adding dollars to
+ * euros — an absent cost says "membrane does not know", which is true.
+ */
+export declare function addCostBreakdowns(a: CostBreakdown, b: CostBreakdown): CostBreakdown | undefined;
 export declare function calculateCost(usage: CostableUsage, pricing: ModelPricing): CostBreakdown;
 //# sourceMappingURL=cost.d.ts.map

package/dist/utils/cost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../../src/utils/cost.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,GAAG,aAAa,CAkBxF"}
+{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../../src/utils/cost.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAKD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAQvD;AAED,0EAA0E;AAC1E,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,GACf,aAAa,GAAG,SAAS,CAsB3B;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,YAAY,GAAG,aAAa,CAmBxF"}

package/dist/utils/cost.js

@@ -1,3 +1,57 @@
+/** Unpriced models warn once each, not once per call. */
+const warnedUnpricedModels = new Set();
+/**
+ * Say once, per model, that membrane has no rates for it — so an omitted
+ * `estimatedCost` reads as "unknown" rather than "free" to a caller who only
+ * ever sees the absence.
+ */
+export function warnUnpricedModel(modelId) {
+    if (warnedUnpricedModels.has(modelId))
+        return;
+    warnedUnpricedModels.add(modelId);
+    console.warn(`[membrane:cost] no pricing for model "${modelId}" — neither the configured`
+        + ' ModelRegistry nor the built-in table has rates for it, so estimatedCost will be'
+        + ' omitted (this is NOT a cost of zero). Add it to your registry to get cost estimates.');
+}
+/** Test seam: the once-per-model warn latch is process-wide otherwise. */
+export function resetUnpricedModelWarnings() {
+    warnedUnpricedModels.clear();
+}
+/**
+ * Add two breakdowns that may have been priced at DIFFERENT rates — the
+ * multi-round case, where each round is priced under the model that served it
+ * and the turn total is their sum.
+ *
+ * `pricingAsOf` takes the OLDER of the two: a total is only as fresh as its
+ * stalest input, and a round whose source vouches for NO date is stalest of
+ * all — one unstamped round leaves the sum unstamped. A currency mismatch is
+ * not summable at all (the caller's
+ * registry priced two rounds in different currencies and membrane has no rate
+ * to convert with), so it returns undefined rather than adding dollars to
+ * euros — an absent cost says "membrane does not know", which is true.
+ */
+export function addCostBreakdowns(a, b) {
+    if (a.currency !== b.currency)
+        return undefined;
+    const cacheWrite = a.cacheWrite != null || b.cacheWrite != null
+        ? (a.cacheWrite ?? 0) + (b.cacheWrite ?? 0)
+        : undefined;
+    const cacheRead = a.cacheRead != null || b.cacheRead != null
+        ? (a.cacheRead ?? 0) + (b.cacheRead ?? 0)
+        : undefined;
+    const oldestAsOf = a.pricingAsOf && b.pricingAsOf
+        ? (a.pricingAsOf < b.pricingAsOf ? a.pricingAsOf : b.pricingAsOf)
+        : undefined;
+    return {
+        input: a.input + b.input,
+        output: a.output + b.output,
+        cacheWrite,
+        cacheRead,
+        total: a.total + b.total,
+        currency: a.currency,
+        ...(oldestAsOf ? { pricingAsOf: oldestAsOf } : {}),
+    };
+}
 export function calculateCost(usage, pricing) {
     const input = usage.inputTokens * pricing.inputPerMillion / 1_000_000;
     const output = usage.outputTokens * pricing.outputPerMillion / 1_000_000;
@@ -14,6 +68,7 @@ export function calculateCost(usage, pricing) {
         cacheRead,
         total: input + output + (cacheWrite ?? 0) + (cacheRead ?? 0),
         currency: pricing.currency,
+        ...(pricing.asOf ? { pricingAsOf: pricing.asOf } : {}),
     };
 }
 //# sourceMappingURL=cost.js.map

package/dist/utils/cost.js.map

@@ -1 +1 @@
-{"version":3,"file":"cost.js","sourceRoot":"","sources":["../../src/utils/cost.ts"],"names":[],"mappings":"AAUA,MAAM,UAAU,aAAa,CAAC,KAAoB,EAAE,OAAqB;IACvE,MAAM,KAAK,GAAG,KAAK,CAAC,WAAW,GAAG,OAAO,CAAC,eAAe,GAAG,SAAS,CAAC;IACtE,MAAM,MAAM,GAAG,KAAK,CAAC,YAAY,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IACzE,MAAM,UAAU,GAAG,OAAO,CAAC,oBAAoB,IAAI,IAAI;QACrD,CAAC,CAAC,CAAC,KAAK,CAAC,mBAAmB,IAAI,CAAC,CAAC,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS;QAC7E,CAAC,CAAC,SAAS,CAAC;IACd,MAAM,SAAS,GAAG,OAAO,CAAC,mBAAmB,IAAI,IAAI;QACnD,CAAC,CAAC,CAAC,KAAK,CAAC,eAAe,IAAI,CAAC,CAAC,GAAG,OAAO,CAAC,mBAAmB,GAAG,SAAS;QACxE,CAAC,CAAC,SAAS,CAAC;IAEd,OAAO;QACL,KAAK;QACL,MAAM;QACN,UAAU;QACV,SAAS;QACT,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,CAAC,UAAU,IAAI,CAAC,CAAC,GAAG,CAAC,SAAS,IAAI,CAAC,CAAC;QAC5D,QAAQ,EAAE,OAAO,CAAC,QAAQ;KAC3B,CAAC;AACJ,CAAC"}
+{"version":3,"file":"cost.js","sourceRoot":"","sources":["../../src/utils/cost.ts"],"names":[],"mappings":"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"}

package/dist/utils/thinking-carriers.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Helpers for pairing provider-native thinking carriers (which hold the
+ * signatures) with parser-derived thinking blocks (which hold the text).
+ * See Membrane.mergeProviderThinkingBlocks for the pairing rules.
+ */
+import type { ContentBlock } from '../types/index.js';
+/**
+ * Identity for thinking text, insensitive to exactly two artifacts that ride
+ * the parser's view of the same reasoning — and to nothing else:
+ *
+ *  - stream scaffolding: the XML path prefills `Claude: <thinking>` and asks
+ *    the adapter to wrap native thinking deltas, so a parsed block can carry
+ *    a literal `<thinking>` / `</thinking>` tag the provider block never had.
+ *  - OUTER boundary whitespace: the continuation path trims the accumulation
+ *    at each round boundary (`buildContinuationRequest` trimEnds before
+ *    re-prefilling), so a fragment and the parsed text can differ by leading
+ *    or trailing whitespace.
+ *
+ * INTERNAL whitespace is payload and is compared verbatim. Erasing it (the
+ * first implementation stripped every `\s`) makes distinct signed payloads
+ * collide on nothing but where their spaces fall, and the caller then stamps
+ * one payload's signature onto the other's text — a carrier that fails
+ * Anthropic signature validation when the consumer ships its history back.
+ *
+ * Comparison only — stored text is never rewritten. Empty text is never
+ * identical to anything: signature-only carriers are prepend-only.
+ */
+export declare function sameThinkingText(left: string, right: string): boolean;
+/**
+ * Find a RUN of consecutive still-unpaired provider blocks whose concatenated
+ * thinking reconstructs `parsedText` (an auto-continuation split across a
+ * max_tokens boundary). Returns the provider indices in order, or undefined
+ * when no run of two or more reconstructs it.
+ *
+ * Two joins are tried, because the round boundary itself is the one place a
+ * fragment's whitespace can legitimately vanish: `buildContinuationRequest`
+ * trimEnds the accumulation before re-prefilling, so the resumed text may
+ * pick up exactly where the trim left off. Modelling that single
+ * transformation keeps internal whitespace comparable everywhere else —
+ * `sameThinkingText` treats it as payload.
+ */
+export declare function findSpanningProviderRun(providerThinking: Array<{
+    thinking?: string;
+    signature?: string;
+}>, pairedProviderBlocks: ReadonlySet<number>, parsedText: string): number[] | undefined;
+/**
+ * Drop the extended-thinking config from a prefill-shaped provider request —
+ * from BOTH channels the `thinkingEnabled` resolver reads.
+ *
+ * Whether the API rejects thinking beside an assistant prefill is MODEL
+ * DEPENDENT, not a universal law. Measured live 2026-08-25 against the
+ * Anthropic Messages API: `claude-haiku-4-5-20251001` accepts an assistant
+ * prefill together with `thinking: {type: 'enabled'}` (HTTP 200, and the
+ * response carries no thinking block), while `claude-sonnet-4-6` refuses
+ * assistant prefill outright — HTTP 400, "This model does not support
+ * assistant message prefill."
+ *
+ * So the strip is the prefill path's DESIGN wherever prefill works: the XML
+ * formatter uses the thinking config to emit a literal `<thinking>` text
+ * prefix rather than the API feature, and sending both pays for API thinking
+ * the prefill format does not consume. On models that reject the combination
+ * it is additionally the 400 guard it always was. Either way both channels
+ * must agree, and the guard that only deleted the top-level field left
+ * `extra.thinking` (spread from `providerParams`) riding the adapter's
+ * `Object.assign(params, rest)` onto the wire — reproducing both the 400 and
+ * the interleaved-thinking beta header, since the resolver correctly saw the
+ * smuggled config. Mutates and returns the request; callers must own `extra`
+ * (never alias the caller's `providerParams`).
+ */
+export declare function stripThinkingForPrefill<T extends {
+    thinking?: unknown;
+    extra?: unknown;
+}>(providerRequest: T): T;
+/**
+ * De-duplication key for a thinking / redacted_thinking carrier: two carriers
+ * are the same carrier when their payload and signature match. Any other block
+ * type gets a unique key so it can never collide.
+ */
+export declare function thinkingCarrierKey(block: ContentBlock): string;
+//# sourceMappingURL=thinking-carriers.d.ts.map

package/dist/utils/thinking-carriers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-carriers.d.ts","sourceRoot":"","sources":["../../src/utils/thinking-carriers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAOrE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,gBAAgB,EAAE,KAAK,CAAC;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,EAClE,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAAC,EACzC,UAAU,EAAE,MAAM,GACjB,MAAM,EAAE,GAAG,SAAS,CAmBtB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,EACvF,eAAe,EAAE,CAAC,GACjB,CAAC,CAOH;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAS9D"}

package/dist/utils/thinking-carriers.js

@@ -0,0 +1,115 @@
+/**
+ * Identity for thinking text, insensitive to exactly two artifacts that ride
+ * the parser's view of the same reasoning — and to nothing else:
+ *
+ *  - stream scaffolding: the XML path prefills `Claude: <thinking>` and asks
+ *    the adapter to wrap native thinking deltas, so a parsed block can carry
+ *    a literal `<thinking>` / `</thinking>` tag the provider block never had.
+ *  - OUTER boundary whitespace: the continuation path trims the accumulation
+ *    at each round boundary (`buildContinuationRequest` trimEnds before
+ *    re-prefilling), so a fragment and the parsed text can differ by leading
+ *    or trailing whitespace.
+ *
+ * INTERNAL whitespace is payload and is compared verbatim. Erasing it (the
+ * first implementation stripped every `\s`) makes distinct signed payloads
+ * collide on nothing but where their spaces fall, and the caller then stamps
+ * one payload's signature onto the other's text — a carrier that fails
+ * Anthropic signature validation when the consumer ships its history back.
+ *
+ * Comparison only — stored text is never rewritten. Empty text is never
+ * identical to anything: signature-only carriers are prepend-only.
+ */
+export function sameThinkingText(left, right) {
+    if (left === right)
+        return left !== '';
+    if (left === '' || right === '')
+        return false;
+    const normalized = (text) => text.replace(/<\/?(antml:)?thinking>/g, '').trim();
+    const normalizedLeft = normalized(left);
+    if (normalizedLeft === '')
+        return false;
+    return normalizedLeft === normalized(right);
+}
+/**
+ * Find a RUN of consecutive still-unpaired provider blocks whose concatenated
+ * thinking reconstructs `parsedText` (an auto-continuation split across a
+ * max_tokens boundary). Returns the provider indices in order, or undefined
+ * when no run of two or more reconstructs it.
+ *
+ * Two joins are tried, because the round boundary itself is the one place a
+ * fragment's whitespace can legitimately vanish: `buildContinuationRequest`
+ * trimEnds the accumulation before re-prefilling, so the resumed text may
+ * pick up exactly where the trim left off. Modelling that single
+ * transformation keeps internal whitespace comparable everywhere else —
+ * `sameThinkingText` treats it as payload.
+ */
+export function findSpanningProviderRun(providerThinking, pairedProviderBlocks, parsedText) {
+    for (let start = 0; start < providerThinking.length; start++) {
+        if (pairedProviderBlocks.has(start))
+            continue;
+        const firstFragment = providerThinking[start].thinking ?? '';
+        let verbatimJoin = firstFragment;
+        let trimmedJoin = firstFragment;
+        const run = [start];
+        for (let next = start + 1; next < providerThinking.length; next++) {
+            if (pairedProviderBlocks.has(next))
+                break;
+            const fragment = providerThinking[next].thinking ?? '';
+            verbatimJoin += fragment;
+            trimmedJoin = trimmedJoin.trimEnd() + fragment;
+            run.push(next);
+            if (sameThinkingText(verbatimJoin, parsedText) || sameThinkingText(trimmedJoin, parsedText)) {
+                return [...run];
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Drop the extended-thinking config from a prefill-shaped provider request —
+ * from BOTH channels the `thinkingEnabled` resolver reads.
+ *
+ * Whether the API rejects thinking beside an assistant prefill is MODEL
+ * DEPENDENT, not a universal law. Measured live 2026-08-25 against the
+ * Anthropic Messages API: `claude-haiku-4-5-20251001` accepts an assistant
+ * prefill together with `thinking: {type: 'enabled'}` (HTTP 200, and the
+ * response carries no thinking block), while `claude-sonnet-4-6` refuses
+ * assistant prefill outright — HTTP 400, "This model does not support
+ * assistant message prefill."
+ *
+ * So the strip is the prefill path's DESIGN wherever prefill works: the XML
+ * formatter uses the thinking config to emit a literal `<thinking>` text
+ * prefix rather than the API feature, and sending both pays for API thinking
+ * the prefill format does not consume. On models that reject the combination
+ * it is additionally the 400 guard it always was. Either way both channels
+ * must agree, and the guard that only deleted the top-level field left
+ * `extra.thinking` (spread from `providerParams`) riding the adapter's
+ * `Object.assign(params, rest)` onto the wire — reproducing both the 400 and
+ * the interleaved-thinking beta header, since the resolver correctly saw the
+ * smuggled config. Mutates and returns the request; callers must own `extra`
+ * (never alias the caller's `providerParams`).
+ */
+export function stripThinkingForPrefill(providerRequest) {
+    delete providerRequest.thinking;
+    const extra = providerRequest.extra;
+    if (extra && typeof extra === 'object') {
+        delete extra.thinking;
+    }
+    return providerRequest;
+}
+/**
+ * De-duplication key for a thinking / redacted_thinking carrier: two carriers
+ * are the same carrier when their payload and signature match. Any other block
+ * type gets a unique key so it can never collide.
+ */
+export function thinkingCarrierKey(block) {
+    if (block.type === 'thinking') {
+        const { thinking, signature } = block;
+        return `thinking\u0000${thinking ?? ''}\u0000${signature ?? ''}`;
+    }
+    if (block.type === 'redacted_thinking') {
+        return `redacted\u0000${block.data ?? ''}`;
+    }
+    return `other\u0000${JSON.stringify(block)}`;
+}
+//# sourceMappingURL=thinking-carriers.js.map

package/dist/utils/thinking-carriers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking-carriers.js","sourceRoot":"","sources":["../../src/utils/thinking-carriers.ts"],"names":[],"mappings":"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"}

package/dist/utils/tool-parser.d.ts

@@ -80,6 +80,30 @@ export declare function parseAccumulatedIntoBlocks(text: string, options?: {
     blocks: ContentBlock[];
     toolCalls: ToolCall[];
     toolResults: ToolResult[];
+    /**
+     * The text ends inside a tool block — an opener with no closer, or a cut
+     * mid-tag. The membrane loop does not resume on a length stop, so this is
+     * what a max_tokens truncation leaves behind, and persisting it bare lets the
+     * next round's closer splice onto the stale opener.
+     */
+    unclosedToolBlock: boolean;
+    /**
+     * function_calls blocks that yielded no invokes at all. Always a defect —
+     * never how a well-formed block ends.
+     */
+    emptyToolBlocks: number;
+    /**
+     * Block matches that spanned another opener and were re-anchored to the
+     * innermost one. Each is a truncated block that was persisted bare and is
+     * being repaired at read time.
+     */
+    splicedToolBlocks: number;
+    /**
+     * `<invoke>` heads that were left open and swallowed a later invoke, so the
+     * match was refused and re-anchored to the call it absorbed. Nothing was
+     * dispatched under the head's name, and the head itself never ran.
+     */
+    unclosedInvokeHeads: number;
 };
 import type { ToolDefinition } from '../types/index.js';
 /**

package/dist/utils/tool-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-parser.d.ts","sourceRoot":"","sources":["../../src/utils/tool-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,eAAe,EAAE,YAAY,EAA0B,MAAM,mBAAmB,CAAC;AAmDrH;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAqFnE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQ1D;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQ9D;AAkCD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,MAAM,CAsB/D;AAqBD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAE3D;AAMD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;QACzB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;KACjB,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,uBAAuB,EAAE,GAAG,MAAM,CA0B9E;AA0BD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IAAE,gBAAgB,CAAC,EAAE,UAAU,GAAG,WAAW,GAAG,aAAa,CAAA;CAAE,GACxE;IACD,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B,CAqPA;AAMD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAUxD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,MAAM,CAsBnE;AAMD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE;QACN,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CASpE;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gFAAgF;IAChF,cAAc,EAAE,MAAM,CAAC;IAEvB,yDAAyD;IACzD,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAE7B,uEAAuE;IACvE,aAAa,EAAE,MAAM,CAAC;IAEtB,oCAAoC;IACpC,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,gBAAgB,CAuFrF;AA8CD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOhD"}
+{"version":3,"file":"tool-parser.d.ts","sourceRoot":"","sources":["../../src/utils/tool-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,eAAe,EAAE,YAAY,EAA0B,MAAM,mBAAmB,CAAC;AA0OrH;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAiCnE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQ1D;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQ9D;AAkCD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,MAAM,CAsB/D;AAqBD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAE3D;AAMD,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE;QACzB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;KACjB,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,uBAAuB,EAAE,GAAG,MAAM,CA0B9E;AAkKD;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IAAE,gBAAgB,CAAC,EAAE,UAAU,GAAG,WAAW,GAAG,aAAa,CAAA;CAAE,GACxE;IACD,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B;;;;;OAKG;IACH,iBAAiB,EAAE,OAAO,CAAC;IAC3B;;;OAGG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CA6PA;AAMD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAUxD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,MAAM,CAsBnE;AAMD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE;QACN,IAAI,EAAE,QAAQ,CAAC;QACf,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CASpE;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gFAAgF;IAChF,cAAc,EAAE,MAAM,CAAC;IAEvB,yDAAyD;IACzD,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAE7B,uEAAuE;IACvE,aAAa,EAAE,MAAM,CAAC;IAEtB,oCAAoC;IACpC,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,UAAU,EAAE,GAAG,gBAAgB,CAuFrF;AA8CD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOhD"}