agentfootprint 9.136.0 → 9.138.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfootprint",
-  "version": "9.136.0",
+  "version": "9.138.0",
   "description": "The explainable agent framework — backtrack a wrong answer to the exact context that caused it (evidence, not guesses). Built on footprintjs.",
   "license": "MIT",
   "type": "commonjs",
@@ -356,10 +356,6 @@
     }
   },
   "sideEffects": [
-    "./dist/index.js",
-    "./dist/esm/index.js",
-    "**/cache/strategies/*.js",
-    "**/cache/index.js",
     "**/lib/injection-engine/index.js",
     "**/lib/injection-engine/devWarnHost.js"
   ],

package/dist/cache/strategies/AnthropicCacheStrategy.js

@@ -1,90 +0,0 @@
-"use strict";
-/**
- * AnthropicCacheStrategy — translates agnostic CacheMarker[] to
- * Anthropic API's `cache_control: { type: 'ephemeral' }` markers.
- *
- * Anthropic-specific behaviors honored:
- *   - **4-marker limit**: Anthropic allows ≤4 cache breakpoints per
- *     request. Strategy clamps oversize candidate sets, keeping the
- *     first 4 in slot order.
- *   - **TTL mapping**: 'short' → default 5min ephemeral; 'long' →
- *     `ttl: '1h'` (1-hour beta).
- *   - **Provider-side hashing**: this strategy doesn't hash — Anthropic
- *     keys cache by exact byte prefix server-side. We don't need
- *     content hashes for the v2.6 surface; reserved for v2.7+ if a
- *     pre-flight cache-warm-check API ships.
- *
- * What this strategy DOES vs DOESN'T do:
- *   - DOES: clamp markers, attach to LLMRequest.cacheMarkers,
- *     read cache metrics off the PORT usage the framework hands it
- *     (`{ input, output, cacheRead?, cacheWrite? }`) — never off the raw
- *     Anthropic wire, which the adapter has already normalised
- *   - DOES NOT: rewrite the wire body. The provider
- *     (BrowserAnthropicProvider) reads `cacheMarkers` and applies
- *     `cache_control` blocks during body construction. Separation of
- *     concerns: strategy decides WHAT to cache; provider knows HOW
- *     to encode on its specific wire.
- *
- * Auto-registers in the strategy registry on module import for
- * provider names: 'anthropic', 'browser-anthropic'.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnthropicCacheStrategy = void 0;
-const portUsage_js_1 = require("../portUsage.js");
-const strategyRegistry_js_1 = require("../strategyRegistry.js");
-/** Anthropic enforces 4 cache breakpoints per request. */
-const ANTHROPIC_MAX_MARKERS = 4;
-const ANTHROPIC_CAPABILITIES = Object.freeze({
-    enabled: true,
-    maxMarkers: ANTHROPIC_MAX_MARKERS,
-    ttls: ['short', 'long'],
-    fields: ['system', 'tools', 'messages'],
-    automatic: false,
-});
-class AnthropicCacheStrategy {
-    providerName = 'anthropic';
-    capabilities = ANTHROPIC_CAPABILITIES;
-    async prepareRequest(req, candidates, ctx) {
-        // Honor the agent-side kill switch even if reached this far —
-        // belt-and-suspenders. CacheGate should have routed to no-markers
-        // already, leaving `candidates` empty, but if a buggy gate lets
-        // markers through with cachingDisabled=true, we still respect it.
-        if (ctx.cachingDisabled) {
-            return { request: req, markersApplied: [] };
-        }
-        if (candidates.length === 0) {
-            return { request: req, markersApplied: [] };
-        }
-        // Clamp to Anthropic's 4-marker limit. Keep the first N in
-        // slot order so we cover the most-stable prefixes (system /
-        // always-on injections / tools) before less-stable trailing ones.
-        const markersApplied = candidates.length <= ANTHROPIC_MAX_MARKERS
-            ? candidates
-            : candidates.slice(0, ANTHROPIC_MAX_MARKERS);
-        const request = {
-            ...req,
-            cacheMarkers: markersApplied,
-        };
-        return { request, markersApplied };
-    }
-    extractMetrics(usage) {
-        return (0, portUsage_js_1.readPortCacheUsage)(usage, 'the Anthropic adapter');
-    }
-}
-exports.AnthropicCacheStrategy = AnthropicCacheStrategy;
-// Auto-register on module import. Both 'anthropic' (server-side) and
-// 'browser-anthropic' (browser fetch) providers map to this strategy.
-{
-    const strategy = new AnthropicCacheStrategy();
-    (0, strategyRegistry_js_1.registerCacheStrategy)(strategy);
-    // Register the browser variant by cloning with the matching provider name.
-    // Same behavior, different provider.name match-key.
-    const browserStrategy = {
-        providerName: 'browser-anthropic',
-        capabilities: strategy.capabilities,
-        prepareRequest: strategy.prepareRequest.bind(strategy),
-        extractMetrics: strategy.extractMetrics.bind(strategy),
-    };
-    (0, strategyRegistry_js_1.registerCacheStrategy)(browserStrategy);
-}
-//# sourceMappingURL=AnthropicCacheStrategy.js.map

