agentfootprint 2.5.1 → 2.6.1

package/dist/cache/index.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * agentfootprint/cache — public surface for the cache layer (v2.6+).
+ *
+ * Importing this module side-effect-registers every built-in cache
+ * strategy in the registry. The agentfootprint main barrel imports
+ * from here so consumers get the registered strategies without
+ * needing to know they exist.
+ *
+ * Strategies registered as of v2.6:
+ *   - NoOp (wildcard '*' fallback) — always available, registered by
+ *     the registry module itself
+ *   - AnthropicCacheStrategy ('anthropic', 'browser-anthropic')
+ *
+ * Future strategies (Phase 8+):
+ *   - OpenAICacheStrategy
+ *   - BedrockCacheStrategy
+ *   - GeminiCacheStrategy (v2.7+, async handle-based)
+ *
+ * Public types (re-exported for consumers):
+ *   - CachePolicy, CacheMarker, CacheStrategy, CacheCapabilities,
+ *     CacheMetrics, CachePolicyContext, CacheStrategyContext
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheRecorder = exports.BedrockCacheStrategy = exports.OpenAICacheStrategy = exports.AnthropicCacheStrategy = exports.NoOpCacheStrategy = exports.listRegisteredStrategies = exports.registerCacheStrategy = exports.getDefaultCacheStrategy = void 0;
+// Side-effect imports — register strategies on module load.
+require("./strategies/AnthropicCacheStrategy.js");
+require("./strategies/OpenAICacheStrategy.js");
+require("./strategies/BedrockCacheStrategy.js");
+// Strategy registry
+var strategyRegistry_js_1 = require("./strategyRegistry.js");
+Object.defineProperty(exports, "getDefaultCacheStrategy", { enumerable: true, get: function () { return strategyRegistry_js_1.getDefaultCacheStrategy; } });
+Object.defineProperty(exports, "registerCacheStrategy", { enumerable: true, get: function () { return strategyRegistry_js_1.registerCacheStrategy; } });
+Object.defineProperty(exports, "listRegisteredStrategies", { enumerable: true, get: function () { return strategyRegistry_js_1.listRegisteredStrategies; } });
+// Built-in strategy classes (for consumers who want explicit overrides)
+var NoOpCacheStrategy_js_1 = require("./strategies/NoOpCacheStrategy.js");
+Object.defineProperty(exports, "NoOpCacheStrategy", { enumerable: true, get: function () { return NoOpCacheStrategy_js_1.NoOpCacheStrategy; } });
+var AnthropicCacheStrategy_js_1 = require("./strategies/AnthropicCacheStrategy.js");
+Object.defineProperty(exports, "AnthropicCacheStrategy", { enumerable: true, get: function () { return AnthropicCacheStrategy_js_1.AnthropicCacheStrategy; } });
+var OpenAICacheStrategy_js_1 = require("./strategies/OpenAICacheStrategy.js");
+Object.defineProperty(exports, "OpenAICacheStrategy", { enumerable: true, get: function () { return OpenAICacheStrategy_js_1.OpenAICacheStrategy; } });
+var BedrockCacheStrategy_js_1 = require("./strategies/BedrockCacheStrategy.js");
+Object.defineProperty(exports, "BedrockCacheStrategy", { enumerable: true, get: function () { return BedrockCacheStrategy_js_1.BedrockCacheStrategy; } });
+// Recorder
+var cacheRecorder_js_1 = require("./cacheRecorder.js");
+Object.defineProperty(exports, "cacheRecorder", { enumerable: true, get: function () { return cacheRecorder_js_1.cacheRecorder; } });
+//# sourceMappingURL=index.js.map

package/dist/cache/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;;AAEH,4DAA4D;AAC5D,kDAAgD;AAChD,+CAA6C;AAC7C,gDAA8C;AAa9C,oBAAoB;AACpB,6DAI+B;AAH7B,8HAAA,uBAAuB,OAAA;AACvB,4HAAA,qBAAqB,OAAA;AACrB,+HAAA,wBAAwB,OAAA;AAG1B,wEAAwE;AACxE,0EAAsE;AAA7D,yHAAA,iBAAiB,OAAA;AAC1B,oFAAgF;AAAvE,mIAAA,sBAAsB,OAAA;AAC/B,8EAA0E;AAAjE,6HAAA,mBAAmB,OAAA;AAC5B,gFAA4E;AAAnE,+HAAA,oBAAoB,OAAA;AAE7B,WAAW;AACX,uDAAmD;AAA1C,iHAAA,aAAa,OAAA"}

