@deepstrike/sdk 0.2.62 → 0.2.63

package/LICENSE

@@ -0,0 +1,106 @@
+DeepStrike License (Dual License)
+Version 1.0 — 2026-09-01
+
+Copyright (c) 2025-2026 DeepStrike Contributors
+Project: https://github.com/kongusen/deepstrike
+
+======================================================================
+中文摘要（便于理解，不具有法律效力；以下英文条款为准）
+======================================================================
+
+本软件采用双授权模式：
+
+1. 个人，以及上一财年总营收低于 1,000,000 美元的组织（含其关联方），
+   可按 MIT 条款免费使用本软件（见第 2 节），包括使用、复制、修改、
+   合并、发布、分发、再授权及销售的权利。
+2. 上一财年总营收达到或超过 1,000,000 美元的组织（含其关联方），
+   在使用本软件之前（包括内部使用、基于本软件开发的项目、以及对外
+   分发此类产品或服务）须向作者获取商业授权（见第 3 节）。
+   获取方式：发送邮件至 wanghaishan0210@gmail.com，或通过
+   https://github.com/kongusen/deepstrike 提交 Issue / Discussion
+   联系作者。出于评估目的的试用不超过 30 天除外。
+3. 当组织的年营收增长至达到或超过该阈值时，自该时点起第 2 节的免费
+   授权终止，须获取商业授权后方可继续使用。
+4. v0.2.62 及之前已经以 MIT 协议发布的版本继续适用 MIT 协议，不受
+   本协议影响。本协议仅适用于随其一同分发的版本。
+
+======================================================================
+TERMS AND CONDITIONS
+======================================================================
+
+1. DEFINITIONS
+
+"Software" means the DeepStrike software and associated documentation
+files distributed by the Licensor, including all copies and substantial
+portions thereof.
+
+"Licensor" means the copyright holders of the Software (the DeepStrike
+Contributors), represented by the project maintainer at
+https://github.com/kongusen/deepstrike.
+
+"You" (or "Licensee") means the individual or legal entity exercising
+permissions granted by this License, including, where that entity is an
+organization, all entities that control, are controlled by, or are under
+common control with that entity ("Affiliates"). "Control" means ownership
+of more than fifty percent (50%) of the equity or voting interests, or
+the power to direct management and policies.
+
+"Annual Revenue" means the total gross revenue of You and Your Affiliates
+for the most recently completed fiscal year, expressed in US dollars or
+converted into US dollars at prevailing exchange rates.
+
+2. FREE LICENSE FOR INDIVIDUALS AND SMALL ORGANIZATIONS
+
+If You are an individual, or a legal entity whose Annual Revenue is less
+than one million US dollars (USD 1,000,000), the Licensor hereby grants
+You, free of charge, permission to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify,
+merge, publish, distribute, sublicense, and/or sell copies of the
+Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+(a) The above copyright notice and this License shall be included in all
+    copies or substantial portions of the Software.
+
+(b) If Your Annual Revenue reaches or exceeds USD 1,000,000, the grant in
+    this Section 2 terminates for You, and Section 3 applies from that
+    point on.
+
+3. COMMERCIAL LICENSE REQUIRED (ANNUAL REVENUE >= USD 1,000,000)
+
+If Your Annual Revenue equals or exceeds one million US dollars
+(USD 1,000,000), You must obtain a commercial license from the Licensor
+before using the Software. This applies to every form of use, including
+internal use, use within products or services developed based on the
+Software, and distribution or provision of such products or services to
+third parties.
+
+Exception: You may use the Software without a commercial license solely
+for evaluation purposes, for a period of up to thirty (30) days.
+
+To obtain a commercial license, contact the Licensor at
+wanghaishan0210@gmail.com, or via the project repository at
+https://github.com/kongusen/deepstrike (open an issue or discussion).
+Commercial terms, including fees, are set by individual agreement with
+the Licensor.
+
+Any use of the Software requiring a commercial license under this
+Section 3 without one is unlicensed use and constitutes copyright
+infringement.
+
+4. PRIOR VERSIONS
+
+Versions of the Software released before this License took effect (up to
+and including version 0.2.62) were released under the MIT License and
+remain available under the terms of the MIT License. This License applies
+only to versions of the Software distributed together with it.
+
+5. NO WARRANTY
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/dist/index.d.ts

