agentfootprint 9.136.0 → 9.138.0

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

@@ -1,93 +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 { notApplicable } from '../../lib/claim/claim.js';
-import { registerCacheStrategy } from '../strategyRegistry.js';
-import { isDevMode } from '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;
-export 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 && 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 notApplicable('the Bedrock adapter does not read cache usage off the Converse response, so no ' +
-            'cache tokens ever reach the port');
-    }
-}
-registerCacheStrategy(new BedrockCacheStrategy());
-//# sourceMappingURL=BedrockCacheStrategy.js.map

package/dist/esm/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,OAAO,EAAE,aAAa,EAAc,MAAM,0BAA0B,CAAC;AAErE,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;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,MAAM,OAAO,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,SAAS,EAAE,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,aAAa,CAClB,iFAAiF;YAC/E,kCAAkC,CACrC,CAAC;IACJ,CAAC;CACF;AAED,qBAAqB,CAAC,IAAI,oBAAoB,EAAE,CAAC,CAAC"}

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

@@ -1,47 +0,0 @@
-/**
- * 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.
- */
-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 OpenAICacheStrategy implements CacheStrategy {
-    readonly providerName = "openai";
-    readonly capabilities: CacheCapabilities;
-    prepareRequest(req: LLMRequest, _candidates: readonly CacheMarker[], _ctx: CacheStrategyContext): Promise<{
-        readonly request: LLMRequest;
-        readonly markersApplied: readonly CacheMarker[];
-    }>;
-    /**
-     * 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: CacheUsage | undefined): Claim<CacheMetrics>;
-}

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

@@ -1,72 +0,0 @@
-/**
- * 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.
- */
-import { notApplicable } from '../../lib/claim/claim.js';
-import { registerCacheStrategy } from '../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,
-});
-export 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 notApplicable('the OpenAI adapter does not lift prompt_tokens_details.cached_tokens onto the port ' +
-            'usage, so no cache tokens ever reach this strategy');
-    }
-}
-// Auto-register for both server-side and browser variants.
-{
-    const strategy = new OpenAICacheStrategy();
-    registerCacheStrategy(strategy);
-    const browserStrategy = {
-        providerName: 'browser-openai',
-        capabilities: strategy.capabilities,
-        prepareRequest: strategy.prepareRequest.bind(strategy),
-        extractMetrics: strategy.extractMetrics.bind(strategy),
-    };
-    registerCacheStrategy(browserStrategy);
-}
-//# sourceMappingURL=OpenAICacheStrategy.js.map

package/dist/esm/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,OAAO,EAAE,aAAa,EAAc,MAAM,0BAA0B,CAAC;AAErE,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;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,MAAM,OAAO,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,aAAa,CAClB,qFAAqF;YACnF,oDAAoD,CACvD,CAAC;IACJ,CAAC;CACF;AAED,2DAA2D;AAC3D,CAAC;IACC,MAAM,QAAQ,GAAG,IAAI,mBAAmB,EAAE,CAAC;IAC3C,qBAAqB,CAAC,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,qBAAqB,CAAC,eAAe,CAAC,CAAC;AACzC,CAAC"}

package/dist/esm/cache/strategyRegistry.d.ts

@@ -1,45 +0,0 @@
-/**
- * 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.
- */
-import type { CacheStrategy } from './types.js';
-/**
- * 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.
- */
-export declare function getDefaultCacheStrategy(providerName: string): CacheStrategy;
-/**
- * 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.
- */
-export declare function registerCacheStrategy(strategy: CacheStrategy): void;
-/**
- * Read-only view of registered strategy names. Useful for diagnostics
- * (e.g., logging "we have strategies for: anthropic, openai, *").
- */
-export declare function listRegisteredStrategies(): readonly string[];
-/**
- * Internal helper for tests: reset the registry to the default
- * (wildcard → NoOp only). Not exported from the public barrel.
- */
-export declare function _resetRegistryForTests(): void;

package/dist/esm/cache/strategyRegistry.js

@@ -1,74 +0,0 @@
-/**
- * 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.
- */
-import { NoOpCacheStrategy } from './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()]]);
-/**
- * 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.
- */
-export 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('*');
-}
-/**
- * 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.
- */
-export function registerCacheStrategy(strategy) {
-    REGISTRY.set(strategy.providerName, strategy);
-}
-/**
- * Read-only view of registered strategy names. Useful for diagnostics
- * (e.g., logging "we have strategies for: anthropic, openai, *").
- */
-export function listRegisteredStrategies() {
-    return [...REGISTRY.keys()];
-}
-/**
- * Internal helper for tests: reset the registry to the default
- * (wildcard → NoOp only). Not exported from the public barrel.
- */
-export function _resetRegistryForTests() {
-    REGISTRY.clear();
-    REGISTRY.set('*', new NoOpCacheStrategy());
-}
-//# sourceMappingURL=strategyRegistry.js.map

package/dist/esm/cache/strategyRegistry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"strategyRegistry.js","sourceRoot":"","sources":["../../../src/cache/strategyRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAwB,CAAC,CAAC,GAAG,EAAE,IAAI,iBAAiB,EAAE,CAAC,CAAC,CAAC,CAAC;AAElF;;;;;GAKG;AACH,MAAM,UAAU,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;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAAuB;IAC3D,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;AAChD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,wBAAwB;IACtC,OAAO,CAAC,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;AAC9B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB;IACpC,QAAQ,CAAC,KAAK,EAAE,CAAC;IACjB,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,iBAAiB,EAAE,CAAC,CAAC;AAC7C,CAAC"}

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

