@deepstrike/sdk 0.2.60 → 0.2.61

package/dist/runtime/runner.js

@@ -1575,6 +1575,8 @@ export class RuntimeRunner {
                         let turnOutputTokens = 0;
                         let turnCacheReadTokens = 0;
                         let turnCacheCreationTokens = 0;
+                        let turnCacheTelemetryStatus = "unavailable";
+                        let turnCacheTelemetrySource;
                         let turnCacheReadBySlot;
                         let turnStopReason;
                         const providerPlan = createProviderRequestPlanForProvider(this.opts.provider, context, tools, ext);
@@ -1640,9 +1642,36 @@ export class RuntimeRunner {
                                     // P0-C: capture the prompt-cache split for the tool-gating hit-rate baseline.
                                     turnCacheReadTokens = usageEvt.cacheReadInputTokens ?? 0;
                                     turnCacheCreationTokens = usageEvt.cacheCreationInputTokens ?? 0;
+                                    turnCacheTelemetryStatus = usageEvt.cacheTelemetryStatus
+                                        ?? usageEvt.providerUsage?.cacheTelemetryStatus
+                                        ?? ((usageEvt.cacheReadInputTokens ?? 0) > 0 || (usageEvt.cacheCreationInputTokens ?? 0) > 0
+                                            ? "measured"
+                                            : "unavailable");
+                                    turnCacheTelemetrySource = usageEvt.cacheTelemetrySource ?? usageEvt.providerUsage?.cacheTelemetrySource;
                                     // I1: per-slot attribution forwarded into TurnMetrics. Undefined when the provider
                                     // doesn't honor cache_control (OpenAI-family auto-cache).
                                     turnCacheReadBySlot = usageEvt.cacheReadInputTokensBySlot;
+                                    // spc_024-06: postflight observed input is the authority (INV-024-08). Feed it back
+                                    // as a durable measurement fact for this exact request fingerprint so replay reuses
+                                    // the observed truth instead of re-counting (or trusting the preflight estimate).
+                                    if (turnInputTokens > 0) {
+                                        const postflight = recordPromptMeasurement(providerPlan, {
+                                            inputTokens: turnInputTokens,
+                                            source: { kind: "postflight" },
+                                            confidence: "exact",
+                                        });
+                                        recordedMeasurements.set(providerPlan.fingerprint, postflight);
+                                        await this.opts.sessionLog.append(sessionId, {
+                                            kind: "prompt_measured",
+                                            turn: runtime.turn(),
+                                            measurement: {
+                                                requestFingerprint: postflight.requestFingerprint,
+                                                inputTokens: postflight.inputTokens,
+                                                source: postflight.source,
+                                                confidence: postflight.confidence,
+                                            },
+                                        });
+                                    }
                                     // Phase 4: stop_reason drives the kernel's max-output-tokens recovery. The closing
                                     // usage frame carries it; keep the last non-empty value seen this turn.
                                     if (usageEvt.stopReason)
@@ -1782,6 +1811,10 @@ export class RuntimeRunner {
                                     inputTokens: turnInputTokens,
                                     cacheReadTokens: turnCacheReadTokens,
                                     cacheCreationTokens: turnCacheCreationTokens,
+                                    cacheTelemetryStatus: turnCacheTelemetryStatus,
+                                    ...(turnCacheTelemetrySource ? { cacheTelemetrySource: turnCacheTelemetrySource } : {}),
+                                    requestFingerprint: providerPlan.fingerprint,
+                                    stablePrefixFingerprint: providerPlan.stablePrefixFingerprint,
                                     ...(turnCacheReadBySlot ? { cacheReadTokensBySlot: turnCacheReadBySlot } : {}),
                                 });
                             }

package/dist/types.d.ts

@@ -151,10 +151,9 @@ export interface UsageEvent extends StreamEvent {
     cacheReadInputTokens?: number;
     /** Prompt tokens written to cache this request (billed ~1.25x). Subset of inputTokens. */
     cacheCreationInputTokens?: number;
-    /** I1: per-slot pro-rata attribution of `cacheReadInputTokens`. Estimated, not authoritative —
-     *  Anthropic returns a single cache-read total, so the SDK divides it evenly across the slots
-     *  that carried a `cache_control` breakpoint on the request. Missing when the provider doesn't
-     *  honor `cache_control` (OpenAI-family auto-cache) or when no breakpoints were placed. */
+    cacheTelemetryStatus?: CacheTelemetryStatus;
+    cacheTelemetrySource?: CacheTelemetrySource;
+    /** Reserved for provider-authoritative per-slot data. DeepStrike does not estimate this field. */
     cacheReadInputTokensBySlot?: {
         system?: number;
         tools?: number;
@@ -339,12 +338,16 @@ export interface ProviderUsage {
     outputTokens: number;
     cacheReadInputTokens?: number;
     cacheCreationInputTokens?: number;
+    cacheTelemetryStatus?: CacheTelemetryStatus;
+    cacheTelemetrySource?: CacheTelemetrySource;
     /** Output tokens spent on hidden reasoning (OpenAI `completion_tokens_details.reasoning_tokens` /
      *  Responses `output_tokens_details.reasoning_tokens`). A SUBSET of `outputTokens`, not additional
      *  — vendors that don't report a separate count (Anthropic, Gemini via this SDK) leave this unset
      *  rather than guessing. */
     reasoningTokens?: number;
 }
+export type CacheTelemetryStatus = "measured" | "unavailable";
+export type CacheTelemetrySource = "anthropic_usage" | "openai_prompt_details" | "deepseek_prompt_cache" | "gemini_usage";
 /** Node-side mirror of the reserved Rust `context::measurement` types — where a
  *  preflight token count came from. Field names/shape intentionally match the Rust
  *  `MeasurementSource` enum (`kind`-tagged, snake_case variant names) so the two sides can be
@@ -523,7 +526,7 @@ export interface LLMProvider {
      * capability remains directly callable, but no dispatch trigger is enabled until request
      * fingerprinting and durable measurement semantics are defined.
      */
-    countTokens?(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<PromptMeasurement>;
+    countTokens?(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState): Promise<PromptMeasurement>;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState, 
     /** #2-B-ii: when provided, a preempting `InterruptNow` (or `interrupt()`) aborts the in-flight

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deepstrike/sdk",
-  "version": "0.2.60",
+  "version": "0.2.61",
   "description": "DeepStrike Node.js SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -72,9 +72,9 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.99.0",
-    "@deepstrike/core": "0.2.60",
+    "@deepstrike/core": "0.2.61",
     "@google/generative-ai": "^0.24.1",
-    "openai": "^5.23.2"
+    "openai": "^7.5.0"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",