package/dist/cache/strategies/AnthropicCacheStrategy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AnthropicCacheStrategy.js","sourceRoot":"","sources":["../../../src/cache/strategies/AnthropicCacheStrategy.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;;;AAWH,kDAAqD;AAErD,gEAA+D;AAE/D,0DAA0D;AAC1D,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAEhC,MAAM,sBAAsB,GAAsB,MAAM,CAAC,MAAM,CAAC;IAC9D,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,qBAAqB;IACjC,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,CAAkC;IACxD,MAAM,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,CAAiD;IACvF,SAAS,EAAE,KAAK;CACjB,CAAC,CAAC;AAEH,MAAa,sBAAsB;IACxB,YAAY,GAAG,WAAW,CAAC;IAC3B,YAAY,GAAG,sBAAsB,CAAC;IAE/C,KAAK,CAAC,cAAc,CAClB,GAAe,EACf,UAAkC,EAClC,GAAyB;QAKzB,8DAA8D;QAC9D,kEAAkE;QAClE,gEAAgE;QAChE,kEAAkE;QAClE,IAAI,GAAG,CAAC,eAAe,EAAE,CAAC;YACxB,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC;QAC9C,CAAC;QAED,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC;QAC9C,CAAC;QAED,2DAA2D;QAC3D,4DAA4D;QAC5D,kEAAkE;QAClE,MAAM,cAAc,GAClB,UAAU,CAAC,MAAM,IAAI,qBAAqB;YACxC,CAAC,CAAC,UAAU;YACZ,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAC;QAEjD,MAAM,OAAO,GAAe;YAC1B,GAAG,GAAG;YACN,YAAY,EAAE,cAAc;SAC7B,CAAC;QACF,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;IACrC,CAAC;IAED,cAAc,CAAC,KAA6B;QAC1C,OAAO,IAAA,iCAAkB,EAAC,KAAK,EAAE,uBAAuB,CAAC,CAAC;IAC5D,CAAC;CACF;AA1CD,wDA0CC;AAED,qEAAqE;AACrE,sEAAsE;AACtE,CAAC;IACC,MAAM,QAAQ,GAAG,IAAI,sBAAsB,EAAE,CAAC;IAC9C,IAAA,2CAAqB,EAAC,QAAQ,CAAC,CAAC;IAChC,2EAA2E;IAC3E,oDAAoD;IACpD,MAAM,eAAe,GAAkB;QACrC,YAAY,EAAE,mBAAmB;QACjC,YAAY,EAAE,QAAQ,CAAC,YAAY;QACnC,cAAc,EAAE,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;QACtD,cAAc,EAAE,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;KACvD,CAAC;IACF,IAAA,2CAAqB,EAAC,eAAe,CAAC,CAAC;AACzC,CAAC"}

package/dist/cache/strategies/BedrockCacheStrategy.js