package/dist/cache/strategies/AnthropicCacheStrategy.js

@@ -0,0 +1,102 @@
+"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,
+ *     extract metrics from response.usage
+ *   - 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 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) {
+        if (!usage || typeof usage !== 'object')
+            return undefined;
+        const u = usage;
+        const cacheRead = u.cache_read_input_tokens ?? 0;
+        const cacheWrite = u.cache_creation_input_tokens ?? 0;
+        const fresh = u.input_tokens ?? 0;
+        // If neither cache field present, response didn't involve caching.
+        // Returning undefined signals "no cache info" so cacheRecorder
+        // doesn't compute a misleading 0% hit rate.
+        if (cacheRead === 0 && cacheWrite === 0)
+            return undefined;
+        return {
+            cacheReadTokens: cacheRead,
+            cacheWriteTokens: cacheWrite,
+            freshInputTokens: fresh,
+        };
+    }
+}
+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

@@ -0,0 +1 @@
+{"version":3,"file":"AnthropicCacheStrategy.js","sourceRoot":"","sources":["../../../src/cache/strategies/AnthropicCacheStrategy.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;;AAUH,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,KAAc;QAC3B,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO,SAAS,CAAC;QAC1D,MAAM,CAAC,GAAG,KAIT,CAAC;QACF,MAAM,SAAS,GAAG,CAAC,CAAC,uBAAuB,IAAI,CAAC,CAAC;QACjD,MAAM,UAAU,GAAG,CAAC,CAAC,2BAA2B,IAAI,CAAC,CAAC;QACtD,MAAM,KAAK,GAAG,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC;QAClC,mEAAmE;QACnE,+DAA+D;QAC/D,4CAA4C;QAC5C,IAAI,SAAS,KAAK,CAAC,IAAI,UAAU,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAC1D,OAAO;YACL,eAAe,EAAE,SAAS;YAC1B,gBAAgB,EAAE,UAAU;YAC5B,gBAAgB,EAAE,KAAK;SACxB,CAAC;IACJ,CAAC;CACF;AA3DD,wDA2DC;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

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * BedrockCacheStrategy — model-aware strategy for AWS Bedrock.
+ *
+ * Bedrock hosts multiple model families. Cache support varies:
+ *   - Claude on Bedrock → identical mechanics to direct Anthropic
+ *     (`cache_control: { type: 'ephemeral' }` markers, 4-marker
+ *     limit). Strategy delegates to Anthropic-shaped behavior.
+ *   - Llama / Mistral / Cohere on Bedrock → no cache support today
+ *     (as of 2026-04-30). Strategy passes through, returns no metrics.
+ *
+ * Auto-detection: inspects `req.model` to decide. Claude model IDs
+ * start with `'anthropic.claude'` on Bedrock (e.g.,
+ * `anthropic.claude-3-5-sonnet-20240620-v1:0`).
+ *
+ * Auto-registers under provider name `'bedrock'`.
+ *
+ * Per the Phase 1 review (Reviewer 6 — Provider SDK expert): for
+ * non-Claude Bedrock models the strategy reports `enabled: false` in
+ * its capabilities so the CacheDecision subflow can short-circuit
+ * marker emission (potential v2.7 optimization). Today markers still
+ * emit and we drop them silently in prepareRequest.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockCacheStrategy = void 0;
+const strategyRegistry_js_1 = require("../strategyRegistry.js");
+/** Match Bedrock-Claude model ids: `anthropic.claude-...` */
+const BEDROCK_CLAUDE_RE = /^anthropic\.claude/i;
+/** Anthropic's 4-marker limit applies to Bedrock-Claude too. */
+const BEDROCK_MAX_MARKERS = 4;
+const BEDROCK_CAPABILITIES = Object.freeze({
+    // We say `enabled: true` at the capability level because Bedrock-
+    // Claude DOES support caching. Bedrock-Llama/Mistral land in the
+    // model-aware code path inside prepareRequest (no markers applied).
+    enabled: true,
+    maxMarkers: BEDROCK_MAX_MARKERS,
+    ttls: ['short', 'long'],
+    fields: ['system', 'tools', 'messages'],
+    automatic: false,
+});
+class BedrockCacheStrategy {
+    providerName = 'bedrock';
+    capabilities = BEDROCK_CAPABILITIES;
+    async prepareRequest(req, candidates, ctx) {
+        if (ctx.cachingDisabled || candidates.length === 0) {
+            return { request: req, markersApplied: [] };
+        }
+        // Model-aware: only Claude on Bedrock supports cache_control.
+        // Other model families silently drop the markers.
+        if (!BEDROCK_CLAUDE_RE.test(req.model)) {
+            return { request: req, markersApplied: [] };
+        }
+        const markersApplied = candidates.length <= BEDROCK_MAX_MARKERS
+            ? candidates
+            : candidates.slice(0, BEDROCK_MAX_MARKERS);
+        return {
+            request: { ...req, cacheMarkers: markersApplied },
+            markersApplied,
+        };
+    }
+    extractMetrics(usage) {
+        // Bedrock returns the SAME usage shape as Anthropic for Claude
+        // models — same cache_creation_input_tokens / cache_read_input_tokens
+        // fields. Reuse identical extraction.
+        if (!usage || typeof usage !== 'object')
+            return undefined;
+        const u = usage;
+        const cacheRead = u.cache_read_input_tokens ?? 0;
+        const cacheWrite = u.cache_creation_input_tokens ?? 0;
+        if (cacheRead === 0 && cacheWrite === 0)
+            return undefined;
+        return {
+            cacheReadTokens: cacheRead,
+            cacheWriteTokens: cacheWrite,
+            freshInputTokens: u.input_tokens ?? 0,
+        };
+    }
+}
+exports.BedrockCacheStrategy = BedrockCacheStrategy;
+(0, strategyRegistry_js_1.registerCacheStrategy)(new BedrockCacheStrategy());
+//# sourceMappingURL=BedrockCacheStrategy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BedrockCacheStrategy.js","sourceRoot":"","sources":["../../../src/cache/strategies/BedrockCacheStrategy.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;;AAUH,gEAA+D;AAE/D,6DAA6D;AAC7D,MAAM,iBAAiB,GAAG,qBAAqB,CAAC;AAEhD,gEAAgE;AAChE,MAAM,mBAAmB,GAAG,CAAC,CAAC;AAE9B,MAAM,oBAAoB,GAAsB,MAAM,CAAC,MAAM,CAAC;IAC5D,kEAAkE;IAClE,iEAAiE;IACjE,oEAAoE;IACpE,OAAO,EAAE,IAAI;IACb,UAAU,EAAE,mBAAmB;IAC/B,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,oBAAoB;IACtB,YAAY,GAAG,SAAS,CAAC;IACzB,YAAY,GAAG,oBAAoB,CAAC;IAE7C,KAAK,CAAC,cAAc,CAClB,GAAe,EACf,UAAkC,EAClC,GAAyB;QAKzB,IAAI,GAAG,CAAC,eAAe,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnD,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC;QAC9C,CAAC;QACD,8DAA8D;QAC9D,kDAAkD;QAClD,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACvC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC;QAC9C,CAAC;QACD,MAAM,cAAc,GAClB,UAAU,CAAC,MAAM,IAAI,mBAAmB;YACtC,CAAC,CAAC,UAAU;YACZ,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,mBAAmB,CAAC,CAAC;QAC/C,OAAO;YACL,OAAO,EAAE,EAAE,GAAG,GAAG,EAAE,YAAY,EAAE,cAAc,EAAE;YACjD,cAAc;SACf,CAAC;IACJ,CAAC;IAED,cAAc,CAAC,KAAc;QAC3B,+DAA+D;QAC/D,sEAAsE;QACtE,sCAAsC;QACtC,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO,SAAS,CAAC;QAC1D,MAAM,CAAC,GAAG,KAIT,CAAC;QACF,MAAM,SAAS,GAAG,CAAC,CAAC,uBAAuB,IAAI,CAAC,CAAC;QACjD,MAAM,UAAU,GAAG,CAAC,CAAC,2BAA2B,IAAI,CAAC,CAAC;QACtD,IAAI,SAAS,KAAK,CAAC,IAAI,UAAU,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QAC1D,OAAO;YACL,eAAe,EAAE,SAAS;YAC1B,gBAAgB,EAAE,UAAU;YAC5B,gBAAgB,EAAE,CAAC,CAAC,YAAY,IAAI,CAAC;SACtC,CAAC;IACJ,CAAC;CACF;AAjDD,oDAiDC;AAED,IAAA,2CAAqB,EAAC,IAAI,oBAAoB,EAAE,CAAC,CAAC"}

package/dist/cache/strategies/NoOpCacheStrategy.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * NoOpCacheStrategy — fallback strategy for providers without cache
+ * support (Mock, unknown providers, intentional opt-out).
+ *
+ * Returns the request unchanged; reports no metrics. The
+ * `capabilities.enabled` flag is `false` so the CacheDecision subflow
+ * could choose to skip emitting markers entirely (potential v2.7
+ * optimization), though current Phase 4+5 always emit markers and
+ * let the strategy decide what to do with them.
+ *
+ * Always-available default. Registered against the special wildcard
+ * `'*'` so any unrecognized provider name falls back to NoOp.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoOpCacheStrategy = void 0;
+const NOOP_CAPABILITIES = Object.freeze({
+    enabled: false,
+    maxMarkers: 0,
+    ttls: [],
+    fields: [],
+    automatic: false,
+});
+class NoOpCacheStrategy {
+    /**
+     * Wildcard provider name. The strategy registry treats this as the
+     * fallback for any provider that doesn't have a specific strategy
+     * registered.
+     */
+    providerName = '*';
+    capabilities = NOOP_CAPABILITIES;
+    async prepareRequest(req, _candidates, _ctx) {
+        return { request: req, markersApplied: [] };
+    }
+    extractMetrics(_usage) {
+        return undefined;
+    }
+}
+exports.NoOpCacheStrategy = NoOpCacheStrategy;
+//# sourceMappingURL=NoOpCacheStrategy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NoOpCacheStrategy.js","sourceRoot":"","sources":["../../../src/cache/strategies/NoOpCacheStrategy.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AAWH,MAAM,iBAAiB,GAAsB,MAAM,CAAC,MAAM,CAAC;IACzD,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,CAAC;IACb,IAAI,EAAE,EAAmC;IACzC,MAAM,EAAE,EAAkD;IAC1D,SAAS,EAAE,KAAK;CACjB,CAAC,CAAC;AAEH,MAAa,iBAAiB;IAC5B;;;;OAIG;IACM,YAAY,GAAG,GAAG,CAAC;IACnB,YAAY,GAAG,iBAAiB,CAAC;IAE1C,KAAK,CAAC,cAAc,CAClB,GAAe,EACf,WAAmC,EACnC,IAA0B;QAK1B,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC;IAC9C,CAAC;IAED,cAAc,CAAC,MAAe;QAC5B,OAAO,SAAS,CAAC;IACnB,CAAC;CACF;AAvBD,8CAuBC"}

package/dist/cache/strategies/OpenAICacheStrategy.js

@@ -0,0 +1,75 @@
+"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 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: [] };
+    }
+    extractMetrics(usage) {
+        if (!usage || typeof usage !== 'object')
+            return undefined;
+        const u = usage;
+        const cached = u.prompt_tokens_details?.cached_tokens ?? 0;
+        if (cached === 0)
+            return undefined;
+        const totalPrompt = u.prompt_tokens ?? cached;
+        return {
+            cacheReadTokens: cached,
+            cacheWriteTokens: 0, // OpenAI doesn't charge a write premium
+            freshInputTokens: Math.max(0, totalPrompt - cached),
+        };
+    }
+}
+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

