@deepstrike/sdk 0.2.52 → 0.2.60

package/dist/memory/durable.js

@@ -0,0 +1,46 @@
+/**
+ * Binds the host storage protocol to the public Memory contract for one agent and namespace.
+ * This is deliberately an SDK adapter: it does not lower memory mutations into the Kernel.
+ */
+export class DurableMemory {
+    store;
+    agentId;
+    scope;
+    namespace;
+    constructor(store, agentId, scope) {
+        this.store = store;
+        this.agentId = agentId;
+        this.scope = scope;
+        this.namespace = scope.namespace;
+    }
+    async search(query, options = {}) {
+        const request = {
+            scope: this.scope,
+            query,
+            top_k: options.topK ?? 5,
+            kinds: options.kinds ?? [],
+            ...(options.minScore === undefined ? {} : { min_score: options.minScore }),
+        };
+        return (await this.store.search(this.agentId, request))
+            .map(hit => hit.record)
+            .filter(record => sameScope(record.scope, this.scope));
+    }
+    async get(id) {
+        const record = await this.store.get(this.agentId, id);
+        return record !== null && sameScope(record.scope, this.scope) ? record : null;
+    }
+    async put(record) {
+        if (!sameScope(record.scope, this.scope)) {
+            throw new Error("memory record scope must match the bound Memory scope");
+        }
+        await this.store.put(this.agentId, record);
+    }
+    async delete(id) {
+        const record = await this.get(id);
+        if (record !== null)
+            await this.store.delete(this.agentId, id);
+    }
+}
+function sameScope(left, right) {
+    return left.tenant_id === right.tenant_id && left.namespace === right.namespace;
+}

package/dist/memory/in-memory-store.d.ts

@@ -1,7 +1,7 @@
 /**
- * `InMemoryDreamStore` — a lightweight `DreamStore` implementation backed by per-agent `Map`s.
+ * `InMemoryMemoryStore` — a lightweight `MemoryStore` implementation backed by per-agent `Map`s.
  *
- * Originally lived as `MockDreamStore` in the SDK's test helpers; promoted here so benchmarks,
+ * Originally lived as `MockMemoryStore` in the SDK's test helpers; promoted here so benchmarks,
  * examples, and downstream consumers can use it without copying the boilerplate.
  *
  * Use cases:
@@ -14,8 +14,8 @@
  * the full record set, so it (M3) bounds itself by value-ordered retention eviction and (M3/M4)
  * mirrors recall lifecycle and pin state. For semantic search, plug in a real store.
  */