@@ -1,97 +0,0 @@
-"use strict";
-/**
- * BedrockCacheStrategy — REGISTERED, AND HONEST ABOUT DOING NOTHING (9.59.0).
- *
- * What Bedrock supports and what THIS ADAPTER does are two different facts,
- * and until 9.59.0 the strategy stated the first while the runtime lived
- * under the second:
- *
- *   - AWS's Converse API does support prompt caching for Claude models
- *     (`cachePoint: { type: 'default' }` entries inserted into the `system` /
- *     `tools` / `messages` arrays) and does report
- *     `cacheReadInputTokens` / `cacheWriteInputTokens` in its usage block.
- *   - `BedrockProvider` implements NEITHER half. It never reads
- *     `req.cacheMarkers` (compare `AnthropicProvider`, which calls
- *     `applyCacheMarkers`) and it builds `usage` as `{ input, output }` at
- *     both its streaming and non-streaming sites. The string "cache" does
- *     not appear in that file.
- *
- * So this strategy used to clamp markers onto a request field the adapter
- * then discarded, and report `markersApplied` for markers that never reached
- * a wire — a meter attached to a provider that cannot feed it. It now:
- *
- *   - declares `enabled: false` (nothing here works end to end);
- *   - passes the request through with `markersApplied: []`, and says why
- *     once, in dev mode;
- *   - answers `extractMetrics` with `not-applicable` and the reason.
- *
- * It stays REGISTERED rather than being deleted so that a Bedrock consumer
- * asking the registry what it got is told the truth by name, instead of
- * silently falling through to the wildcard NoOp and being left to guess.
- *
- * Note on Converse: the send half is genuinely a DIFFERENT wire from
- * Anthropic's `cache_control` block, so implementing it wants its own
- * `bedrockCacheWire.ts` beside `anthropicCacheWire.ts` — not a reuse. That
- * is the follow-up this file is waiting for; when it lands, flip `enabled`
- * and give `extractMetrics` the `readPortCacheUsage` body the Anthropic
- * strategy has.
- *
- * Auto-registers under provider name `'bedrock'`.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BedrockCacheStrategy = void 0;
-const claim_js_1 = require("../../lib/claim/claim.js");
-const strategyRegistry_js_1 = require("../strategyRegistry.js");
-const footprintjs_1 = require("footprintjs");
-const BEDROCK_CAPABILITIES = Object.freeze({
-    // `false`, and it is a statement about the ADAPTER, not about Bedrock.
-    // Bedrock-Claude supports prompt caching; `BedrockProvider` implements
-    // neither half of the contract (never sends markers, never reads cache
-    // usage), so nothing this strategy could do would reach a wire. Saying
-    // `true` here is what let a dead meter look alive.
-    enabled: false,
-    maxMarkers: 0,
-    ttls: [],
-    fields: [],
-    automatic: false,
-});
-/** One warning per process, not one per call — the fact does not change. */
-let warnedAboutAdapterGap = false;
-class BedrockCacheStrategy {
-    providerName = 'bedrock';
-    capabilities = BEDROCK_CAPABILITIES;
-    async prepareRequest(req, candidates, _ctx) {
-        // Pass-through, ALWAYS. Writing `req.cacheMarkers` here would be writing
-        // to a field `BedrockProvider` never reads, and returning a non-empty
-        // `markersApplied` would put markers that never reached a wire onto the
-        // recorder's record.
-        if (candidates.length > 0 && !warnedAboutAdapterGap && (0, footprintjs_1.isDevMode)()) {
-            warnedAboutAdapterGap = true;
-            // eslint-disable-next-line no-console
-            console.warn(`[agentfootprint] cache: ${candidates.length} cache marker(s) were declared for ` +
-                `model "${req.model}", but the Bedrock adapter does not implement prompt caching — ` +
-                `it never sends cachePoint entries and never reads cacheReadInputTokens off the ` +
-                `Converse response. No markers were applied and no hit rate can be measured. ` +
-                `Your cache: directives stay portable and light up on the Anthropic providers.`);
-        }
-        return { request: req, markersApplied: [] };
-    }
-    /**
-     * Always `not-applicable` — and that is a statement about THIS adapter,
-     * not about Bedrock. AWS's Converse API does report
-     * `cacheReadInputTokens` / `cacheWriteInputTokens`, but
-     * `BedrockProvider` never reads them: its `usage` is built as
-     * `{ input, output }` at both the streaming and non-streaming sites. So
-     * `cacheRead`/`cacheWrite` are ALWAYS absent on this port, and an
-     * `unknown` per call would read as a measurement that merely failed.
-     * `not-applicable` says the true thing: nothing here can be measured
-     * until the adapter grows the read half.
-     */
-    extractMetrics(_usage) {
-        return (0, claim_js_1.notApplicable)('the Bedrock adapter does not read cache usage off the Converse response, so no ' +
-            'cache tokens ever reach the port');
-    }
-}
-exports.BedrockCacheStrategy = BedrockCacheStrategy;
-(0, strategyRegistry_js_1.registerCacheStrategy)(new BedrockCacheStrategy());
-//# sourceMappingURL=BedrockCacheStrategy.js.map

package/dist/cache/strategies/BedrockCacheStrategy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BedrockCacheStrategy.js","sourceRoot":"","sources":["../../../src/cache/strategies/BedrockCacheStrategy.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;;;AAUH,uDAAqE;AAErE,gEAA+D;AAC/D,6CAAwC;AAExC,MAAM,oBAAoB,GAAsB,MAAM,CAAC,MAAM,CAAC;IAC5D,uEAAuE;IACvE,uEAAuE;IACvE,uEAAuE;IACvE,uEAAuE;IACvE,mDAAmD;IACnD,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,CAAC;IACb,IAAI,EAAE,EAAmC;IACzC,MAAM,EAAE,EAAkD;IAC1D,SAAS,EAAE,KAAK;CACjB,CAAC,CAAC;AAEH,4EAA4E;AAC5E,IAAI,qBAAqB,GAAG,KAAK,CAAC;AAElC,MAAa,oBAAoB;IACtB,YAAY,GAAG,SAAS,CAAC;IACzB,YAAY,GAAG,oBAAoB,CAAC;IAE7C,KAAK,CAAC,cAAc,CAClB,GAAe,EACf,UAAkC,EAClC,IAA0B;QAK1B,yEAAyE;QACzE,sEAAsE;QACtE,wEAAwE;QACxE,qBAAqB;QACrB,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,qBAAqB,IAAI,IAAA,uBAAS,GAAE,EAAE,CAAC;YACnE,qBAAqB,GAAG,IAAI,CAAC;YAC7B,sCAAsC;YACtC,OAAO,CAAC,IAAI,CACV,2BAA2B,UAAU,CAAC,MAAM,qCAAqC;gBAC/E,UAAU,GAAG,CAAC,KAAK,iEAAiE;gBACpF,iFAAiF;gBACjF,8EAA8E;gBAC9E,+EAA+E,CAClF,CAAC;QACJ,CAAC;QACD,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC;IAC9C,CAAC;IAED;;;;;;;;;;OAUG;IACH,cAAc,CAAC,MAA8B;QAC3C,OAAO,IAAA,wBAAa,EAClB,iFAAiF;YAC/E,kCAAkC,CACrC,CAAC;IACJ,CAAC;CACF;AA/CD,oDA+CC;AAED,IAAA,2CAAqB,EAAC,IAAI,oBAAoB,EAAE,CAAC,CAAC"}

