@deepstrike/sdk 0.2.52 → 0.2.61

package/dist/runtime/provider-replay.js

@@ -1,3 +1,11 @@
+export class ProviderReplayProtocolMismatchError extends Error {
+    code = "provider_replay_protocol_mismatch";
+    constructor(provider, storedProtocol, resolvedProtocol) {
+        super(`Stored ${storedProtocol} tool replay is incompatible with resolved ${provider}/${resolvedProtocol}; `
+            + `pin the previous ${storedProtocol} endpoint explicitly to resume this session`);
+        this.name = "ProviderReplayProtocolMismatchError";
+    }
+}
 function sortObjectKeys(val) {
     if (val === null || typeof val !== "object") {
         return val;
@@ -33,22 +41,6 @@ export function assistantReplayKey(message) {
         toolCalls,
     });
 }
-/**
- * Infer the wire protocol a stored replay envelope belongs to.
- *
- * New envelopes carry an explicit `protocol`. Legacy envelopes are inferred
- * from their shape: Anthropic persisted `native_blocks`, OpenAI-compatible
- * persisted `reasoning_content` / `reasoning_details`.
- */
-function replayProtocol(replay) {
-    if (replay.protocol)
-        return replay.protocol;
-    if (replay.native_blocks?.length)
-        return "anthropic-messages";
-    if (replay.reasoning_content != null || replay.reasoning_details !== undefined)
-        return "openai-chat";
-    return undefined;
-}
 /**
  * A stored replay may only be seeded into a provider speaking the same wire
  * protocol. On a cross-protocol fallback (provider A -> provider B) the
@@ -56,12 +48,16 @@ function replayProtocol(replay) {
  * of replaying A's protocol-specific shape.
  */
 export function isReplayCompatibleWithProvider(replay, descriptor) {
-    if (!descriptor)
-        return true;
-    const protocol = replayProtocol(replay);
-    if (!protocol)
-        return true;
-    return protocol === descriptor.protocol;
+    assertCanonicalReplay(replay);
+    return !descriptor || replay.protocol === descriptor.protocol;
+}
+const REPLAY_KEYS = new Set(["protocol", "provider", "model", "native_blocks", "reasoning_content", "reasoning_details", "native_message", "tool_calls"]);
+function assertCanonicalReplay(replay) {
+    for (const key of Object.keys(replay))
+        if (!REPLAY_KEYS.has(key))
+            throw new Error(`provider replay has unknown field ${key}`);
+    if (typeof replay.protocol !== "string" || replay.protocol.length === 0)
+        throw new Error("provider replay protocol is required");
 }
 export function seedProviderReplayFromEvents(provider, events) {
     if (!provider.seedProviderReplay)
@@ -72,12 +68,15 @@ export function seedProviderReplayFromEvents(provider, events) {
             continue;
         const toolCalls = event.tool_calls ?? [];
         const stored = event.provider_replay;
-        if (stored && !isReplayCompatibleWithProvider(stored, descriptor))
+        if (!stored)
             continue;
-        // Pass the message even when no replay was persisted: a provider may
-        // reconstruct a legacy replay (e.g. Anthropic native_blocks) from the
-        // neutral transcript. Providers that cannot reconstruct simply no-op.
-        provider.seedProviderReplay({ content: event.content, toolCalls }, stored ?? {});
+        if (!isReplayCompatibleWithProvider(stored, descriptor)) {
+            if (toolCalls.length > 0 && descriptor) {
+                throw new ProviderReplayProtocolMismatchError(descriptor.provider, stored.protocol, descriptor.protocol);
+            }
+            continue;
+        }
+        provider.seedProviderReplay({ content: event.content, toolCalls }, stored);
     }
 }
 export function peekProviderReplay(provider, content, toolCalls) {

package/dist/runtime/reactive-session.d.ts

@@ -121,7 +121,7 @@ export declare class ReactiveSession {
      * blackboard continuity comes from the (persistent) `EventStream`. Turn-policy cursor state is not
      * restored. W-N5: vehicle members (workflow envelopes, `wf-node*` children, loop iterations) share
      * the governance domain but are NOT personas — resuming them as peers would resurrect phantoms.
-     * A legacy membership with no kind tags falls back to resuming every member.
+     * Only explicitly tagged peer memberships are resumable.
      */
     static resume(opts: ReactiveSessionOptions & {
         peerSpecs?: Record<string, ReactivePeerSpec>;

package/dist/runtime/reactive-session.js

@@ -135,14 +135,13 @@ export class ReactiveSession {
      * blackboard continuity comes from the (persistent) `EventStream`. Turn-policy cursor state is not
      * restored. W-N5: vehicle members (workflow envelopes, `wf-node*` children, loop iterations) share
      * the governance domain but are NOT personas — resuming them as peers would resurrect phantoms.
-     * A legacy membership with no kind tags falls back to resuming every member.
+     * Only explicitly tagged peer memberships are resumable.
      */
     static async resume(opts) {
         const session = new ReactiveSession(opts);
         const members = await opts.runGroup.budgetStore.members(opts.runGroup.id);
-        const anyTagged = members.some(m => m.kind !== undefined);
         for (const member of members) {
-            if (anyTagged && member.kind !== "peer")
+            if (member.kind !== "peer")
                 continue;
             session.peerSpecs.set(member.sessionId, opts.peerSpecs?.[member.sessionId] ?? { role: member.role });
         }

package/dist/runtime/run-group.d.ts

@@ -34,7 +34,7 @@ export interface GroupMember {
     /** W-N5: what this member IS in the lineage — a `"peer"` persona (ReactiveSession.addPeer) vs a
      *  `"vehicle"` session (run()/runWorkflow envelopes, workflow-node children, loop iterations).
      *  `ReactiveSession.resume()` rebuilds the peer set from `"peer"` members only, so DAG-in-Peer
-     *  usage can't resurrect phantom `wf-node*` personas. Absent (legacy) = unknown. */
+     *  usage can't resurrect phantom `wf-node*` personas. Absent means unknown. */
     kind?: "peer" | "vehicle";
 }
 export interface GroupBudgetStore {

package/dist/runtime/runner.d.ts

@@ -1,5 +1,5 @@
-import type { LLMProvider, Message, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, DreamSummarizer, EntropySample, EntropyWatchOptions } from "../types.js";
-import type { DreamStore, MemoryRecord, MemoryRecall, MemoryScope, MemoryQuery } from "../memory/protocols.js";
+import type { LLMProvider, Message, ContentPart, ToolSchema, StreamEvent, ToolSuspendEvent, PermissionRequestEvent, PermissionResponse, AsyncSummarizer, MemorySummarizer, EntropySample, EntropyWatchOptions } from "../types.js";
+import type { MemoryStore, MemoryRecord, MemoryRecall, MemoryScope, MemoryQuery } from "../memory/protocols.js";
 import type { KnowledgeSource } from "../knowledge/source.js";
 import type { RuntimeSignalUrgency, SignalSource } from "../signals/types.js";
 import type { SessionLog, SessionEvent } from "./session-log.js";
@@ -15,15 +15,18 @@ import { type GovernancePolicy } from "../governance.js";
 import { type NativeOsProfile, type OsProfileId, type SignalPolicy } from "./os-profile.js";
 import { PayloadStore } from "./payload-store.js";
 import type { BackgroundTaskErrorHandler } from "./reliability.js";
-import { type ContextPolicyOverridesV1 } from "./context-policy.js";
+import { type ContextPolicyOverrides } from "./context-policy.js";
 import { type InstructionProfile } from "../harness/manifest.js";
 import { type NudgeRule } from "../harness/nudge.js";
 export interface SchedulerPolicy {
-    version: 1;
     criticalPathWeight: number;
     fanoutWeight: number;
     ageWeight: number;
     tokenCostWeight: number;
+    deadlineWeight?: number;
+    processPriorityWeight?: number;
+    resourcePressureWeight?: number;
+    budgetPressureWeight?: number;
 }
 export declare function schedulerPolicyToKernel(policy: SchedulerPolicy): Record<string, number>;
 /** Host-counted provider envelope and response reserves deducted from the model context window. */
@@ -53,11 +56,7 @@ export interface TurnMetrics {
     inputTokens: number;
     /** Tokens served from the prompt cache this turn (Anthropic `cache_read_input_tokens`). */
     cacheReadTokens: number;
-    /** I1: per-slot attribution of `cacheReadTokens`. Anthropic reports a single cache-read total,
-     *  not a per-block breakdown — this field is a pro-rata estimate over the slots that actually
-     *  carried a `cache_control` breakpoint on the request. Missing / empty when the provider does
-     *  not honor `cache_control` (OpenAI-family auto-cache) or when no breakpoints were placed.
-     *  Useful for diagnosing which slot is buying the cache hit when comparing strategies. */
+    /** Provider-authoritative per-slot attribution, when the endpoint reports one. */
     cacheReadTokensBySlot?: {
         system?: number;
         tools?: number;
@@ -65,6 +64,10 @@ export interface TurnMetrics {
     };
     /** Tokens written to the prompt cache this turn (Anthropic `cache_creation_input_tokens`). */
     cacheCreationTokens: number;
+    cacheTelemetryStatus?: "measured" | "unavailable";
+    cacheTelemetrySource?: "anthropic_usage" | "openai_prompt_details" | "deepseek_prompt_cache" | "gemini_usage";
+    requestFingerprint?: string;
+    stablePrefixFingerprint?: string;
 }
 /** O5: decision returned by `onToolCall` — `block: true` denies this call before it executes; the
  *  `reason` is fed back to the model as a governance-denied tool result (so it can redirect). */
@@ -117,10 +120,10 @@ export interface RuntimeOptions {
     memoryScope?: MemoryScope;
     /** I4: optional run-start memory pre-fetch hook. The runner calls this ONCE per run, before the
      *  first LLM turn, with the request's goal and (optional) run-spec. Each returned scoped query
-     *  becomes a `dreamStore.search(agentId, query)` and the resulting hits land in decaying
+     *  becomes a `memoryStore.search(agentId, query)` and the resulting hits land in decaying
      *  HISTORY as an ordinary user turn before turn 1 (single-use retrieval content — never a
      *  permanent knowledge pin; `initialMemory` is the curated CLAUDE.md-analog seed). Returning
-     *  `undefined` / empty array is a no-op. Requires `dreamStore` + `agentId`; missing either ⇒
+     *  `undefined` / empty array is a no-op. Requires `memoryStore` + `agentId`; missing either ⇒
      *  silently skipped (errs-open). Default when unset: one query = the run goal (P10). Bench memory-recall shows -57% turns / -55% dollars when
      *  relevant memories land on turn 1 instead of being discovered via the meta-tool on turn 3+. */
     preQueryMemory?: (ctx: {
@@ -150,7 +153,7 @@ export interface RuntimeOptions {
      *  scanned skills fed); empty array ⇒ no skills (a legitimate narrowing — unlike an empty
      *  `allowedToolIds`, which the runner reads as "no gating"). Only takes effect when `skillDir` is set. */
     skillFilter?: string[];
-    dreamStore?: DreamStore;
+    memoryStore?: MemoryStore;
     /** M4: advisory callback when a recalled record crosses the promotion threshold. The host/model
      *  decides whether to pin the record or promote its content into knowledge. */
     onPromotionSuggested?: (info: {
@@ -168,13 +171,13 @@ export interface RuntimeOptions {
      * AskUser calls surface as `tool_gated` and run through `onPermissionRequest`.
      */
     governancePolicy?: GovernancePolicy;
-    /** Version-1 in-kernel signal admission, queue, and expiry policy. */
+    /** In-kernel signal admission, queue, and expiry policy. */
     signalPolicy?: SignalPolicy;
     /** Provider-envelope overhead plus output and safety reserves journaled before start. */
     promptBudget?: PromptBudget;
     /** Stable replayable context behavior; SDK ratios are normalized to integer ppm on the ABI wire. */
-    contextPolicy?: ContextPolicyOverridesV1;
-    /** Versioned deterministic DAG scheduling policy installed atomically through ConfigureRun. */
+    contextPolicy?: ContextPolicyOverrides;
+    /** Deterministic DAG scheduling policy installed atomically through ConfigureRun. */
     schedulerPolicy?: SchedulerPolicy;
     /**
      * Optional declarative resource quotas (`set_resource_quota`). Bounds spawn concurrency /
@@ -231,15 +234,13 @@ export interface RuntimeOptions {
      * executes. Return `{ block: true, reason }` to veto — the call never runs and the reason is fed
      * back to the model as a denied tool result. This is the seam for STATEFUL host policy (count
      * repeats, budget writes per resource, project-specific rules); keep static allow/deny in
-     * `governancePolicy`. A throwing decision hook fails closed by default.
+     * `governancePolicy`. A throwing decision hook always fails closed.
      */
     onToolCall?: (call: {
         callId: string;
         name: string;
         arguments: string;
     }) => Promise<ToolCallHookDecision | undefined | void> | ToolCallHookDecision | undefined | void;
-    /** Failure policy for `onToolCall`. Default `closed`; set `open` only for advisory hooks. */
-    onToolCallFailure?: "closed" | "open";
     /**
      * O5 (the PostToolUse-hook analog): called for each executed tool result before it reaches the
      * kernel. Return `{ replaceOutput }` to swap the result the model sees (redact / annotate), and/or
@@ -271,7 +272,7 @@ export interface RuntimeOptions {
      */
     nestedGroupVehicle?: boolean;
     /**
-     * Optional canonical long-term memory policy. Enabling memory still requires `dreamStore` +
+     * Optional canonical long-term memory policy. Enabling memory still requires `memoryStore` +
      * `agentId`; storage location is configured on that host store, not in the kernel contract.
      */
     memoryPolicy?: MemoryPolicy;
@@ -310,8 +311,7 @@ export interface RuntimeOptions {
      * synthesizes a minimal run spec. Omitted **or empty** ⇒ no ceiling (all registered tools) — the
      * empty array is NOT a minimal surface here; use `baselineToolIds: []` for that.
      *
-     * Enforcement: `toolDispatchGate` (default `"exposed"`) makes this a real boundary — a call to a
-     * tool outside the advertised set never executes.
+     * Dispatch is always fail-closed: a call outside the advertised set never executes.
      */
     allowedToolIds?: string[];
     /**
@@ -322,27 +322,13 @@ export interface RuntimeOptions {
      *
      *   `exposed = meta ∪ ((baseline ∪ stableCore ∪ ⋃ activeSkills.allowed_tools) ∩ ceiling)`
      *
-     * An active skill that declares no `allowed_tools` contributes nothing — with a baseline set the
-     * surface stays narrow (strict; the legacy errs-open widening is deliberately not inherited).
+     * An active skill that declares no `allowed_tools` contributes nothing and the surface stays narrow.
      *
-     * `undefined` ⇒ legacy behavior, byte-identical (ceiling + errs-open skill narrowing). `[]` is a
-     * legitimate, distinct value: the minimal surface (meta-tools + `stableCoreToolIds` only) — the
+     * `undefined` and `[]` both mean the minimal surface (meta-tools + `stableCoreToolIds` only) — the
      * `allowedToolIds` "empty means no gating" trap does NOT recur here. Entries outside the ceiling
      * silently intersect away (no root-start error), the same fold every id-list surface uses.
      */
     baselineToolIds?: string[];
-    /**
-     * Dispatch enforcement for the exposure surface. `"exposed"` (default) is fail-closed: a tool call
-     * the model was never advertised this turn never reaches the host — the kernel commits a
-     * model-visible `governance_denied` result instead ("Tool 'X' is not part of this run's toolset"),
-     * which feeds the repeat fuse like any other denial. Allowed siblings in the same batch still
-     * execute; `pace` and the meta-tool family always pass through.
-     *
-     * `"registered"` is the escape hatch restoring the pre-gate permissive behavior (any registered
-     * tool the model names executes, even if it was gated out of the tools schema). Set it only when a
-     * host deliberately relies on blind calls to unadvertised tools.
-     */
-    toolDispatchGate?: "exposed" | "registered";
     /** P0-C: optional per-turn metrics sink for tool-gating telemetry (see `TurnMetrics`). Pure
      *  observation; invoked once per LLM turn. Never throws into the run loop (errors are swallowed). */
     onTurnMetrics?: (metrics: TurnMetrics) => void;
@@ -366,15 +352,15 @@ export interface RuntimeOptions {
     /** G2: custom reducers for `NodeKind::Reduce` workflow nodes, merged over the built-ins
      *  (`concat` / `dedupe_lines` / `merge_json_arrays` / `count`). A reduce node runs no LLM. */
     reducers?: ReducerRegistry;
-    /** Optional system prompt injected into the dream synthesis call. */
-    dreamSystemPrompt?: string;
-    /** Custom LLM provider used for background memory consolidation (dream loop). */
-    dreamProvider?: LLMProvider;
+    /** Optional system prompt injected into durable-memory synthesis. */
+    memorySystemPrompt?: string;
+    /** Custom LLM provider used for durable-memory consolidation. */
+    memoryProvider?: LLMProvider;
     /**
-     * Optional LLM summarizer for semantic page_out events. When unset, `dreamProvider`
-     * (or the runtime provider) is used to produce long-term summaries for DreamStore.
+     * Optional LLM summarizer for semantic page_out events. When unset, `memoryProvider`
+     * (or the runtime provider) is used to produce long-term summaries for MemoryStore.
      */
-    dreamSummarizer?: DreamSummarizer;
+    memorySummarizer?: MemorySummarizer;
     /**
      * Optional async LLM summarizer. When provided, a background call is fired
      * after each compression event to produce a richer semantic summary.
@@ -429,7 +415,7 @@ export declare class RuntimeRunner {
     private retrieveMemoryFromStore;
     /**
      * Route a host-originated renewal prefetch into canonical knowledge commands. This is not an
-     * agent syscall: the host selects records from its store, then the kernel owns the only mutation
+     * agent syscall: the host selects records from its store, then the kernel owns the write
      * of live semantic context. `seenRecordIds` is the prefetch's dedupe horizon.
      */
     private prefetchMemoryIntoKnowledge;