@@ -13,7 +13,9 @@ export type { ContextPolicyOverrides, ContextPolicy, ContextPolicyWire, ContextP
 export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export type { ExecutionPlane, RunContext } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
-export type { SessionLog, SessionEvent } from "./runtime/session-log.js";
+export type { SessionLog, SessionEvent, SessionEventKind } from "./runtime/session-log.js";
+export { SESSION_EVENT_KINDS } from "./runtime/session-log.js";
+export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCanonicalContentParts, } from "./runtime/kernel-step.js";
 export { FileKernelJournal, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./runtime/kernel-journal.js";
 export type { CheckpointCandidate, InstalledCheckpoint, JournalAppendReceipt, JournalEntry, JournalHead, JournalPruneReceipt, JournalRecordInput, KernelJournal, } from "./runtime/kernel-journal.js";
 export { diagnoseKernelJournal } from "./runtime/kernel-doctor.js";
@@ -43,8 +45,10 @@ export { OpenAIResponsesProvider } from "./providers/openai-responses.js";
 export { createProvider, createProviderAsync, resolveProviderRuntime, resolveProviderRuntimeAsync } from "./providers/catalog.js";
 export { UnsupportedModalityError } from "./providers/base.js";
 export type { CreateProviderOptions, EndpointProfileId } from "./providers/catalog.js";
-export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement } from "./providers/request-plan.js";
-export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, RecordedPromptMeasurement } from "./providers/request-plan.js";
+export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement, resolveProviderRoute } from "./providers/request-plan.js";
+export type { CostObservation, NormalizedProviderUsage, PricingSnapshot, ProviderRequestEndpoint, ProviderRequestPlan, RecordedPromptMeasurement, ResolvedProviderRoute } from "./providers/request-plan.js";
+export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY } from "./runtime/execution-evidence.js";
+export type { InvocationOutcome, ModelInvocation, ProviderAttempt, ProviderAttemptRecord, ProviderAttemptStatus, UsageAccountingPolicy, UsageSettlement } from "./runtime/execution-evidence.js";
 export type { GovernancePolicy, GovernanceConstraint } from "./governance.js";
 export { AgentPool } from "./collaboration/pool.js";
 export { Agent } from "./agent.js";
@@ -57,7 +61,7 @@ export type { Knowledge, KnowledgeSourceRef } from "./knowledge/public.js";
 export type { AgentRef, Handoff } from "./handoff-target.js";
 export type { Session } from "./session.js";
 export type { RuntimeSignal, SignalClaim, SignalDeliveryReceipt, SignalSource, } from "./signals/types.js";
-export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, MediaSource, ContentBlockText, ContentBlockImage, ContentBlockAudio, ContentBlockVideo, ContentBlockFile, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, RetryConfig, TokenUsage, } from "./types.js";
+export type { Message, ToolCall, ToolResult, ToolSchema, ContentPart, TextPart, ImagePart, AudioPart, MediaSource, ContentBlockText, ContentBlockImage, ContentBlockAudio, ContentBlockVideo, ContentBlockFile, StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, ToolChunk, ToolDeltaEvent, ToolSuspendEvent, ToolResultEvent, ToolAuditFailedEvent, DoneEvent, ErrorEvent, PermissionRequestEvent, PermissionResolvedEvent, PermissionResponse, EntropySample, EntropySampleEvent, EntropyAlertEvent, EntropyWatchOptions, LLMProvider, RetryConfig, TokenUsage, ProviderWireEvidence, ProviderTransportTelemetry, } from "./types.js";
 export { DurableContentError, decodeDurableContent, decodeDurableToolResult, encodeDurableContent, encodeDurableToolResult, toolOutputBlocksToDurable, durableBlocksToToolOutput, } from "./runtime/durable-content.js";
 export type { DurableContent, DurableContentBlock, DurableSource, DurableToolResult } from "./runtime/durable-content.js";
 export type { WorkflowSpec, WorkflowNodeSpec, SchedulingFactors, WorkflowDependencyPolicy, WorkflowNodeStatus, WorkflowNodeOutcome, WorkflowOutcome, } from "./types/agent.js";

package/dist/index.js