package/dist/cache/strategies/OpenAICacheStrategy.js

@@ -1,76 +0,0 @@
-"use strict";
-/**
- * OpenAICacheStrategy — metrics-only strategy for OpenAI providers.
- *
- * OpenAI auto-caches request prefixes ≥1024 tokens at 50% off.
- * No client-side opt-in markers needed (and no way to influence
- * cache behavior from the client). The strategy:
- *
- *   - **prepareRequest**: pass-through. We can't tell OpenAI what
- *     to cache; they decide automatically. Markers are silently
- *     dropped (the 80% case for OpenAI consumers is "I declared
- *     cache: 'always' for my injections" — that's still meaningful
- *     because (a) it's portable across providers, (b) for OpenAI
- *     the auto-cache may still hit on stable prefixes regardless).
- *   - **extractMetrics**: reads `prompt_tokens_details.cached_tokens`
- *     from OpenAI's usage response so cacheRecorder can surface
- *     hit rates / dollar savings.
- *
- * Auto-registers on module import for: 'openai', 'browser-openai'.
- *
- * Documentation note for consumers (Phase 12 docs): the `cache:`
- * directive on injection definitions is portable but has NO LOCAL
- * EFFECT on OpenAI runs — the provider auto-caches based on prefix
- * length. The directive still ships correctly with the agent and
- * lights up automatically when you swap to Anthropic / Bedrock.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAICacheStrategy = void 0;
-const claim_js_1 = require("../../lib/claim/claim.js");
-const strategyRegistry_js_1 = require("../strategyRegistry.js");
-const OPENAI_CAPABILITIES = Object.freeze({
-    // `enabled: true` because metrics ARE extracted (cacheRecorder shows
-    // hit rates). The `automatic: true` flag tells consumers the markers
-    // are inert here — OpenAI decides what to cache, not us.
-    enabled: true,
-    maxMarkers: 0,
-    ttls: ['short'],
-    fields: [],
-    automatic: true,
-});
-class OpenAICacheStrategy {
-    providerName = 'openai';
-    capabilities = OPENAI_CAPABILITIES;
-    async prepareRequest(req, _candidates, _ctx) {
-        // Pass-through. OpenAI auto-caches; no opt-in needed.
-        return { request: req, markersApplied: [] };
-    }
-    /**
-     * Always `not-applicable`, for the same adapter reason as Bedrock:
-     * OpenAI's wire DOES carry `prompt_tokens_details.cached_tokens`, but
-     * `OpenAIProvider` builds `usage` as `{ input, output }` at both its
-     * streaming and non-streaming sites and never lifts the cached count
-     * onto the port. OpenAI is the AUTO-caching provider, so this is the
-     * costliest of the three gaps — it is named here rather than hidden
-     * behind a per-call `unknown` that would suggest the measurement was
-     * attempted and merely came back empty.
-     */
-    extractMetrics(_usage) {
-        return (0, claim_js_1.notApplicable)('the OpenAI adapter does not lift prompt_tokens_details.cached_tokens onto the port ' +
-            'usage, so no cache tokens ever reach this strategy');
-    }
-}
-exports.OpenAICacheStrategy = OpenAICacheStrategy;
-// Auto-register for both server-side and browser variants.
-{
-    const strategy = new OpenAICacheStrategy();
-    (0, strategyRegistry_js_1.registerCacheStrategy)(strategy);
-    const browserStrategy = {
-        providerName: 'browser-openai',
-        capabilities: strategy.capabilities,
-        prepareRequest: strategy.prepareRequest.bind(strategy),
-        extractMetrics: strategy.extractMetrics.bind(strategy),
-    };
-    (0, strategyRegistry_js_1.registerCacheStrategy)(browserStrategy);
-}
-//# sourceMappingURL=OpenAICacheStrategy.js.map