-import type { DreamStore, MemoryQuery, MemoryRecall, MemoryRecallLifecycle, MemoryRecord, SessionData } from "./protocols.js";
-export interface InMemoryDreamStoreOptions {
+import type { MemoryStore, MemoryQuery, MemoryRecall, MemoryRecallLifecycle, MemoryRecord, SessionData } from "./protocols.js";
+export interface InMemoryMemoryStoreOptions {
     /** Cap the per-agent record set; a write past it evicts the lowest-value unpinned records (M3). */
     maxRecords?: number;
     /** Age (days) past which a record's recall relevance is discounted. Default 2. */
@@ -23,7 +23,7 @@ export interface InMemoryDreamStoreOptions {
     /** Wall-clock source for staleness scoring + recall stamps. Injectable for deterministic tests. */
     now?: () => number;
 }
-export declare class InMemoryDreamStore implements DreamStore {
+export declare class InMemoryMemoryStore implements MemoryStore {
     private readonly initialMemories;
     private memories;
     /** Sessions persisted via `saveSession`; exposed for test assertions. */
@@ -35,9 +35,11 @@ export declare class InMemoryDreamStore implements DreamStore {
      * @param initialMemories Optional seed memories applied to every agent that asks for memories
      *                        for the first time. Useful for benchmark scenarios that preload a fact.
      */
-    constructor(initialMemories?: MemoryRecord[], options?: InMemoryDreamStoreOptions);
+    constructor(initialMemories?: MemoryRecord[], options?: InMemoryMemoryStoreOptions);
     private recordsFor;
-    upsert(agentId: string, incoming: MemoryRecord): Promise<void>;
+    put(agentId: string, incoming: MemoryRecord): Promise<void>;
+    get(agentId: string, recordId: string): Promise<MemoryRecord | null>;
+    delete(agentId: string, recordId: string): Promise<void>;
     /** M3: value-ordered retention eviction. Sheds the lowest-value unpinned records — the shared
      *  deterministic formula, never a blind tail-cut — until the set fits `maxRecords`. */
     private evictToCapacity;

package/dist/memory/in-memory-store.js

@@ -1,6 +1,6 @@
 import { rankMemories } from "./ranking.js";
 import { memoryRetentionScore } from "./retention.js";
-export class InMemoryDreamStore {
+export class InMemoryMemoryStore {
     initialMemories;
     memories = new Map();
     /** Sessions persisted via `saveSession`; exposed for test assertions. */
@@ -27,7 +27,7 @@ export class InMemoryDreamStore {
         }
         return [];
     }
-    async upsert(agentId, incoming) {
+    async put(agentId, incoming) {
         const kept = [...this.recordsFor(agentId)];
         const index = kept.findIndex(record => record.scope.tenant_id === incoming.scope.tenant_id
             && record.scope.namespace === incoming.scope.namespace
@@ -39,6 +39,12 @@ export class InMemoryDreamStore {
             kept.push(incoming);
         this.memories.set(agentId, this.evictToCapacity(kept));
     }
+    async get(agentId, recordId) {
+        return this.recordsFor(agentId).find(record => record.record_id === recordId) ?? null;
+    }
+    async delete(agentId, recordId) {
+        this.memories.set(agentId, this.recordsFor(agentId).filter(record => record.record_id !== recordId));
+    }
     /** M3: value-ordered retention eviction. Sheds the lowest-value unpinned records — the shared
      *  deterministic formula, never a blind tail-cut — until the set fits `maxRecords`. */
     evictToCapacity(records) {

package/dist/memory/protocols.d.ts

@@ -60,10 +60,28 @@ export interface MemoryRecallLifecycle {
     recall_count: number;
     last_recalled_at: number;
 }
-export interface DreamStore {
-    /** The only durable memory mutation. Callers must reach this through the kernel WriteMemory gate. */
-    upsert(agentId: string, record: MemoryRecord): Promise<void>;
-    /** Semantic search over the agent's long-term memories. Called on demand during a run. */
+/** Search options for the public, agent-bound durable `Memory` descriptor. */
+export interface MemorySearchOptions {
+    topK?: number;
+    kinds?: MemoryKind[];
+    minScore?: number;
+}
+/**
+ * Public durable memory descriptor bound to one agent and scope. It intentionally returns records,
+ * not ranking internals, and is distinct from `WorkingMemory`, the SDK-only scratch pad.
+ */
+export interface Memory {
+    readonly namespace?: string;
+    search(query: string, options?: MemorySearchOptions): Promise<MemoryRecord[]>;
+    get(id: string): Promise<MemoryRecord | null>;
+    put(record: MemoryRecord): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+/** Host-owned durable storage behind an agent-bound public `Memory` descriptor. */
+export interface MemoryStore {
+    put(agentId: string, record: MemoryRecord): Promise<void>;
+    get(agentId: string, recordId: string): Promise<MemoryRecord | null>;
+    delete(agentId: string, recordId: string): Promise<void>;
     search(agentId: string, query: MemoryQuery): Promise<MemoryRecall[]>;
     /** Persist the completed session before the runner performs its one extraction pass. */
     saveSession(data: SessionData): Promise<void>;

package/dist/memory/public.d.ts

@@ -1,9 +1,10 @@
 export { WorkingMemory } from "./working.js";
-export { InMemoryDreamStore } from "./in-memory-store.js";
-export type { InMemoryDreamStoreOptions } from "./in-memory-store.js";
+export { DurableMemory } from "./durable.js";
+export { InMemoryMemoryStore } from "./in-memory-store.js";
+export type { InMemoryMemoryStoreOptions } from "./in-memory-store.js";
 export { memoryRetentionScore } from "./retention.js";
 export { rankMemories } from "./ranking.js";
 export type { RankableMemory, RankedMemory, RankOptions } from "./ranking.js";
 export { extractSessionMemories, parseExtractedMemories } from "./extraction.js";
-export type { DreamStore, SessionData, SessionMessage, MemoryRecord, MemoryRecall, MemoryQuery, MemoryScope, MemoryProvenance, MemoryRecallLifecycle, MemoryKind, MemoryAuthor, MemoryTrustLevel, } from "./protocols.js";
+export type { MemoryStore, Memory, MemorySearchOptions, SessionData, SessionMessage, MemoryRecord, MemoryRecall, MemoryQuery, MemoryScope, MemoryProvenance, MemoryRecallLifecycle, MemoryKind, MemoryAuthor, MemoryTrustLevel, } from "./protocols.js";
 export type { KnowledgeSource } from "../knowledge/source.js";

package/dist/memory/public.js

@@ -1,6 +1,7 @@
-// `@deepstrike/sdk/memory` — long-term (dream) and working memory, plus the knowledge-source interface.
+// `@deepstrike/sdk/memory` — durable and working memory, plus the knowledge-source interface.
 export { WorkingMemory } from "./working.js";
-export { InMemoryDreamStore } from "./in-memory-store.js";
+export { DurableMemory } from "./durable.js";
+export { InMemoryMemoryStore } from "./in-memory-store.js";
 export { memoryRetentionScore } from "./retention.js";
 export { rankMemories } from "./ranking.js";
 export { extractSessionMemories, parseExtractedMemories } from "./extraction.js";

package/dist/providers/anthropic-adapter.d.ts

@@ -0,0 +1,47 @@
+import type { Message, ProviderReplay, ProviderUsage, ToolCall } from "../types.js";
+import type { CanonicalAdapterInput } from "./content-normalization.js";
+import { type AdapterDecodeInput, type AdapterOutput, type AdapterStreamInput, type CanonicalStopReason, type ProtocolAdapter } from "./protocol-adapter.js";
+export interface AnthropicRequestPlan {
+    transport: "stable" | "beta";
+    params: Record<string, unknown>;
+    cacheSlots: {
+        system: boolean;
+        tools: boolean;
+        messages: boolean;
+    };
+}
+export type AnthropicStreamChunk = Record<string, any>;
+export interface AnthropicStreamState {
+    readonly input: CanonicalAdapterInput;
+    readonly cacheSlots: {
+        system: boolean;
+        tools: boolean;
+        messages: boolean;
+    };
+    readonly toolBlocks: Record<number, {
+        id: string;
+        name: string;
+        argsBuffer: string;
+    }>;
+    readonly nativeBlocks: Record<number, Record<string, unknown>>;
+    readonly finalToolCalls: ToolCall[];
+    finalText: string;
+    uncachedInput: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    outputTokens: number;
+}
+export declare class AnthropicMessagesAdapter implements ProtocolAdapter<AnthropicRequestPlan, Record<string, any>, AnthropicStreamChunk, AnthropicStreamState, undefined> {
+    readonly protocol: "anthropic-messages";
+    readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
+    buildRequest(input: CanonicalAdapterInput): AnthropicRequestPlan;
+    decodeComplete(raw: Record<string, any>, _input: AdapterDecodeInput): {
+        message: Message;
+        replay?: ProviderReplay;
+    };
+    createStreamState(input: AdapterStreamInput): AnthropicStreamState;
+    pushStreamChunk(chunk: AnthropicStreamChunk, state: AnthropicStreamState): AdapterOutput;
+    finishStream(state: AnthropicStreamState): AdapterOutput;
+    normalizeUsage(raw: unknown): ProviderUsage | undefined;
+    normalizeStopReason(raw: string | undefined): CanonicalStopReason | undefined;
+}

package/dist/providers/anthropic-adapter.js

@@ -0,0 +1,444 @@
+import { normalizeToolCall } from "./base.js";
+import { ProtocolResponseError, } from "./protocol-adapter.js";
+import { ANTHROPIC_PROTOCOL_CAPABILITIES } from "./protocol-capabilities.js";
+const CACHE_BREAKPOINT_STRATEGIES = new Set([
+    "default", "tools-only", "system-only", "frozen-prefix", "none",
+]);
+function cacheStrategy(extensions) {
+    const raw = extensions.cacheBreakpointStrategy;
+    return typeof raw === "string" && CACHE_BREAKPOINT_STRATEGIES.has(raw)
+        ? raw
+        : "default";
+}
+function extensionsForWire(extensions) {
+    const blocked = new Set([
+        "model", "messages", "system", "tools", "max_tokens", "stream",
+        "__deepstrikeThinkingEnabled", "degradeMissingReasoningReplay",
+    ]);
+    return Object.fromEntries(Object.entries(extensions).filter(([key]) => !blocked.has(key)));
+}
+function systemBlocks(context, strategy) {
+    if (!context.systemStable && !context.systemKnowledge) {
+        return context.systemText || undefined;
+    }
+    const cache = strategy === "default" || strategy === "system-only";
+    const blocks = [];
+    if (context.systemStable) {
+        blocks.push({
+            type: "text",
+            text: context.systemStable,
+            ...(cache ? { cache_control: { type: "ephemeral" } } : {}),
+        });
+    }
+    if (context.systemKnowledge) {
+        blocks.push({
+            type: "text",
+            text: context.systemKnowledge,
+            ...(cache ? { cache_control: { type: "ephemeral" } } : {}),
+        });
+    }
+    return blocks.length ? blocks : undefined;
+}
+function toolResult(result) {
+    const blocks = result.blocks;
+    const native = blocks.map(block => {
+        if (block.type === "text")
+            return { type: "text", text: block.text };
+        if (block.type === "image") {
+            if (block.source.kind === "base64") {
+                return {
+                    type: "image",
+                    source: {
+                        type: "base64",
+                        media_type: block.mediaType ?? "image/png",
+                        data: block.source.data,
+                    },
+                };
+            }
+            if (block.source.kind === "url") {
+                return { type: "image", source: { type: "url", url: block.source.url } };
+            }
+        }
+        return { type: "text", text: `[${block.type}]` };
+    });
+    return {
+        type: "tool_result",
+        tool_use_id: result.callId,
+        content: result.contentForm !== "blocks" && blocks.length === 1 && blocks[0].type === "text"
+            ? blocks[0].text
+            : native,
+        is_error: result.isError,
+    };
+}
+function canonicalMessage(message) {
+    if (message.role === "assistant"
+        && message.toolCalls?.length
+        && message.providerReplay?.native_blocks?.length) {
+        return { role: "assistant", content: ensureAssistantToolText(message.providerReplay.native_blocks) };
+    }
+    const content = [];
+    for (const item of message.blocks) {
+        if (item.type === "tool_result") {
+            content.push(toolResult(item));
+        }
+        else if (item.type === "text") {
+            if (item.text)
+                content.push({ type: "text", text: item.text });
+        }
+        else if (item.type === "image") {
+            if (item.source.kind === "base64") {
+                content.push({
+                    type: "image",
+                    source: {
+                        type: "base64",
+                        media_type: item.mediaType ?? "image/png",
+                        data: item.source.data,
+                    },
+                });
+            }
+            else if (item.source.kind === "url") {
+                content.push({ type: "image", source: { type: "url", url: item.source.url } });
+            }
+        }
+    }
+    if (message.role === "assistant" && message.toolCalls?.length) {
+        if (!content.length)
+            content.push({ type: "text", text: "Tool call requested." });
+        for (const call of message.toolCalls) {
+            let args = {};
+            try {
+                args = JSON.parse(call.arguments);
+            }
+            catch {
+                args = {};
+            }
+            content.push({ type: "tool_use", id: call.id, name: call.name, input: args });
+        }
+    }
+    if (message.role === "tool" && !content.some(block => block.type === "tool_result")) {
+        return undefined;
+    }
+    return {
+        role: message.role === "tool" ? "user" : message.role,
+        content: message.contentForm !== "blocks" && content.length === 1 && content[0].type === "text"
+            ? content[0].text
+            : content,
+    };
+}
+function ensureAssistantToolText(blocks) {
+    if (!blocks.some(block => block.type === "tool_use"))
+        return blocks;
+    if (blocks.some(block => block.type === "text" && String(block.text ?? "").trim()))
+        return blocks;
+    if (blocks.some(block => block.type === "thinking"))
+        return blocks;
+    return [{ type: "text", text: "Tool call requested." }, ...blocks];
+}
+function markLastBlockCacheable(message) {
+    const cache_control = { type: "ephemeral" };
+    if (typeof message.content === "string") {
+        if (message.content) {
+            message.content = [{ type: "text", text: message.content, cache_control }];
+        }
+        return;
+    }
+    if (Array.isArray(message.content) && message.content.length) {
+        const last = message.content.at(-1);
+        last.cache_control = cache_control;
+    }
+}
+function applyMessageCacheControl(messages, frozenPrefixLen, strategy) {
+    if (!messages.length || ["tools-only", "system-only", "none"].includes(strategy))
+        return;
+    const targets = new Set([messages.length - 1]);
+    if (typeof frozenPrefixLen === "number" && frozenPrefixLen >= 1 && frozenPrefixLen < messages.length) {
+        targets.add(frozenPrefixLen - 1);
+    }
+    else if (strategy === "default") {
+        for (let index = messages.length - 2; index >= 0 && targets.size < 2; index--) {
+            if (messages[index].role === "user")
+                targets.add(index);
+        }
+    }
+    for (const index of targets)
+        markLastBlockCacheable(messages[index]);
+}
+function requestTools(input, system, strategy) {
+    if (!input.tools.length)
+        return undefined;
+    const anchor = !Array.isArray(system)
+        && (strategy === "default" || strategy === "tools-only");
+    return input.tools.map((tool, index) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: JSON.parse(tool.parameters),
+        ...(anchor && index === input.tools.length - 1
+            ? { cache_control: { type: "ephemeral" } }
+            : {}),
+    }));
+}
+function countSlots(system, tools, messages) {
+    return {
+        system: Array.isArray(system) && system.some(block => block.cache_control),
+        tools: !!tools?.some(tool => tool.cache_control),
+        messages: messages.some(message => Array.isArray(message.content)
+            && message.content.some(block => block.cache_control)),
+    };
+}
+function countCacheBreakpoints(value) {
+    if (Array.isArray(value))
+        return value.reduce((total, item) => total + countCacheBreakpoints(item), 0);
+    if (!value || typeof value !== "object")
+        return 0;
+    const record = value;
+    return (record.cache_control ? 1 : 0)
+        + Object.entries(record)
+            .filter(([key]) => key !== "cache_control")
+            .reduce((total, [, item]) => total + countCacheBreakpoints(item), 0);
+}
+function assertCacheBudget(params) {
+    const count = countCacheBreakpoints({
+        system: params.system,
+        tools: params.tools,
+        messages: params.messages,
+    });
+    if (count > 4) {
+        throw new Error(`Anthropic cache_control budget exceeded: ${count} > 4`);
+    }
+}
+function estimateCacheRead(cacheRead, slots) {
+    if (cacheRead <= 0)
+        return undefined;
+    const keys = ["system", "tools", "messages"].filter(key => slots[key]);
+    if (!keys.length)
+        return undefined;
+    const share = Math.floor(cacheRead / keys.length);
+    const remainder = cacheRead - share * keys.length;
+    return Object.fromEntries(keys.map((key, index) => [key, share + (index === 0 ? remainder : 0)]));
+}
+function numeric(raw, field) {
+    const value = raw[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new ProtocolResponseError("anthropic-messages", `usage.${field} is invalid`);
+    }
+    return value;
+}
+export class AnthropicMessagesAdapter {
+    protocol = "anthropic-messages";
+    protocolCapabilities = ANTHROPIC_PROTOCOL_CAPABILITIES;
+    buildRequest(input) {
+        const strategy = cacheStrategy(input.extensions);
+        const system = systemBlocks(input.context, strategy);
+        const messages = input.context.turns
+            .map(canonicalMessage)
+            .filter((message) => message !== undefined);
+        applyMessageCacheControl(messages, input.context.frozenPrefixLen, strategy);
+        if (input.context.stateTurn) {
+            const stateMessage = canonicalMessage(input.context.stateTurn);
+            if (stateMessage)
+                messages.push(stateMessage);
+        }
+        if (!messages.length)
+            messages.push({ role: "user", content: "Proceed." });
+        const tools = requestTools(input, system, strategy);
+        const wire = extensionsForWire(input.extensions);
+        const betas = Array.isArray(input.extensions.betas) && input.extensions.betas.length
+            ? input.extensions.betas
+            : undefined;
+        const params = {
+            ...wire,
+            model: input.resolved.identity.modelId,
+            max_tokens: typeof input.extensions.max_tokens === "number"
+                ? input.extensions.max_tokens
+                : 8096,
+            ...(system ? { system } : {}),
+            messages,
+            ...(tools ? { tools } : {}),
+            ...(betas ? { betas } : {}),
+        };
+        assertCacheBudget(params);
+        return {
+            transport: betas ? "beta" : "stable",
+            params,
+            cacheSlots: countSlots(system, tools, messages),
+        };
+    }
+    decodeComplete(raw, _input) {
+        let content = "";
+        const toolCalls = [];
+        for (const block of raw.content ?? []) {
+            if (block.type === "text")
+                content += block.text;
+            else if (block.type === "tool_use") {
+                const call = normalizeToolCall(block.id, block.name, block.input);
+                if (call)
+                    toolCalls.push(call);
+            }
+        }
+        const usage = this.normalizeUsage(raw.usage);
+        const blocks = raw.content;
+        return {
+            message: {
+                role: "assistant",
+                content,
+                ...(usage ? { tokenCount: usage.outputTokens } : {}),
+                toolCalls,
+            },
+            ...(blocks?.length ? { replay: { protocol: "anthropic-messages", native_blocks: blocks } } : {}),
+        };
+    }
+    createStreamState(input) {
+        const plan = this.buildRequest(input.input);
+        return {
+            input: input.input,
+            cacheSlots: plan.cacheSlots,
+            toolBlocks: {},
+            nativeBlocks: {},
+            finalToolCalls: [],
+            finalText: "",
+            uncachedInput: 0,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            outputTokens: 0,
+        };
+    }
+    pushStreamChunk(chunk, state) {
+        const events = [];
+        if (chunk.type === "message_start" || chunk.type === "message_delta") {
+            const raw = chunk.usage ?? chunk.message?.usage;
+            if (raw) {
+                state.uncachedInput = Math.max(state.uncachedInput, numeric(raw, "input_tokens") ?? 0);
+                state.cacheReadTokens = Math.max(state.cacheReadTokens, numeric(raw, "cache_read_input_tokens") ?? 0);
+                state.cacheCreationTokens = Math.max(state.cacheCreationTokens, numeric(raw, "cache_creation_input_tokens") ?? 0);
+                state.outputTokens = Math.max(state.outputTokens, numeric(raw, "output_tokens") ?? 0);
+                const inputTokens = state.uncachedInput + state.cacheReadTokens + state.cacheCreationTokens;
+                const providerUsage = {
+                    inputTokens,
+                    outputTokens: state.outputTokens,
+                    ...(state.cacheReadTokens ? { cacheReadInputTokens: state.cacheReadTokens } : {}),
+                    ...(state.cacheCreationTokens ? { cacheCreationInputTokens: state.cacheCreationTokens } : {}),
+                };
+                const rawStopReason = chunk.delta?.stop_reason;
+                const stopReason = this.normalizeStopReason(rawStopReason);
+                const bySlot = estimateCacheRead(state.cacheReadTokens, state.cacheSlots);
+                events.push({
+                    type: "usage",
+                    totalTokens: inputTokens + state.outputTokens,
+                    inputTokens,
+                    outputTokens: state.outputTokens,
+                    cacheReadInputTokens: state.cacheReadTokens,
+                    cacheCreationInputTokens: state.cacheCreationTokens,
+                    ...(bySlot ? { cacheReadInputTokensBySlot: bySlot } : {}),
+                    ...(stopReason ? { stopReason } : {}),
+                    ...(rawStopReason ? { rawStopReason } : {}),
+                    providerUsage,
+                });
+            }
+        }
+        else if (chunk.type === "content_block_start") {
+            state.nativeBlocks[chunk.index] = { ...chunk.content_block };
+            if (chunk.content_block.type === "tool_use") {
+                state.toolBlocks[chunk.index] = {
+                    id: chunk.content_block.id,
+                    name: chunk.content_block.name,
+                    argsBuffer: "",
+                };
+            }
+        }
+        else if (chunk.type === "content_block_delta") {
+            const delta = chunk.delta;
+            if (delta.type === "text_delta") {
+                state.finalText += delta.text;
+                state.nativeBlocks[chunk.index] = {
+                    ...state.nativeBlocks[chunk.index],
+                    text: String(state.nativeBlocks[chunk.index]?.text ?? "") + delta.text,
+                };
+                events.push({ type: "text_delta", delta: delta.text });
+            }
+            else if (delta.type === "thinking_delta") {
+                state.nativeBlocks[chunk.index] = {
+                    ...state.nativeBlocks[chunk.index],
+                    thinking: String(state.nativeBlocks[chunk.index]?.thinking ?? "") + delta.thinking,
+                };
+                events.push({ type: "thinking_delta", delta: delta.thinking });
+            }
+            else if (delta.type === "signature_delta") {
+                state.nativeBlocks[chunk.index] = {
+                    ...state.nativeBlocks[chunk.index],
+                    signature: String(state.nativeBlocks[chunk.index]?.signature ?? "") + delta.signature,
+                };
+            }
+            else if (delta.type === "input_json_delta" && state.toolBlocks[chunk.index]) {
+                state.toolBlocks[chunk.index].argsBuffer += delta.partial_json;
+            }
+        }
+        else if (chunk.type === "content_block_stop" && state.toolBlocks[chunk.index]) {
+            const tool = state.toolBlocks[chunk.index];
+            delete state.toolBlocks[chunk.index];
+            let args = {};
+            try {
+                args = JSON.parse(tool.argsBuffer || "{}");
+            }
+            catch {
+                args = {};
+            }
+            state.nativeBlocks[chunk.index] = { ...state.nativeBlocks[chunk.index], input: args };
+            state.finalToolCalls.push({
+                id: tool.id,
+                name: tool.name,
+                arguments: JSON.stringify(args),
+            });
+            events.push({
+                type: "tool_call",
+                id: tool.id,
+                name: tool.name,
+                arguments: args,
+            });
+        }
+        return { events };
+    }
+    finishStream(state) {
+        const blocks = Object.keys(state.nativeBlocks)
+            .map(Number)
+            .sort((left, right) => left - right)
+            .map(index => state.nativeBlocks[index]);
+        return {
+            events: [],
+            ...(blocks.length ? { replay: { protocol: "anthropic-messages", native_blocks: blocks } } : {}),
+        };
+    }
+    normalizeUsage(raw) {
+        if (raw === undefined || raw === null)
+            return undefined;
+        if (typeof raw !== "object" || Array.isArray(raw)) {
+            throw new ProtocolResponseError("anthropic-messages", "usage must be an object");
+        }
+        const record = raw;
+        const uncached = numeric(record, "input_tokens");
+        const cacheRead = numeric(record, "cache_read_input_tokens");
+        const cacheCreation = numeric(record, "cache_creation_input_tokens");
+        const output = numeric(record, "output_tokens");
+        if (uncached === undefined && cacheRead === undefined
+            && cacheCreation === undefined && output === undefined)
+            return undefined;
+        return {
+            inputTokens: (uncached ?? 0) + (cacheRead ?? 0) + (cacheCreation ?? 0),
+            outputTokens: output ?? 0,
+            ...(cacheRead ? { cacheReadInputTokens: cacheRead } : {}),
+            ...(cacheCreation ? { cacheCreationInputTokens: cacheCreation } : {}),
+        };
+    }
+    normalizeStopReason(raw) {
+        if (raw === undefined)
+            return undefined;
+        switch (raw) {
+            case "end_turn": return "end_turn";
+            case "tool_use": return "tool_use";
+            case "max_tokens": return "max_tokens";
+            case "stop_sequence": return "stop_sequence";
+            default: return "other";
+        }
+    }
+}