@@ -20,6 +20,10 @@ export { DEFAULT_CONTEXT_POLICY, PPM_SCALE, contextPolicy, normalizeContextPolic
 // ── Execution plane + session log (the defaults) ────────────────────────────
 export { LocalExecutionPlane } from "./runtime/execution-plane.js";
 export { InMemorySessionLog, FileSessionLog } from "./runtime/session-log.js";
+// Registered session-event vocabulary (F9/S3; manifest-pinned by sdk-conformance, P7-S4)
+export { SESSION_EVENT_KINDS } from "./runtime/session-log.js";
+// ── content-parts-v1 registered encoding (F14/B5; byte-pinned by sdk-conformance) ──
+export { CANONICAL_CONTENT_PARTS_PREFIX, encodeCanonicalContentParts, decodeCanonicalContentParts, } from "./runtime/kernel-step.js";
 // ── Durable transaction capability (Canonical Kernel ABI §9.1) ──────────────
 export { FileKernelJournal, InMemoryKernelJournal, JournalCasConflictError, JournalIntegrityError, JournalIoError, } from "./runtime/kernel-journal.js";
 export { diagnoseKernelJournal } from "./runtime/kernel-doctor.js";
@@ -40,7 +44,8 @@ export { OpenAIProvider } from "./providers/openai.js";
 export { OpenAIResponsesProvider } from "./providers/openai-responses.js";
 export { createProvider, createProviderAsync, resolveProviderRuntime, resolveProviderRuntimeAsync } from "./providers/catalog.js";
 export { UnsupportedModalityError } from "./providers/base.js";
-export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement } from "./providers/request-plan.js";
+export { createProviderRequestPlan, createProviderRequestPlanForProvider, estimateProviderPromptTokens, measurementForPlan, normalizeProviderUsage, priceProviderUsage, recordPromptMeasurement, resolveProviderRoute } from "./providers/request-plan.js";
+export { FULL_FOOTPRINT_USAGE_ACCOUNTING_POLICY } from "./runtime/execution-evidence.js";
 // ── Multi-agent primitive ───────────────────────────────────────────────────
 // Parallel fan-out / sub-agent delegation. The full orchestration layer is in `@deepstrike/sdk/workflow`.
 export { AgentPool } from "./collaboration/pool.js";

package/dist/providers/anthropic.d.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, Message, PromptMeasurement, ProviderDescriptor, ProviderReplay, ProviderRunState, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, Message, PromptMeasurement, ProviderDescriptor, ProviderReplay, ProviderRunState, ProviderTransportTelemetry, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 export interface AnthropicProviderConfig {
     apiKey: string;
@@ -29,6 +29,10 @@ export declare class AnthropicProvider implements LLMProvider {
     /** Identity advertised in the descriptor; overridden by Anthropic-compatible vendors. */
     protected providerName(): string;
     descriptor(): ProviderDescriptor;
+    /** P4-S1: transport facts of the most recent execution (rung count + wire response id).
+     *  Host evidence only — never kernel input (B7). */
+    private lastTelemetry;
+    peekTransportTelemetry(): ProviderTransportTelemetry | undefined;
     bindResolvedRuntime(resolved: ResolvedAnthropicRuntime): void;
     peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
     seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;

package/dist/providers/anthropic.js

@@ -70,6 +70,12 @@ export class AnthropicProvider {
             },
         };
     }