package/dist/cache/strategies/OpenAICacheStrategy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"OpenAICacheStrategy.js","sourceRoot":"","sources":["../../../src/cache/strategies/OpenAICacheStrategy.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;;AAUH,uDAAqE;AAErE,gEAA+D;AAE/D,MAAM,mBAAmB,GAAsB,MAAM,CAAC,MAAM,CAAC;IAC3D,qEAAqE;IACrE,qEAAqE;IACrE,yDAAyD;IACzD,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,CAAC;IACb,IAAI,EAAE,CAAC,OAAO,CAAkC;IAChD,MAAM,EAAE,EAAkD;IAC1D,SAAS,EAAE,IAAI;CAChB,CAAC,CAAC;AAEH,MAAa,mBAAmB;IACrB,YAAY,GAAG,QAAQ,CAAC;IACxB,YAAY,GAAG,mBAAmB,CAAC;IAE5C,KAAK,CAAC,cAAc,CAClB,GAAe,EACf,WAAmC,EACnC,IAA0B;QAK1B,sDAAsD;QACtD,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC;IAC9C,CAAC;IAED;;;;;;;;;OASG;IACH,cAAc,CAAC,MAA8B;QAC3C,OAAO,IAAA,wBAAa,EAClB,qFAAqF;YACnF,oDAAoD,CACvD,CAAC;IACJ,CAAC;CACF;AAhCD,kDAgCC;AAED,2DAA2D;AAC3D,CAAC;IACC,MAAM,QAAQ,GAAG,IAAI,mBAAmB,EAAE,CAAC;IAC3C,IAAA,2CAAqB,EAAC,QAAQ,CAAC,CAAC;IAChC,MAAM,eAAe,GAAkB;QACrC,YAAY,EAAE,gBAAgB;QAC9B,YAAY,EAAE,QAAQ,CAAC,YAAY;QACnC,cAAc,EAAE,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;QACtD,cAAc,EAAE,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;KACvD,CAAC;IACF,IAAA,2CAAqB,EAAC,eAAe,CAAC,CAAC;AACzC,CAAC"}

package/dist/cache/strategyRegistry.js

@@ -1,81 +0,0 @@
-"use strict";
-/**
- * Strategy registry — maps provider name → CacheStrategy.
- *
- * Auto-resolution at agent build time: agentfootprint inspects
- * `provider.name` and looks up the registered strategy for that
- * name. Falls back to `NoOpCacheStrategy` (registered under wildcard
- * `'*'`) when the provider isn't recognized.
- *
- * Phases shipping registered strategies:
- *   - v2.6 Phase 6 (this phase): NoOp
- *   - v2.6 Phase 7: AnthropicCacheStrategy ('anthropic',
- *     'browser-anthropic')
- *   - v2.6 Phase 8: OpenAICacheStrategy ('openai', 'browser-openai'),
- *     BedrockCacheStrategy ('bedrock')
- *   - v2.7+ : GeminiCacheStrategy (handle-based, async, deferred)
- *
- * Consumers can register their own strategy via
- * `registerCacheStrategy(strategy)`. Useful for in-house LLM proxies
- * or test mocks.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._resetRegistryForTests = exports.listRegisteredStrategies = exports.registerCacheStrategy = exports.getDefaultCacheStrategy = void 0;
-const NoOpCacheStrategy_js_1 = require("./strategies/NoOpCacheStrategy.js");
-/**
- * Registry singleton. Populated by individual strategy modules
- * importing this and calling `registerCacheStrategy` at module load
- * time, OR by the consumer at agent build time.
- *
- * Contains the wildcard `'*'` → NoOp entry by default; never empty.
- */
-const REGISTRY = new Map([['*', new NoOpCacheStrategy_js_1.NoOpCacheStrategy()]]);
-/**
- * Look up a CacheStrategy by provider name. Falls back to the
- * wildcard NoOp strategy if no match.
- *
- * Lookup is case-insensitive on the provider name.
- */
-function getDefaultCacheStrategy(providerName) {
-    const exact = REGISTRY.get(providerName);
-    if (exact !== undefined)
-        return exact;
-    const lower = providerName.toLowerCase();
-    if (lower !== providerName) {
-        const lowercased = REGISTRY.get(lower);
-        if (lowercased !== undefined)
-            return lowercased;
-    }
-    // Fallback wildcard always present (set at module load by registerDefaults).
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return REGISTRY.get('*');
-}
-exports.getDefaultCacheStrategy = getDefaultCacheStrategy;
-/**
- * Register (or replace) a strategy for a provider name. Called by
- * strategy modules (v2.6 Phase 7+) at module load OR by consumers
- * needing a custom backend. Replacing an existing strategy is allowed
- * — the most-recent registration wins.
- */
-function registerCacheStrategy(strategy) {
-    REGISTRY.set(strategy.providerName, strategy);
-}
-exports.registerCacheStrategy = registerCacheStrategy;
-/**
- * Read-only view of registered strategy names. Useful for diagnostics
- * (e.g., logging "we have strategies for: anthropic, openai, *").
- */
-function listRegisteredStrategies() {
-    return [...REGISTRY.keys()];
-}
-exports.listRegisteredStrategies = listRegisteredStrategies;
-/**
- * Internal helper for tests: reset the registry to the default
- * (wildcard → NoOp only). Not exported from the public barrel.
- */
-function _resetRegistryForTests() {
-    REGISTRY.clear();
-    REGISTRY.set('*', new NoOpCacheStrategy_js_1.NoOpCacheStrategy());
-}
-exports._resetRegistryForTests = _resetRegistryForTests;
-//# sourceMappingURL=strategyRegistry.js.map