@@ -1,42 +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>;
-}
-//# sourceMappingURL=AnthropicCacheStrategy.d.ts.map

package/dist/types/cache/strategies/AnthropicCacheStrategy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AnthropicCacheStrategy.d.ts","sourceRoot":"","sources":["../../../../src/cache/strategies/AnthropicCacheStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,UAAU,EACX,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAEtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAc1D,qBAAa,sBAAuB,YAAW,aAAa;IAC1D,QAAQ,CAAC,YAAY,eAAe;IACpC,QAAQ,CAAC,YAAY,oBAA0B;IAEzC,cAAc,CAClB,GAAG,EAAE,UAAU,EACf,UAAU,EAAE,SAAS,WAAW,EAAE,EAClC,GAAG,EAAE,oBAAoB,GACxB,OAAO,CAAC;QACT,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;QAC7B,QAAQ,CAAC,cAAc,EAAE,SAAS,WAAW,EAAE,CAAC;KACjD,CAAC;IA4BF,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,KAAK,CAAC,YAAY,CAAC;CAGnE"}

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

@@ -1,63 +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>;
-}
-//# sourceMappingURL=BedrockCacheStrategy.d.ts.map

package/dist/types/cache/strategies/BedrockCacheStrategy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BedrockCacheStrategy.d.ts","sourceRoot":"","sources":["../../../../src/cache/strategies/BedrockCacheStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,UAAU,EACX,MAAM,aAAa,CAAC;AACrB,OAAO,EAAiB,KAAK,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAoB1D,qBAAa,oBAAqB,YAAW,aAAa;IACxD,QAAQ,CAAC,YAAY,aAAa;IAClC,QAAQ,CAAC,YAAY,oBAAwB;IAEvC,cAAc,CAClB,GAAG,EAAE,UAAU,EACf,UAAU,EAAE,SAAS,WAAW,EAAE,EAClC,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC;QACT,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;QAC7B,QAAQ,CAAC,cAAc,EAAE,SAAS,WAAW,EAAE,CAAC;KACjD,CAAC;IAmBF;;;;;;;;;;OAUG;IACH,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,KAAK,CAAC,YAAY,CAAC;CAMpE"}

package/dist/types/cache/strategies/OpenAICacheStrategy.d.ts

@@ -1,48 +0,0 @@
-/**
- * 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.
- */
-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 OpenAICacheStrategy implements CacheStrategy {
-    readonly providerName = "openai";
-    readonly capabilities: CacheCapabilities;
-    prepareRequest(req: LLMRequest, _candidates: readonly CacheMarker[], _ctx: CacheStrategyContext): Promise<{
-        readonly request: LLMRequest;
-        readonly markersApplied: readonly CacheMarker[];
-    }>;
-    /**
-     * 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: CacheUsage | undefined): Claim<CacheMetrics>;
-}
-//# sourceMappingURL=OpenAICacheStrategy.d.ts.map

package/dist/types/cache/strategies/OpenAICacheStrategy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OpenAICacheStrategy.d.ts","sourceRoot":"","sources":["../../../../src/cache/strategies/OpenAICacheStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,UAAU,EACX,MAAM,aAAa,CAAC;AACrB,OAAO,EAAiB,KAAK,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAc1D,qBAAa,mBAAoB,YAAW,aAAa;IACvD,QAAQ,CAAC,YAAY,YAAY;IACjC,QAAQ,CAAC,YAAY,oBAAuB;IAEtC,cAAc,CAClB,GAAG,EAAE,UAAU,EACf,WAAW,EAAE,SAAS,WAAW,EAAE,EACnC,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC;QACT,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;QAC7B,QAAQ,CAAC,cAAc,EAAE,SAAS,WAAW,EAAE,CAAC;KACjD,CAAC;IAKF;;;;;;;;;OASG;IACH,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,KAAK,CAAC,YAAY,CAAC;CAMpE"}

package/dist/types/cache/strategyRegistry.d.ts

@@ -1,46 +0,0 @@
-/**
- * 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.
- */
-import type { CacheStrategy } from './types.js';
-/**
- * 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.
- */
-export declare function getDefaultCacheStrategy(providerName: string): CacheStrategy;
-/**
- * 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.
- */
-export declare function registerCacheStrategy(strategy: CacheStrategy): void;
-/**
- * Read-only view of registered strategy names. Useful for diagnostics
- * (e.g., logging "we have strategies for: anthropic, openai, *").
- */
-export declare function listRegisteredStrategies(): readonly string[];
-/**
- * Internal helper for tests: reset the registry to the default
- * (wildcard → NoOp only). Not exported from the public barrel.
- */
-export declare function _resetRegistryForTests(): void;
-//# sourceMappingURL=strategyRegistry.d.ts.map

package/dist/types/cache/strategyRegistry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strategyRegistry.d.ts","sourceRoot":"","sources":["../../../src/cache/strategyRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAYhD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,CAW3E;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI,CAEnE;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,SAAS,MAAM,EAAE,CAE5D;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAG7C"}