@@ -0,0 +1 @@
+{"version":3,"file":"OpenAICacheStrategy.js","sourceRoot":"","sources":["../../../src/cache/strategies/OpenAICacheStrategy.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;;AAUH,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,cAAc,CAAC,KAAc;QAC3B,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO,SAAS,CAAC;QAC1D,MAAM,CAAC,GAAG,KAGT,CAAC;QACF,MAAM,MAAM,GAAG,CAAC,CAAC,qBAAqB,EAAE,aAAa,IAAI,CAAC,CAAC;QAC3D,IAAI,MAAM,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC;QACnC,MAAM,WAAW,GAAG,CAAC,CAAC,aAAa,IAAI,MAAM,CAAC;QAC9C,OAAO;YACL,eAAe,EAAE,MAAM;YACvB,gBAAgB,EAAE,CAAC,EAAE,wCAAwC;YAC7D,gBAAgB,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC;SACpD,CAAC;IACJ,CAAC;CACF;AA/BD,kDA+BC;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

@@ -0,0 +1,80 @@
+"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
+    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

@@ -0,0 +1 @@
+{"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,mCAAmC;IACnC,OAAO,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;AAC5B,CAAC;AAVD,0DAUC;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/cache/types.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Cache layer — public types.
+ *
+ * Three layers, each with one responsibility:
+ *
+ *   1. CONSUMER DSL — `CachePolicy` field on every injection factory.
+ *      Declarative, like GraphQL schema input. Says WHAT should be
+ *      cacheable. Examples: `cache: 'always'`, `cache: 'while-active'`.
+ *
+ *   2. AGNOSTIC MARKERS — `CacheMarker[]` produced by the
+ *      `CacheDecision` subflow at runtime. Provider-independent
+ *      identification of "cacheable prefix in field X up to index Y".
+ *
+ *   3. PROVIDER STRATEGY — one `CacheStrategy` implementation per
+ *      provider (Anthropic / OpenAI / Bedrock / NoOp). Translates
+ *      agnostic markers to provider-specific wire format AND extracts
+ *      cache metrics from the provider's response.
+ *
+ * The interfaces are read-only / immutable by convention. Strategies
+ * MUST be stateless across runs; per-run state lives in the
+ * `CacheStrategyContext` passed into `prepareRequest`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/cache/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/cache/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG"}

package/dist/conventions.js

@@ -31,6 +31,9 @@ exports.SUBFLOW_IDS = {
     MERGE: 'sf-merge',
     /** Final-answer composition inside Agent. */
     FINAL: 'sf-final',
+    /** Cache decision subflow (v2.6). Walks activeInjections, emits
+     *  agnostic CacheMarker[]. Provider-independent. */
+    CACHE_DECISION: 'sf-cache-decision',
 };
 /** Stage IDs — plain function stages that builders mount. */
 exports.STAGE_IDS = {
@@ -40,6 +43,21 @@ exports.STAGE_IDS = {
     FORMAT_MERGE: 'format-merge',
     MERGE_LLM: 'merge-llm',
     EXTRACT_MERGE: 'extract-merge',
+    /** Updates the rolling skill-history window before CacheGate
+     *  evaluates skill-churn (v2.6). */
+    UPDATE_SKILL_HISTORY: 'update-skill-history',
+    /** CacheGate decider stage — routes to apply-markers / no-markers
+     *  based on kill switch / hit rate / skill churn (v2.6). */
+    CACHE_GATE: 'cache-gate',
+    /** CacheGate branch (routing key) when markers SHOULD be applied
+     *  this iteration. Pass-through stage; markers stay in scope. (v2.6) */
+    APPLY_MARKERS: 'apply-markers',
+    /** CacheGate branch (routing key) when markers should be SKIPPED
+     *  this iteration. Stage clears scope.cacheMarkers. (v2.6) */
+    SKIP_CACHING: 'no-markers',
+    /** BuildLLMRequest stage — calls strategy.prepareRequest to apply
+     *  markers to the wire request (v2.6). */
+    BUILD_LLM_REQUEST: 'build-llm-request',
 };
 // ─── Type guards ─────────────────────────────────────────────────────
 /** True when a subflow id corresponds to one of the 3 context slots. */

package/dist/conventions.js.map

@@ -1 +1 @@
-{"version":3,"file":"conventions.js","sourceRoot":"","sources":["../src/conventions.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AAIH,gEAAgE;AACnD,QAAA,WAAW,GAAG;IACzB;0EACsE;IACtE,gBAAgB,EAAE,qBAAqB;IACvC,+DAA+D;IAC/D,aAAa,EAAE,kBAAkB;IACjC,6BAA6B;IAC7B,QAAQ,EAAE,aAAa;IACvB,0BAA0B;IAC1B,KAAK,EAAE,UAAU;IACjB,2CAA2C;IAC3C,KAAK,EAAE,UAAU;IACjB,uDAAuD;IACvD,UAAU,EAAE,eAAe;IAC3B,kCAAkC;IAClC,KAAK,EAAE,UAAU;IACjB,6CAA6C;IAC7C,KAAK,EAAE,UAAU;CACT,CAAC;AAIX,6DAA6D;AAChD,QAAA,SAAS,GAAG;IACvB,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,UAAU;IACpB,KAAK,EAAE,OAAO;IACd,YAAY,EAAE,cAAc;IAC5B,SAAS,EAAE,WAAW;IACtB,aAAa,EAAE,eAAe;CACtB,CAAC;AAIX,wEAAwE;AAExE,wEAAwE;AACxE,SAAgB,aAAa,CAC3B,EAAU;IAEV,OAAO,CACL,EAAE,KAAK,mBAAW,CAAC,aAAa,IAAI,EAAE,KAAK,mBAAW,CAAC,QAAQ,IAAI,EAAE,KAAK,mBAAW,CAAC,KAAK,CAC5F,CAAC;AACJ,CAAC;AAND,sCAMC;AAED,iFAAiF;AACjF,SAAgB,iBAAiB,CAAC,EAAU;IAC1C,iEAAiE;IACjE,mEAAmE;IACnE,kEAAkE;IAClE,6CAA6C;IAC7C,MAAM,WAAW,GAAG,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC9E,QAAQ,WAAW,EAAE,CAAC;QACpB,KAAK,mBAAW,CAAC,aAAa;YAC5B,OAAO,eAAe,CAAC;QACzB,KAAK,mBAAW,CAAC,QAAQ;YACvB,OAAO,UAAU,CAAC;QACpB,KAAK,mBAAW,CAAC,KAAK;YACpB,OAAO,OAAO,CAAC;QACjB;YACE,OAAO,SAAS,CAAC;IACrB,CAAC;AACH,CAAC;AAhBD,8CAgBC;AAED,iEAAiE;AACjE,SAAgB,cAAc,CAAC,EAAU;IACvC,OAAQ,MAAM,CAAC,MAAM,CAAC,mBAAW,CAAc,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;AAC/D,CAAC;AAFD,wCAEC;AAED,+DAA+D;AAC/D,SAAgB,YAAY,CAAC,EAAU;IACrC,OAAQ,MAAM,CAAC,MAAM,CAAC,iBAAS,CAAc,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;AAC7D,CAAC;AAFD,oCAEC;AAED;;;;;;;;GAQG;AACU,QAAA,cAAc,GAAG;IAC5B,aAAa,EAAE,wBAAwB;IACvC,QAAQ,EAAE,oBAAoB;IAC9B,KAAK,EAAE,iBAAiB;CAChB,CAAC;AAIX,6CAA6C;AAC7C,SAAgB,mBAAmB,CAAC,IAA4C;IAC9E,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,eAAe;YAClB,OAAO,sBAAc,CAAC,aAAa,CAAC;QACtC,KAAK,UAAU;YACb,OAAO,sBAAc,CAAC,QAAQ,CAAC;QACjC,KAAK,OAAO;YACV,OAAO,sBAAc,CAAC,KAAK,CAAC;IAChC,CAAC;AACH,CAAC;AATD,kDASC;AAED,gEAAgE;AAChE,SAAgB,cAAc,CAAC,GAAW;IACxC,OAAQ,MAAM,CAAC,MAAM,CAAC,sBAAc,CAAc,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;AACnE,CAAC;AAFD,wCAEC"}
+{"version":3,"file":"conventions.js","sourceRoot":"","sources":["../src/conventions.ts"],"names":[],"mappings":"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"}