package/dist/cache/strategyRegistry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"strategyRegistry.js","sourceRoot":"","sources":["../../src/cache/strategyRegistry.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;;AAGH,4EAAsE;AAEtE;;;;;;GAMG;AACH,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAwB,CAAC,CAAC,GAAG,EAAE,IAAI,wCAAiB,EAAE,CAAC,CAAC,CAAC,CAAC;AAElF;;;;;GAKG;AACH,SAAgB,uBAAuB,CAAC,YAAoB;IAC1D,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IACzC,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACtC,MAAM,KAAK,GAAG,YAAY,CAAC,WAAW,EAAE,CAAC;IACzC,IAAI,KAAK,KAAK,YAAY,EAAE,CAAC;QAC3B,MAAM,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACvC,IAAI,UAAU,KAAK,SAAS;YAAE,OAAO,UAAU,CAAC;IAClD,CAAC;IACD,6EAA6E;IAC7E,oEAAoE;IACpE,OAAO,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;AAC5B,CAAC;AAXD,0DAWC;AAED;;;;;GAKG;AACH,SAAgB,qBAAqB,CAAC,QAAuB;IAC3D,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;AAChD,CAAC;AAFD,sDAEC;AAED;;;GAGG;AACH,SAAgB,wBAAwB;IACtC,OAAO,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;AAC9B,CAAC;AAFD,4DAEC;AAED;;;GAGG;AACH,SAAgB,sBAAsB;IACpC,QAAQ,CAAC,KAAK,EAAE,CAAC;IACjB,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,wCAAiB,EAAE,CAAC,CAAC;AAC7C,CAAC;AAHD,wDAGC"}

package/dist/esm/cache/strategies/AnthropicCacheStrategy.d.ts

@@ -1,41 +0,0 @@
-/**
- * AnthropicCacheStrategy — translates agnostic CacheMarker[] to
- * Anthropic API's `cache_control: { type: 'ephemeral' }` markers.
- *
- * Anthropic-specific behaviors honored:
- *   - **4-marker limit**: Anthropic allows ≤4 cache breakpoints per
- *     request. Strategy clamps oversize candidate sets, keeping the
- *     first 4 in slot order.
- *   - **TTL mapping**: 'short' → default 5min ephemeral; 'long' →
- *     `ttl: '1h'` (1-hour beta).
- *   - **Provider-side hashing**: this strategy doesn't hash — Anthropic
- *     keys cache by exact byte prefix server-side. We don't need
- *     content hashes for the v2.6 surface; reserved for v2.7+ if a
- *     pre-flight cache-warm-check API ships.
- *
- * What this strategy DOES vs DOESN'T do:
- *   - DOES: clamp markers, attach to LLMRequest.cacheMarkers,
- *     read cache metrics off the PORT usage the framework hands it
- *     (`{ input, output, cacheRead?, cacheWrite? }`) — never off the raw
- *     Anthropic wire, which the adapter has already normalised
- *   - DOES NOT: rewrite the wire body. The provider
- *     (BrowserAnthropicProvider) reads `cacheMarkers` and applies
- *     `cache_control` blocks during body construction. Separation of
- *     concerns: strategy decides WHAT to cache; provider knows HOW
- *     to encode on its specific wire.
- *
- * Auto-registers in the strategy registry on module import for
- * provider names: 'anthropic', 'browser-anthropic'.
- */
-import type { CacheCapabilities, CacheMarker, CacheMetrics, CacheStrategy, CacheStrategyContext, CacheUsage } from '../types.js';
-import type { Claim } from '../../lib/claim/claim.js';
-import type { LLMRequest } from '../../adapters/types.js';
-export declare class AnthropicCacheStrategy implements CacheStrategy {
-    readonly providerName = "anthropic";
-    readonly capabilities: CacheCapabilities;
-    prepareRequest(req: LLMRequest, candidates: readonly CacheMarker[], ctx: CacheStrategyContext): Promise<{
-        readonly request: LLMRequest;
-        readonly markersApplied: readonly CacheMarker[];
-    }>;
-    extractMetrics(usage: CacheUsage | undefined): Claim<CacheMetrics>;
-}

package/dist/esm/cache/strategies/AnthropicCacheStrategy.js

