@deepstrike/sdk 0.2.52 → 0.2.61

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/os/public.d.ts

@@ -15,5 +15,5 @@ export { ReplayProvider } from "../runtime/replay-provider.js";
 export type { ReplayProviderOpts } from "../runtime/replay-provider.js";
 export { extractRecordedMessages } from "../runtime/replay-fixture.js";
 export { ProviderReplayValidationError, DEGRADED_REASONING_PLACEHOLDER } from "../providers/replay-validator.js";
-export { assessProviderReplayability, peekProviderReplay, seedProviderReplayFromEvents, isReplayCompatibleWithProvider, } from "../runtime/provider-replay.js";
+export { ProviderReplayProtocolMismatchError, assessProviderReplayability, peekProviderReplay, seedProviderReplayFromEvents, isReplayCompatibleWithProvider, } from "../runtime/provider-replay.js";
 export type { ReplayabilityAssessment } from "../types.js";

package/dist/os/public.js

@@ -12,4 +12,4 @@ export { PermissionManager, PermissionMode } from "../safety/permissions.js";
 export { ReplayProvider } from "../runtime/replay-provider.js";
 export { extractRecordedMessages } from "../runtime/replay-fixture.js";
 export { ProviderReplayValidationError, DEGRADED_REASONING_PLACEHOLDER } from "../providers/replay-validator.js";
-export { assessProviderReplayability, peekProviderReplay, seedProviderReplayFromEvents, isReplayCompatibleWithProvider, } from "../runtime/provider-replay.js";
+export { ProviderReplayProtocolMismatchError, assessProviderReplayability, peekProviderReplay, seedProviderReplayFromEvents, isReplayCompatibleWithProvider, } from "../runtime/provider-replay.js";

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

@@ -0,0 +1,59 @@
+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 declare const ANTHROPIC_TEXTUAL_TOOL_CALL_START_MARKER = "<\uFF5C\uFF5CDSML\uFF5C\uFF5Ctool_calls>";
+type TextualToolCallPolicy = "off" | "reject";
+interface TextualToolCallGuardState {
+    policy: TextualToolCallPolicy;
+    mode: "passthrough" | "candidate";
+    tail: string;
+    capturedLength: number;
+    sawNativeToolCall: boolean;
+}
+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[];
+    readonly textualToolCallGuard: TextualToolCallGuardState;
+    finalText: string;
+    uncachedInput: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    cacheTelemetryMeasured: boolean;
+    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>, decodeInput: 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;
+}
+export {};