+    /** P4-S1: transport facts of the most recent execution (rung count + wire response id).
+     *  Host evidence only — never kernel input (B7). */
+    lastTelemetry;
+    peekTransportTelemetry() {
+        return this.lastTelemetry;
+    }
     bindResolvedRuntime(resolved) {
         if (resolved.identity.protocol !== "anthropic-messages"
             || resolved.identity.providerId !== this.providerName()
@@ -138,8 +144,11 @@ export class AnthropicProvider {
         let lastErr;
         for (let attempt = 0; attempt < this.maxRetries; attempt++) {
             try {
+                this.lastTelemetry = { rungs: attempt + 1 };
                 const raw = await this.createMessage(plan.params, plan.transport);
                 this.circuit.recordSuccess();
+                if (typeof raw.id === "string")
+                    this.lastTelemetry = { rungs: attempt + 1, responseId: raw.id };
                 const decoded = this.adapter.decodeComplete(raw, { input });
                 if (decoded.replay?.native_blocks) {
                     this.rememberNativeBlocks(decoded.message, decoded.replay.native_blocks);
@@ -183,7 +192,13 @@ export class AnthropicProvider {
         try {
             const { input, plan } = this.buildPlan(context, tools, extensions);
             const state = this.adapter.createStreamState({ input });
+            this.lastTelemetry = { rungs: 1 };
             for await (const chunk of this.streamMessage(plan.params, plan.transport, signal)) {
+                if (this.lastTelemetry.responseId === undefined && chunk.type === "message_start") {
+                    const id = chunk.message?.id;
+                    if (typeof id === "string")
+                        this.lastTelemetry = { rungs: 1, responseId: id };
+                }
                 for (const event of this.adapter.pushStreamChunk(chunk, state).events)
                     yield event;
             }

package/dist/providers/gemini.d.ts

@@ -1,5 +1,5 @@
 import { type Content } from "@google/generative-ai";
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy, PromptMeasurement } from "../types.js";
+import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy, PromptMeasurement, ProviderTransportTelemetry } from "../types.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 type ResolvedGeminiRuntime = CanonicalAdapterInput["resolved"];
 export declare function buildContents(turns: Message[]): Content[];
@@ -13,6 +13,9 @@ export declare class GeminiProvider implements LLMProvider {
     private requestOptions;
     private readonly resolvedRuntimePolicy;
     private readonly adapter;
+    /** P4-S1: transport facts of the most recent execution. Host evidence only (B7). */
+    private lastTelemetry;
+    peekTransportTelemetry(): ProviderTransportTelemetry | undefined;
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;

package/dist/providers/gemini.js

@@ -19,6 +19,11 @@ export class GeminiProvider {
     requestOptions;
     resolvedRuntimePolicy;
     adapter = new GeminiAdapter();
+    /** P4-S1: transport facts of the most recent execution. Host evidence only (B7). */
+    lastTelemetry;
+    peekTransportTelemetry() {
+        return this.lastTelemetry;
+    }
     constructor(apiKey, model = "gemini-2.0-flash", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = GEMINI_BASE, runtimePolicy = {}, resolvedRuntime) {
         this.model = model;
         this.resolvedRuntime = resolvedRuntime;
@@ -89,9 +94,13 @@ export class GeminiProvider {
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
+                this.lastTelemetry = { rungs: i + 1 };
                 const m = this.genAI.getGenerativeModel(plan.modelParams, this.requestOptions);
                 const resp = await m.generateContent(plan.request);
                 this.circuit.recordSuccess();
+                const responseId = resp.response.responseId;
+                if (typeof responseId === "string")
+                    this.lastTelemetry = { rungs: i + 1, responseId };
                 return this.adapter.decodeComplete(resp.response, { input }).message;
             }
             catch (err) {
@@ -110,11 +119,16 @@ export class GeminiProvider {
             const m = this.genAI.getGenerativeModel(plan.modelParams, this.requestOptions);
             const result = await m.generateContentStream(plan.request);
             const state = this.adapter.createStreamState({ input });
+            this.lastTelemetry = { rungs: 1 };
             for await (const chunk of result.stream) {
                 for (const event of this.adapter.pushStreamChunk(chunk, state).events)
                     yield event;
             }
-            for (const event of this.adapter.finishStream(state, await result.response).events)
+            const finalResponse = await result.response;
+            const responseId = finalResponse.responseId;
+            if (typeof responseId === "string")
+                this.lastTelemetry = { rungs: 1, responseId };
+            for (const event of this.adapter.finishStream(state, finalResponse).events)
                 yield event;
         }
         catch (error) {

package/dist/providers/ollama.d.ts

@@ -1,4 +1,4 @@
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy, ProviderTransportTelemetry } from "../types.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 type ResolvedOllamaRuntime = CanonicalAdapterInput["resolved"];
 export declare class OllamaProvider implements LLMProvider {
@@ -8,6 +8,9 @@ export declare class OllamaProvider implements LLMProvider {
     private resolvedRuntime?;
     private readonly adapter;
     constructor(model?: string, baseUrl?: string, resolvedRuntimePolicy?: RuntimePolicy, resolvedRuntime?: ResolvedOllamaRuntime | undefined);
+    /** P4-S1: transport facts of the most recent execution (Ollama's wire has no response id). */
+    private lastTelemetry;
+    peekTransportTelemetry(): ProviderTransportTelemetry | undefined;
     runtimePolicy(): RuntimePolicy;
     bindResolvedRuntime(resolved: ResolvedOllamaRuntime): void;
     private adapterInput;

package/dist/providers/ollama.js

@@ -14,6 +14,11 @@ export class OllamaProvider {
         this.resolvedRuntimePolicy = resolvedRuntimePolicy;
         this.resolvedRuntime = resolvedRuntime;
     }
+    /** P4-S1: transport facts of the most recent execution (Ollama's wire has no response id). */
+    lastTelemetry;
+    peekTransportTelemetry() {
+        return this.lastTelemetry;
+    }
     runtimePolicy() {
         return this.resolvedRuntimePolicy;
     }
@@ -53,6 +58,7 @@ export class OllamaProvider {
         try {
             const input = this.adapterInput(context, tools, extensions);
             const body = { ...this.adapter.buildRequest(input), stream: false };
+            this.lastTelemetry = { rungs: 1 };
             const resp = await fetch(`${this.baseUrl}/api/chat`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
@@ -71,6 +77,7 @@ export class OllamaProvider {
         try {
             const input = this.adapterInput(context, tools, extensions);
             const body = { ...this.adapter.buildRequest(input), stream: true };
+            this.lastTelemetry = { rungs: 1 };
             const resp = await fetch(`${this.baseUrl}/api/chat`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },

package/dist/providers/openai-responses.d.ts

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import type { LLMProvider, Message, PromptMeasurement, ProviderRunState, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, Message, PromptMeasurement, ProviderRunState, ProviderTransportTelemetry, RenderedContext, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 import { OpenAIResponsesAdapter, type OpenAIResponsesRunState } from "./openai-responses-adapter.js";
@@ -32,5 +32,8 @@ export declare class OpenAIResponsesProvider implements LLMProvider {
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, state?: ProviderRunState, signal?: AbortSignal): AsyncIterable<StreamEvent>;
     private builtinTools;
     private requestExtensions;
+    /** P4-S1: transport facts of the most recent execution. Host evidence only (B7). */
+    private lastTelemetry;
+    peekTransportTelemetry(): ProviderTransportTelemetry | undefined;
     private asRunState;
 }

package/dist/providers/openai-responses.js

@@ -86,8 +86,12 @@ export class OpenAIResponsesProvider {
         let lastError;
         for (let attempt = 0; attempt < this.maxRetries; attempt++) {
             try {
+                this.lastTelemetry = { rungs: attempt + 1 };
                 const response = await this.client.responses.create(plan.params);
                 this.circuit.recordSuccess();
+                const responseId = response.id;
+                if (typeof responseId === "string")
+                    this.lastTelemetry = { rungs: attempt + 1, responseId };
                 return this.responses.decodeComplete(response, { input }).message;
             }
             catch (error) {
@@ -130,7 +134,14 @@ export class OpenAIResponsesProvider {
             const plan = this.responses.buildRequest(input, runState);
             const streamState = this.responses.createStreamState({ input }, runState);
             const stream = await this.client.responses.create({ ...plan.params, stream: true }, signal ? { signal } : undefined);
+            this.lastTelemetry = { rungs: 1 };
             for await (const chunk of stream) {
+                if (this.lastTelemetry.responseId === undefined
+                    && (chunk.type === "response.completed" || chunk.type === "response.incomplete" || chunk.type === "response.created")) {
+                    const id = chunk.response?.id;
+                    if (typeof id === "string")
+                        this.lastTelemetry = { rungs: 1, responseId: id };
+                }
                 const output = this.responses.pushStreamChunk(chunk, streamState);
                 for (const event of output.events)
                     yield event;
@@ -160,6 +171,11 @@ export class OpenAIResponsesProvider {
     requestExtensions(extensions) {
         return this.responses.requestExtensions(extensions);
     }
+    /** P4-S1: transport facts of the most recent execution. Host evidence only (B7). */
+    lastTelemetry;
+    peekTransportTelemetry() {
+        return this.lastTelemetry;
+    }
     asRunState(state) {
         if (!state)
             return this.createRunState();

package/dist/providers/openai.d.ts

@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import type { LLMProvider, Message, ProviderDescriptor, ProviderReplay, ProviderRunState, RenderedContext, ReplayabilityAssessment, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
+import type { LLMProvider, Message, ProviderDescriptor, ProviderReplay, ProviderRunState, ProviderTransportTelemetry, RenderedContext, ReplayabilityAssessment, RuntimePolicy, StreamEvent, ToolSchema } from "../types.js";
 import { CircuitBreaker } from "./base.js";
 import { type CanonicalAdapterInput } from "./content-normalization.js";
 import { OpenAIChatAdapter } from "./openai-chat.js";
@@ -35,6 +35,9 @@ export declare class OpenAIChatProvider implements LLMProvider {
     descriptor(): ProviderDescriptor;
     bindResolvedRuntime(resolved: ResolvedOpenAIChatRuntime): void;
     assessReplayability(context: RenderedContext, extensions?: Record<string, unknown>): ReplayabilityAssessment;
+    /** P4-S1: transport facts of the most recent execution. Host evidence only (B7). */
+    private lastTelemetry;
+    peekTransportTelemetry(): ProviderTransportTelemetry | undefined;
     peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
     seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
     private rememberReplay;

package/dist/providers/openai.js

@@ -75,6 +75,11 @@ export class OpenAIChatProvider {
         });
         return { ok: offendingCallIds.length === 0, offendingCallIds };
     }
+    /** P4-S1: transport facts of the most recent execution. Host evidence only (B7). */
+    lastTelemetry;
+    peekTransportTelemetry() {
+        return this.lastTelemetry;
+    }
     peekProviderReplay(message) {
         const replay = this.replayStore.get(assistantReplayKey(message));
         if (!replay || !("reasoning_content" in replay || "reasoning_details" in replay))
@@ -139,8 +144,12 @@ export class OpenAIChatProvider {
         let lastError;
         for (let attempt = 0; attempt < this.maxRetries; attempt++) {
             try {
+                this.lastTelemetry = { rungs: attempt + 1 };
                 const response = await this.client.chat.completions.create(plan.params);
                 this.circuit.recordSuccess();
+                const responseId = response.id;
+                if (typeof responseId === "string")
+                    this.lastTelemetry = { rungs: attempt + 1, responseId };
                 const decoded = this.chat.decodeComplete(response, { input }, this.dialect);
                 this.rememberReplay(decoded.message, decoded.replay);
                 return decoded.message;
@@ -166,7 +175,11 @@ export class OpenAIChatProvider {
                 stream: true,
                 stream_options: { include_usage: true },
             }, signal ? { signal } : undefined);
+            this.lastTelemetry = { rungs: 1 };
             for await (const chunk of stream) {
+                if (this.lastTelemetry.responseId === undefined && typeof chunk.id === "string") {
+                    this.lastTelemetry = { rungs: 1, responseId: chunk.id };
+                }
                 const output = this.chat.pushStreamChunk(chunk, state);
                 if (output.replay) {
                     this.rememberReplay({

package/dist/providers/request-plan.d.ts

@@ -1,4 +1,5 @@
 import type { RenderedContext, ToolSchema, ProviderUsage } from "../types.js";
+import type { GenerationProtocol } from "./protocol-capabilities.js";
 export interface ProviderRequestEndpoint {
     id: string;
     protocol: string;
@@ -79,6 +80,45 @@ export declare function createProviderRequestPlanForProvider(provider: {
         };
     };
 }, context: RenderedContext, tools: ToolSchema[], options?: Record<string, unknown>): ProviderRequestPlan;
+/**
+ * P4 §1.3: the resolved route one provider execution is pinned to. Content-addressed
+ * (`routeId` = stable hash of every field except `capabilitiesRef`); the capability table's
+ * authority stays the static vocabulary in protocol-capabilities.ts — this holds a reference,
+ * never a copy.
+ */
+export interface ResolvedProviderRoute {
+    routeId: string;
+    provider: string;
+    protocol: GenerationProtocol;
+    model: string;
+    endpoint: ProviderRequestEndpoint;
+    /** Adapter implementation version (the @deepstrike/sdk package version; F8). */
+    adapterVersion: string;
+    /** Capability snapshot reference: the protocol constant name (e.g. "anthropic-messages").
+     *  A provider exposing capability overrides would append a summary here — none does today. */
+    capabilitiesRef: string;
+}
+/**
+ * P4-S1: assemble the run's route once at runner construction (P4 §0.2 — the provider is
+ * fixed for the run today; a future failover resolver re-evaluates per attempt with the same
+ * shape). Never throws: evidence assembly degrades to "unknown" fields rather than breaking a run.
+ */
+export declare function resolveProviderRoute(provider: {
+    descriptor?(): {
+        provider: string;
+        protocol: string;
+        model: string;
+    };
+    requestPlanIdentity?(): {
+        providerId?: string;
+        modelId?: string;
+        endpoint?: {
+            id?: string;
+            protocol?: string;
+            baseURL?: string;
+        };
+    };
+}): ResolvedProviderRoute;
 export declare function estimateProviderPromptTokens(context: RenderedContext, tools: ToolSchema[]): number;
 /** Bind a preflight count to its exact provider-visible request. Replay only reuses matching facts. */
 export declare function recordPromptMeasurement(plan: Pick<ProviderRequestPlan, "fingerprint">, measurement: Omit<RecordedPromptMeasurement, "requestFingerprint">): RecordedPromptMeasurement;

package/dist/providers/request-plan.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
 const TRANSPORT_ONLY_KEYS = new Set([
     "apiKey", "api_key", "bearerToken", "bearer_token", "authorization", "credential",
     "credentials", "retry", "maxRetries", "baseDelay", "timeout", "signal", "access_token", "refresh_token", "token", "secret", "x-api-key",
@@ -44,6 +45,66 @@ export function createProviderRequestPlanForProvider(provider, context, tools, o
         options,
     });
 }
+const KNOWN_GENERATION_PROTOCOLS = new Set([
+    "anthropic-messages",
+    "openai-chat",
+    "openai-responses",
+    "gemini",
+    "ollama-chat",
+]);
+/**
+ * P4-S1: assemble the run's route once at runner construction (P4 §0.2 — the provider is
+ * fixed for the run today; a future failover resolver re-evaluates per attempt with the same
+ * shape). Never throws: evidence assembly degrades to "unknown" fields rather than breaking a run.
+ */
+export function resolveProviderRoute(provider) {
+    try {
+        const descriptor = provider.descriptor?.() ?? { provider: "unknown", protocol: "unknown", model: "unknown" };
+        const identity = provider.requestPlanIdentity?.();
+        const protocolRaw = identity?.endpoint?.protocol ?? descriptor.protocol;
+        // Evidence records what the descriptor said, even when a foreign provider speaks a protocol
+        // outside the in-tree vocabulary — the field is a report, not a gate.
+        const protocol = protocolRaw;
+        const route = {
+            provider: identity?.providerId ?? descriptor.provider,
+            protocol,
+            model: identity?.modelId ?? descriptor.model,
+            endpoint: sanitizeEndpoint({
+                id: identity?.endpoint?.id ?? `${descriptor.provider}.${descriptor.protocol}`,
+                protocol: protocolRaw,
+                baseURL: identity?.endpoint?.baseURL ?? "",
+            }),
+            adapterVersion: adapterPackageVersion(),
+            capabilitiesRef: KNOWN_GENERATION_PROTOCOLS.has(protocol) ? protocol : "unknown",
+        };
+        // §1.3: content addressing covers every field EXCEPT capabilitiesRef (a reference, not content).
+        const { capabilitiesRef: _ref, ...addressed } = route;
+        return { ...route, routeId: sha256(stableJson(addressed)) };
+    }
+    catch {
+        const fallback = {
+            provider: "unknown",
+            protocol: "unknown",
+            model: "unknown",
+            endpoint: { id: "unknown", protocol: "unknown", baseURL: "" },
+            adapterVersion: "unknown",
+        };
+        return { ...fallback, capabilitiesRef: "unknown", routeId: sha256(stableJson(fallback)) };
+    }
+}
+/** The adapter's package version, read from package.json at runtime. "unknown" when unreadable —
+ *  route assembly is evidence plumbing and must never throw (B7: evidence, not kernel input). */
+function adapterPackageVersion() {
+    try {
+        // From both src/providers/ (ts) and dist/providers/ (js), ../../package.json is the SDK manifest.
+        const require = createRequire(import.meta.url);
+        const manifest = require("../../package.json");
+        return typeof manifest.version === "string" && manifest.version.length > 0 ? manifest.version : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
 export function estimateProviderPromptTokens(context, tools) {
     const bytes = new TextEncoder().encode(stableJson({ context, tools })).byteLength;
     return Math.max(1, Math.ceil(bytes / 4));