@@ -1,86 +0,0 @@
-/**
- * AnthropicCacheStrategy — translates agnostic CacheMarker[] to
- * Anthropic API's `cache_control: { type: 'ephemeral' }` markers.
- *
- * Anthropic-specific behaviors honored:
- *   - **4-marker limit**: Anthropic allows ≤4 cache breakpoints per
- *     request. Strategy clamps oversize candidate sets, keeping the
- *     first 4 in slot order.
- *   - **TTL mapping**: 'short' → default 5min ephemeral; 'long' →
- *     `ttl: '1h'` (1-hour beta).
- *   - **Provider-side hashing**: this strategy doesn't hash — Anthropic
- *     keys cache by exact byte prefix server-side. We don't need
- *     content hashes for the v2.6 surface; reserved for v2.7+ if a
- *     pre-flight cache-warm-check API ships.
- *
- * What this strategy DOES vs DOESN'T do:
- *   - DOES: clamp markers, attach to LLMRequest.cacheMarkers,
- *     read cache metrics off the PORT usage the framework hands it
- *     (`{ input, output, cacheRead?, cacheWrite? }`) — never off the raw
- *     Anthropic wire, which the adapter has already normalised
- *   - DOES NOT: rewrite the wire body. The provider
- *     (BrowserAnthropicProvider) reads `cacheMarkers` and applies
- *     `cache_control` blocks during body construction. Separation of
- *     concerns: strategy decides WHAT to cache; provider knows HOW
- *     to encode on its specific wire.
- *
- * Auto-registers in the strategy registry on module import for
- * provider names: 'anthropic', 'browser-anthropic'.
- */
-import { readPortCacheUsage } from '../portUsage.js';
-import { registerCacheStrategy } from '../strategyRegistry.js';
-/** Anthropic enforces 4 cache breakpoints per request. */
-const ANTHROPIC_MAX_MARKERS = 4;
-const ANTHROPIC_CAPABILITIES = Object.freeze({
-    enabled: true,
-    maxMarkers: ANTHROPIC_MAX_MARKERS,
-    ttls: ['short', 'long'],
-    fields: ['system', 'tools', 'messages'],
-    automatic: false,
-});
-export class AnthropicCacheStrategy {
-    providerName = 'anthropic';
-    capabilities = ANTHROPIC_CAPABILITIES;
-    async prepareRequest(req, candidates, ctx) {
-        // Honor the agent-side kill switch even if reached this far —
-        // belt-and-suspenders. CacheGate should have routed to no-markers
-        // already, leaving `candidates` empty, but if a buggy gate lets
-        // markers through with cachingDisabled=true, we still respect it.
-        if (ctx.cachingDisabled) {
-            return { request: req, markersApplied: [] };
-        }
-        if (candidates.length === 0) {
-            return { request: req, markersApplied: [] };
-        }
-        // Clamp to Anthropic's 4-marker limit. Keep the first N in
-        // slot order so we cover the most-stable prefixes (system /
-        // always-on injections / tools) before less-stable trailing ones.
-        const markersApplied = candidates.length <= ANTHROPIC_MAX_MARKERS
-            ? candidates
-            : candidates.slice(0, ANTHROPIC_MAX_MARKERS);
-        const request = {
-            ...req,
-            cacheMarkers: markersApplied,
-        };
-        return { request, markersApplied };
-    }
-    extractMetrics(usage) {
-        return readPortCacheUsage(usage, 'the Anthropic adapter');
-    }
-}
-// Auto-register on module import. Both 'anthropic' (server-side) and
-// 'browser-anthropic' (browser fetch) providers map to this strategy.
-{
-    const strategy = new AnthropicCacheStrategy();
-    registerCacheStrategy(strategy);
-    // Register the browser variant by cloning with the matching provider name.
-    // Same behavior, different provider.name match-key.
-    const browserStrategy = {
-        providerName: 'browser-anthropic',
-        capabilities: strategy.capabilities,
-        prepareRequest: strategy.prepareRequest.bind(strategy),
-        extractMetrics: strategy.extractMetrics.bind(strategy),
-    };
-    registerCacheStrategy(browserStrategy);
-}
-//# sourceMappingURL=AnthropicCacheStrategy.js.map

package/dist/esm/cache/strategies/AnthropicCacheStrategy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AnthropicCacheStrategy.js","sourceRoot":"","sources":["../../../../src/cache/strategies/AnthropicCacheStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAWH,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,0DAA0D;AAC1D,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAEhC,MAAM,sBAAsB,GAAsB,MAAM,CAAC,MAAM,CAAC;IAC9D,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,qBAAqB;IACjC,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,CAAkC;IACxD,MAAM,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,UAAU,CAAiD;IACvF,SAAS,EAAE,KAAK;CACjB,CAAC,CAAC;AAEH,MAAM,OAAO,sBAAsB;IACxB,YAAY,GAAG,WAAW,CAAC;IAC3B,YAAY,GAAG,sBAAsB,CAAC;IAE/C,KAAK,CAAC,cAAc,CAClB,GAAe,EACf,UAAkC,EAClC,GAAyB;QAKzB,8DAA8D;QAC9D,kEAAkE;QAClE,gEAAgE;QAChE,kEAAkE;QAClE,IAAI,GAAG,CAAC,eAAe,EAAE,CAAC;YACxB,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC;QAC9C,CAAC;QAED,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC;QAC9C,CAAC;QAED,2DAA2D;QAC3D,4DAA4D;QAC5D,kEAAkE;QAClE,MAAM,cAAc,GAClB,UAAU,CAAC,MAAM,IAAI,qBAAqB;YACxC,CAAC,CAAC,UAAU;YACZ,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAAC;QAEjD,MAAM,OAAO,GAAe;YAC1B,GAAG,GAAG;YACN,YAAY,EAAE,cAAc;SAC7B,CAAC;QACF,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;IACrC,CAAC;IAED,cAAc,CAAC,KAA6B;QAC1C,OAAO,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,CAAC,CAAC;IAC5D,CAAC;CACF;AAED,qEAAqE;AACrE,sEAAsE;AACtE,CAAC;IACC,MAAM,QAAQ,GAAG,IAAI,sBAAsB,EAAE,CAAC;IAC9C,qBAAqB,CAAC,QAAQ,CAAC,CAAC;IAChC,2EAA2E;IAC3E,oDAAoD;IACpD,MAAM,eAAe,GAAkB;QACrC,YAAY,EAAE,mBAAmB;QACjC,YAAY,EAAE,QAAQ,CAAC,YAAY;QACnC,cAAc,EAAE,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;QACtD,cAAc,EAAE,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC;KACvD,CAAC;IACF,qBAAqB,CAAC,eAAe,CAAC,CAAC;AACzC,CAAC"}

package/dist/esm/cache/strategies/BedrockCacheStrategy.d.ts

@@ -1,62 +0,0 @@
-/**
- * BedrockCacheStrategy — REGISTERED, AND HONEST ABOUT DOING NOTHING (9.59.0).
- *
- * What Bedrock supports and what THIS ADAPTER does are two different facts,
- * and until 9.59.0 the strategy stated the first while the runtime lived
- * under the second:
- *
- *   - AWS's Converse API does support prompt caching for Claude models
- *     (`cachePoint: { type: 'default' }` entries inserted into the `system` /
- *     `tools` / `messages` arrays) and does report
- *     `cacheReadInputTokens` / `cacheWriteInputTokens` in its usage block.
- *   - `BedrockProvider` implements NEITHER half. It never reads
- *     `req.cacheMarkers` (compare `AnthropicProvider`, which calls
- *     `applyCacheMarkers`) and it builds `usage` as `{ input, output }` at
- *     both its streaming and non-streaming sites. The string "cache" does
- *     not appear in that file.
- *
- * So this strategy used to clamp markers onto a request field the adapter
- * then discarded, and report `markersApplied` for markers that never reached
- * a wire — a meter attached to a provider that cannot feed it. It now:
- *
- *   - declares `enabled: false` (nothing here works end to end);
- *   - passes the request through with `markersApplied: []`, and says why
- *     once, in dev mode;
- *   - answers `extractMetrics` with `not-applicable` and the reason.
- *
- * It stays REGISTERED rather than being deleted so that a Bedrock consumer
- * asking the registry what it got is told the truth by name, instead of
- * silently falling through to the wildcard NoOp and being left to guess.
- *
- * Note on Converse: the send half is genuinely a DIFFERENT wire from
- * Anthropic's `cache_control` block, so implementing it wants its own
- * `bedrockCacheWire.ts` beside `anthropicCacheWire.ts` — not a reuse. That
- * is the follow-up this file is waiting for; when it lands, flip `enabled`
- * and give `extractMetrics` the `readPortCacheUsage` body the Anthropic
- * strategy has.
- *
- * Auto-registers under provider name `'bedrock'`.
- */
-import type { CacheCapabilities, CacheMarker, CacheMetrics, CacheStrategy, CacheStrategyContext, CacheUsage } from '../types.js';
-import { type Claim } from '../../lib/claim/claim.js';
-import type { LLMRequest } from '../../adapters/types.js';
-export declare class BedrockCacheStrategy implements CacheStrategy {
-    readonly providerName = "bedrock";
-    readonly capabilities: CacheCapabilities;
-    prepareRequest(req: LLMRequest, candidates: readonly CacheMarker[], _ctx: CacheStrategyContext): Promise<{
-        readonly request: LLMRequest;
-        readonly markersApplied: readonly CacheMarker[];
-    }>;
-    /**
-     * Always `not-applicable` — and that is a statement about THIS adapter,
-     * not about Bedrock. AWS's Converse API does report
-     * `cacheReadInputTokens` / `cacheWriteInputTokens`, but
-     * `BedrockProvider` never reads them: its `usage` is built as
-     * `{ input, output }` at both the streaming and non-streaming sites. So
-     * `cacheRead`/`cacheWrite` are ALWAYS absent on this port, and an
-     * `unknown` per call would read as a measurement that merely failed.
-     * `not-applicable` says the true thing: nothing here can be measured
-     * until the adapter grows the read half.
-     */
-    extractMetrics(_usage: CacheUsage | undefined): Claim<CacheMetrics>;
-}