@deepstrike/wasm 0.2.39 → 0.2.41

package/dist/memory/extraction.js

@@ -0,0 +1,48 @@
+const KINDS = new Set(["user", "feedback", "project", "reference"]);
+export async function extractSessionMemories(provider, session, scope, systemPrompt) {
+    const transcript = session.messages.map(message => `[${message.role.toUpperCase()}] ${message.content}`).join("\n").slice(0, 8_000);
+    const context = {
+        systemText: [systemPrompt, "Extract durable, reusable facts from this completed session. Return only JSON; do not include transient progress or guesses."].filter(Boolean).join("\n\n"),
+        turns: [{ role: "user", content: `${transcript}\n\nReturn {"memories":[{"name":"stable-kebab-key","kind":"user|feedback|project|reference","content":"fact","description":"why durable","confidence":0.0,"links":[],"pinned":false,"ttl_days":null,"evidence_refs":[]}]} with at most 10 items. Return {"memories":[]} when nothing is durable.`, toolCalls: [] }],
+    };
+    let output = "";
+    const state = provider.createRunState?.();
+    for await (const event of provider.stream(context, [], undefined, state)) {
+        if (event.type === "text_delta" && "delta" in event)
+            output += event.delta;
+    }
+    return parseExtractedMemories(output, session, scope);
+}
+export function parseExtractedMemories(output, session, scope) {
+    let value;
+    try {
+        value = JSON.parse(output.trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, ""));
+    }
+    catch {
+        return [];
+    }
+    if (!value || typeof value !== "object" || !Array.isArray(value.memories))
+        return [];
+    const records = [];
+    for (const raw of value.memories.slice(0, 10)) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const draft = raw;
+        const name = typeof draft.name === "string" ? draft.name.trim() : "";
+        const kind = typeof draft.kind === "string" && KINDS.has(draft.kind) ? draft.kind : undefined;
+        const content = typeof draft.content === "string" ? draft.content.trim() : "";
+        if (!name || !kind || !content)
+            continue;
+        records.push({
+            record_id: `${scope.tenant_id}:${scope.namespace}:${kind}:${name}`, scope, name, kind, content,
+            description: typeof draft.description === "string" ? draft.description.trim() : "",
+            provenance: { session_id: session.sessionId, author: "extraction", trust: "untrusted", evidence_refs: Array.isArray(draft.evidence_refs) ? draft.evidence_refs.filter((ref) => typeof ref === "string") : [] },
+            created_at: session.updatedAtMs, updated_at: session.updatedAtMs, recall_count: 0,
+            confidence: typeof draft.confidence === "number" ? Math.max(0, Math.min(1, draft.confidence)) : 0.5,
+            links: Array.isArray(draft.links) ? draft.links.filter((link) => typeof link === "string") : [],
+            pinned: draft.pinned === true,
+            ...(typeof draft.ttl_days === "number" && Number.isInteger(draft.ttl_days) && draft.ttl_days > 0 ? { ttl_days: draft.ttl_days } : {}),
+        });
+    }
+    return records;
+}

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

@@ -1,19 +1,29 @@
 /**
  * `InMemoryDreamStore` — a lightweight `DreamStore` implementation backed by per-agent `Map`s.
  * WASM port of node/src/memory/in-memory-store.ts. See that file for the full design.
+ *
+ * Search returns a genuine relevance score (never stored confidence); the store bounds itself by
+ * value-ordered retention eviction (M3) and mirrors recall lifecycle and pin state (M3/M4).
  */
-import type { CurationResult, DreamStore, MemoryEntry, SessionData } from "./index.js";
+import type { DreamStore, MemoryQuery, MemoryRecall, MemoryRecallLifecycle, MemoryRecord, SessionData } from "./index.js";
+export interface InMemoryDreamStoreOptions {
+    maxRecords?: number;
+    staleWarningDays?: number;
+    now?: () => number;
+}
 export declare class InMemoryDreamStore implements DreamStore {
     private readonly initialMemories;
-    private sessions;
     private memories;
     readonly savedSessions: SessionData[];
-    constructor(initialMemories?: MemoryEntry[]);
-    addSession(agentId: string, session: SessionData): void;
-    addMemories(agentId: string, entries: MemoryEntry[]): void;
-    loadSessions(agentId: string): Promise<SessionData[]>;
-    loadMemories(agentId: string): Promise<MemoryEntry[]>;
-    commit(agentId: string, result: CurationResult, existing: MemoryEntry[]): Promise<void>;
-    search(agentId: string, _query: string, topK?: number): Promise<MemoryEntry[]>;
+    private readonly maxRecords?;
+    private readonly staleWarningDays;
+    private readonly now;
+    constructor(initialMemories?: MemoryRecord[], options?: InMemoryDreamStoreOptions);
+    private recordsFor;
+    private evictToCapacity;
+    upsert(agentId: string, incoming: MemoryRecord): Promise<void>;
+    search(agentId: string, query: MemoryQuery): Promise<MemoryRecall[]>;
     saveSession(data: SessionData): Promise<void>;
+    recordRecall(agentId: string, recalls: MemoryRecallLifecycle[]): Promise<void>;
+    setPinned(agentId: string, recordId: string, pinned: boolean): Promise<void>;
 }

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

@@ -1,23 +1,19 @@
+import { rankMemories } from "./ranking.js";
+import { memoryRetentionScore } from "./retention.js";
 export class InMemoryDreamStore {
     initialMemories;
-    sessions = new Map();
     memories = new Map();
     savedSessions = [];
-    constructor(initialMemories = []) {
+    maxRecords;
+    staleWarningDays;
+    now;
+    constructor(initialMemories = [], options = {}) {
         this.initialMemories = initialMemories;
+        this.maxRecords = options.maxRecords;
+        this.staleWarningDays = options.staleWarningDays ?? 2;
+        this.now = options.now ?? Date.now;
     }
-    addSession(agentId, session) {
-        const list = this.sessions.get(agentId) ?? [];
-        list.push(session);
-        this.sessions.set(agentId, list);
-    }
-    addMemories(agentId, entries) {
-        this.memories.set(agentId, [...(this.memories.get(agentId) ?? []), ...entries]);
-    }
-    async loadSessions(agentId) {
-        return this.sessions.get(agentId) ?? [];
-    }
-    async loadMemories(agentId) {
+    recordsFor(agentId) {
         if (this.memories.has(agentId))
             return this.memories.get(agentId);
         if (this.initialMemories.length > 0) {
@@ -26,18 +22,67 @@ export class InMemoryDreamStore {
         }
         return [];
     }
-    async commit(agentId, result, existing) {
-        const kept = existing.filter((_, i) => !result.toRemoveIndices.includes(i));
-        this.memories.set(agentId, [...kept, ...result.toAdd]);
+    evictToCapacity(records) {
+        if (this.maxRecords === undefined || records.length <= this.maxRecords)
+            return records;
+        const nowMs = this.now();
+        const scored = records.map((record, insertionIndex) => ({
+            record,
+            insertionIndex,
+            score: record.pinned ? Number.POSITIVE_INFINITY : memoryRetentionScore(record, nowMs, this.staleWarningDays),
+        }));
+        scored.sort((a, b) => b.score - a.score || a.insertionIndex - b.insertionIndex);
+        return scored.slice(0, this.maxRecords).map(entry => entry.record);
+    }
+    async upsert(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
+            && record.kind === incoming.kind && record.name === incoming.name);
+        if (index >= 0)
+            kept[index] = incoming;
+        else
+            kept.push(incoming);
+        this.memories.set(agentId, this.evictToCapacity(kept));
     }
-    async search(agentId, _query, topK = 5) {
-        const all = await this.loadMemories(agentId);
-        return all.slice(0, topK);
+    async search(agentId, query) {
+        const all = this.recordsFor(agentId);
+        const candidates = all.filter(record => record.scope.tenant_id === query.scope.tenant_id
+            && record.scope.namespace === query.scope.namespace
+            && (query.kinds.length === 0 || query.kinds.includes(record.kind)));
+        const ranked = rankMemories(query.query, candidates.map((record, insertionIndex) => {
+            return {
+                value: record,
+                searchableText: `${record.name} ${record.description} ${record.content}`,
+                updatedAt: Number.isFinite(record.updated_at) ? record.updated_at : 0,
+                recallCount: record.recall_count,
+                ttlDays: record.ttl_days,
+                insertionIndex,
+            };
+        }), query.top_k, { nowMs: this.now(), staleWarningDays: this.staleWarningDays });
+        return ranked
+            .filter(hit => query.min_score === undefined || hit.score >= query.min_score)
+            .map(hit => ({ record: hit.value, score: hit.score, why: hit.why }));
     }
     async saveSession(data) {
         this.savedSessions.push(data);
-        const list = this.sessions.get(data.agentId) ?? [];
-        list.push(data);
-        this.sessions.set(data.agentId, list);
+    }
+    async recordRecall(agentId, recalls) {
+        const records = this.recordsFor(agentId);
+        for (const recall of recalls) {
+            const record = records.find(candidate => candidate.record_id === recall.record_id);
+            if (record) {
+                record.recall_count = recall.recall_count;
+                record.last_recalled_at = recall.last_recalled_at;
+            }
+        }
+        this.memories.set(agentId, records);
+    }
+    async setPinned(agentId, recordId, pinned) {
+        const records = this.recordsFor(agentId);
+        const record = records.find(candidate => candidate.record_id === recordId);
+        if (record)
+            record.pinned = pinned;
+        this.memories.set(agentId, records);
     }
 }

package/dist/memory/index.d.ts

@@ -7,7 +7,7 @@ export declare class WorkingMemory {
     has(key: string): boolean;
 }
 export interface SessionMessage {
-    role: "user" | "assistant" | "tool";
+    role: "system" | "user" | "assistant" | "tool";
     content: string;
     tokenCount?: number;
     toolCalls?: Array<{
@@ -24,35 +24,63 @@ export interface SessionData {
     createdAtMs: number;
     updatedAtMs: number;
 }
-export interface MemoryEntry {
-    text: string;
-    score: number;
-    metadata: unknown;
+export type MemoryKind = "user" | "feedback" | "project" | "reference";
+export type MemoryAuthor = "model" | "host" | "extraction";
+export type MemoryTrustLevel = "untrusted" | "user_asserted" | "host_verified";
+export interface MemoryScope {
+    tenant_id: string;
+    namespace: string;
+}
+export interface MemoryProvenance {
+    session_id?: string;
+    author: MemoryAuthor;
+    trust: MemoryTrustLevel;
+    evidence_refs: string[];
 }
-export interface CurationStats {
-    insightsProcessed: number;
-    duplicatesRemoved: number;
-    conflictsResolved: number;
-    entriesAdded: number;
+export interface MemoryRecord {
+    record_id: string;
+    scope: MemoryScope;
+    name: string;
+    kind: MemoryKind;
+    content: string;
+    description: string;
+    provenance: MemoryProvenance;
+    created_at: number;
+    updated_at: number;
+    last_recalled_at?: number;
+    recall_count: number;
+    confidence: number;
+    links: string[];
+    pinned: boolean;
+    ttl_days?: number;
+}
+export interface MemoryRecall {
+    record: MemoryRecord;
+    score: number;
+    why: string;
 }
-export interface CurationResult {
-    toAdd: MemoryEntry[];
-    toRemoveIndices: number[];
-    stats: CurationStats;
+export interface MemoryQuery {
+    scope: MemoryScope;
+    query: string;
+    top_k: number;
+    kinds: MemoryKind[];
+    min_score?: number;
 }
-export interface DreamResult {
-    sessionsProcessed: number;
-    insightsExtracted: number;
-    entriesAdded: number;
-    entriesRemoved: number;
+/** One record's recall lifecycle, mirrored from the kernel's `memory_recalled` observation (M3). */
+export interface MemoryRecallLifecycle {
+    record_id: string;
+    recall_count: number;
+    last_recalled_at: number;
 }
 export interface DreamStore {
-    loadSessions(agentId: string): Promise<SessionData[]>;
-    loadMemories(agentId: string): Promise<MemoryEntry[]>;
-    commit(agentId: string, result: CurationResult, existing: MemoryEntry[]): Promise<void>;
-    search(agentId: string, query: string, topK?: number): Promise<MemoryEntry[]>;
-    /** Persist a completed session for future consolidation via `Agent.dream()`. */
+    upsert(agentId: string, record: MemoryRecord): Promise<void>;
+    search(agentId: string, query: MemoryQuery): Promise<MemoryRecall[]>;
+    /** Persist a completed session before the runner's one extraction pass. */
     saveSession(data: SessionData): Promise<void>;
+    /** M3: mirror the kernel's journaled recall lifecycle into the durable store. Optional. */
+    recordRecall?(agentId: string, recalls: MemoryRecallLifecycle[]): Promise<void>;
+    /** M4: set/clear a record's pin (exempt from retention eviction). Optional. */
+    setPinned?(agentId: string, recordId: string, pinned: boolean): Promise<void>;
 }
 export interface SessionStore {
     loadSession(sessionId: string): Promise<SessionData | undefined>;

package/dist/memory/ranking.d.ts

@@ -0,0 +1,32 @@
+export interface RankableMemory<T> {
+    value: T;
+    searchableText: string;
+    updatedAt: number;
+    /** Times this record has been recalled — a proven-useful record ranks slightly higher. */
+    recallCount: number;
+    /** Optional day-based TTL. Records past it are discounted, not dropped (host owns hard deletion). */
+    ttlDays?: number;
+    insertionIndex: number;
+}
+/** One ranked hit with a genuine relevance score in [0,1] and a human-readable rationale. */
+export interface RankedMemory<T> {
+    value: T;
+    score: number;
+    why: string;
+}
+export interface RankOptions {
+    /** Wall-clock reference for the staleness discount. Omit to disable TTL/staleness scoring. */
+    nowMs?: number;
+    /** Age (days) past which a record starts losing relevance. */
+    staleWarningDays?: number;
+}
+/**
+ * Rank memories without embeddings or provider calls, returning a genuine relevance score in [0,1].
+ *
+ * The score is lexical overlap (distinct query terms present, as a fraction) as the dominant term,
+ * lifted slightly by recall history and lowered by TTL/staleness. Recency and insertion order break
+ * ties. A non-empty query never returns unrelated entries (lexical overlap zero ⇒ filtered out).
+ *
+ * The score is relevance, deliberately distinct from the record's stored confidence.
+ */
+export declare function rankMemories<T>(query: string, candidates: Array<RankableMemory<T>>, topK: number, opts?: RankOptions): Array<RankedMemory<T>>;

package/dist/memory/ranking.js

@@ -0,0 +1,77 @@
+function terms(text) {
+    const result = new Set();
+    for (const segment of text.toLocaleLowerCase().match(/[\p{L}\p{N}]+/gu) ?? []) {
+        result.add(segment);
+        if (/\p{Script=Han}/u.test(segment)) {
+            const characters = [...segment];
+            for (let index = 0; index + 1 < characters.length; index++) {
+                result.add(characters[index] + characters[index + 1]);
+            }
+        }
+    }
+    return result;
+}
+const DAY_MS = 86_400_000;
+/** Staleness discount in [0,1): grows once a record is older than the warning window, and jumps
+ *  past its TTL. Clock-based, so it lives host-side (the kernel owns no wall clock). */
+function stalenessPenalty(updatedAt, ttlDays, opts) {
+    if (opts.nowMs === undefined)
+        return 0;
+    const ageDays = Math.max(0, (opts.nowMs - updatedAt) / DAY_MS);
+    let penalty = 0;
+    if (opts.staleWarningDays !== undefined && ageDays > opts.staleWarningDays) {
+        penalty += Math.min(0.3, 0.05 * (ageDays - opts.staleWarningDays));
+    }
+    if (ttlDays !== undefined && ageDays > ttlDays) {
+        penalty += 0.4;
+    }
+    return Math.min(0.9, penalty);
+}
+/** Small proven-usefulness boost from recall history: log-shaped, capped so it never overturns a
+ *  clearly more lexically relevant record. */
+function recallBoost(recallCount) {
+    if (recallCount <= 0)
+        return 0;
+    return Math.min(0.15, 0.05 * Math.log2(1 + recallCount));
+}
+/**
+ * Rank memories without embeddings or provider calls, returning a genuine relevance score in [0,1].
+ *
+ * The score is lexical overlap (distinct query terms present, as a fraction) as the dominant term,
+ * lifted slightly by recall history and lowered by TTL/staleness. Recency and insertion order break
+ * ties. A non-empty query never returns unrelated entries (lexical overlap zero ⇒ filtered out).
+ *
+ * The score is relevance, deliberately distinct from the record's stored confidence.
+ */
+export function rankMemories(query, candidates, topK, opts = {}) {
+    const queryTerms = terms(query);
+    const limit = Math.max(0, Math.floor(topK));
+    if (limit === 0)
+        return [];
+    return candidates
+        .map(candidate => {
+        const candidateTerms = terms(candidate.searchableText);
+        let lexicalMatches = 0;
+        for (const term of queryTerms) {
+            if (candidateTerms.has(term))
+                lexicalMatches++;
+        }
+        const lexicalFraction = queryTerms.size === 0 ? 0 : lexicalMatches / queryTerms.size;
+        const penalty = stalenessPenalty(candidate.updatedAt, candidate.ttlDays, opts);
+        const boost = recallBoost(candidate.recallCount);
+        const score = Math.max(0, Math.min(1, lexicalFraction * 0.85 + boost - penalty));
+        const why = queryTerms.size === 0
+            ? "no query terms; insertion order"
+            : `lexical ${lexicalMatches}/${queryTerms.size}`
+                + (boost > 0 ? `, recall×${candidate.recallCount}` : "")
+                + (penalty > 0 ? `, stale −${penalty.toFixed(2)}` : "");
+        return { ...candidate, lexicalMatches, score, why };
+    })
+        .filter(candidate => queryTerms.size === 0 || candidate.lexicalMatches > 0)
+        .sort((a, b) => b.score - a.score
+        || b.lexicalMatches - a.lexicalMatches
+        || b.updatedAt - a.updatedAt
+        || a.insertionIndex - b.insertionIndex)
+        .slice(0, limit)
+        .map(candidate => ({ value: candidate.value, score: candidate.score, why: candidate.why }));
+}

package/dist/memory/retention.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Host-side mirror of the kernel's shared retention vocabulary (`crates/.../mm/value.rs` +
+ * `memory_retention_score`). The durable store owns the full cross-session record set, so it — not
+ * the kernel — enforces the capacity bound; it must rank by the same integer "value" definition so
+ * memory and context knowledge agree on what is worth keeping.
+ *
+ * Integer terms (magnitudes well within 2^53, so JS number math is exact). The turn-based recency
+ * term is omitted here: the host store has no turn counter, so a record's recall_count, kind,
+ * confidence, size, and (clock-based) staleness drive the ordering. `parity` tests pin this against
+ * the Rust reference for the terms both compute.
+ */
+import type { MemoryRecord } from "./index.js";
+/**
+ * Deterministic retention score for a durable record. Higher is retained first;
+ * `Number.POSITIVE_INFINITY` is reserved for pins (the kernel uses `i64::MAX`).
+ */
+export declare function memoryRetentionScore(record: MemoryRecord, nowMs: number, staleWarningDays: number): number;

package/dist/memory/retention.js

@@ -0,0 +1,54 @@
+const DAY_MS = 86_400_000;
+const KIND_WEIGHT = {
+    user: 1_600,
+    feedback: 1_800,
+    project: 1_400,
+    reference: 1_200,
+};
+/** floor(log2(1 + n)) — the kernel's stable ln(1+n) proxy for usage. */
+function usageBucket(useCount) {
+    if (useCount <= 0)
+        return 0;
+    return Math.floor(Math.log2(useCount + 1));
+}
+/** Day-based staleness discount in parts-per-million, matching the store's recall-ranking penalty
+ *  band but expressed on the kernel's ppm scale. */
+function staleDiscountPpm(updatedAt, ttlDays, nowMs, staleWarningDays) {
+    const ageDays = Math.max(0, (nowMs - updatedAt) / DAY_MS);
+    let ppm = 0;
+    if (ageDays > staleWarningDays) {
+        ppm += Math.min(300_000, 50_000 * (ageDays - staleWarningDays));
+    }
+    if (ttlDays !== undefined && ageDays > ttlDays) {
+        ppm += 400_000;
+    }
+    return Math.min(1_000_000, Math.floor(ppm));
+}
+/**
+ * Deterministic retention score for a durable record. Higher is retained first;
+ * `Number.POSITIVE_INFINITY` is reserved for pins (the kernel uses `i64::MAX`).
+ */
+export function memoryRetentionScore(record, nowMs, staleWarningDays) {
+    if (record.pinned)
+        return Number.POSITIVE_INFINITY;
+    const usage = usageBucket(record.recall_count) * 8_192;
+    // Recency (turn-based in the kernel) is unavailable host-side; omitted deterministically.
+    const kind = KIND_WEIGHT[record.kind] ?? 0;
+    const confidencePpm = Math.min(1_000_000, Math.floor(Math.max(0, Math.min(1, record.confidence)) * 1_000_000));
+    const confidence = Math.floor(confidencePpm / 250);
+    const stalePpm = staleDiscountPpm(record.updated_at, record.ttl_days, nowMs, staleWarningDays);
+    const staleness = Math.floor(stalePpm / 125);
+    // 4-bytes-per-token proxy, matching the kernel's content.len()/4.
+    const tokens = Math.min(0xffffffff, Math.floor(byteLength(record.content) / 4));
+    const size = tokens * 4;
+    return usage + kind + confidence - staleness - size;
+}
+function byteLength(text) {
+    // Match Rust's content.len() (UTF-8 bytes) without pulling in Buffer for portability.
+    let bytes = 0;
+    for (const ch of text) {
+        const code = ch.codePointAt(0);
+        bytes += code <= 0x7f ? 1 : code <= 0x7ff ? 2 : code <= 0xffff ? 3 : 4;
+    }
+    return bytes;
+}

package/dist/providers/base.d.ts

@@ -1,5 +1,10 @@
 import type { Message, RenderedContext } from "../types.js";
 import { assistantReplayKey } from "../runtime/provider-replay.js";
+export declare class UnsupportedModalityError extends Error {
+    readonly modality: string;
+    readonly provider: string;
+    constructor(modality: string, provider: string);
+}
 /** History turns with the volatile State turn appended as the latest turn
  *  (OpenAI), keeping the history a stable cacheable prefix. Anthropic appends it
  *  after the cache breakpoint. Absent on un-rebuilt bindings — then the state is

package/dist/providers/base.js

@@ -1,4 +1,14 @@
 import { assistantReplayKey } from "../runtime/provider-replay.js";
+export class UnsupportedModalityError extends Error {
+    modality;
+    provider;
+    constructor(modality, provider) {
+        super(`UnsupportedModality: ${modality} is not supported by ${provider}`);
+        this.name = "UnsupportedModalityError";
+        this.modality = modality;
+        this.provider = provider;
+    }
+}
 function parseToolArguments(args) {
     try {
         return JSON.parse(args || "{}");
@@ -7,6 +17,16 @@ function parseToolArguments(args) {
         return {};
     }
 }
+/** Map an audio MIME type to OpenAI's `input_audio.format` (accepts "mp3" | "wav").
+ *  `audio/mpeg` must become "mp3", not the raw "mpeg" subtype. */
+function openaiAudioFormat(mediaType) {
+    const sub = (mediaType ?? "audio/wav").split("/")[1]?.toLowerCase() ?? "wav";
+    if (sub === "mpeg" || sub === "mp3")
+        return "mp3";
+    if (sub === "wav" || sub === "wave" || sub === "x-wav")
+        return "wav";
+    return sub;
+}
 /** Multimodal: OpenAI content blocks from contentParts (text + image). */
 function openAIPartsContent(parts) {
     return parts.map(p => {
@@ -14,6 +34,15 @@ function openAIPartsContent(parts) {
             const url = p.data ? `data:${p.mediaType ?? "image/png"};base64,${p.data}` : (p.url ?? "");
             return { type: "image_url", image_url: { url, ...(p.detail ? { detail: p.detail } : {}) } };
         }
+        if (p.type === "audio") {
+            // OpenAI audio has no URL form — a part without base64 data cannot be sent.
+            if (!p.data)
+                throw new UnsupportedModalityError("audio (no data)", "openai");
+            return {
+                type: "input_audio",
+                input_audio: { data: p.data, format: openaiAudioFormat(p.mediaType) },
+            };
+        }
         return { type: "text", text: p.text ?? p.output ?? "" };
     });
 }
@@ -26,6 +55,9 @@ function anthropicPartsContent(parts) {
                 : { type: "url", url: p.url ?? "" };
             return { type: "image", source };
         }
+        if (p.type === "audio") {
+            throw new UnsupportedModalityError("audio", "anthropic");
+        }
         return { type: "text", text: p.text ?? p.output ?? "" };
     });
 }

package/dist/runtime/context-policy.d.ts

@@ -0,0 +1,35 @@
+export declare const CONTEXT_POLICY_VERSION: 1;
+export declare const PPM_SCALE: 1000000;
+export interface ContextPressureThresholdsV1 {
+    snip: number;
+    micro: number;
+    collapse: number;
+    auto: number;
+    renewal: number;
+}
+export interface ContextPolicyV1 {
+    pressureThresholds: ContextPressureThresholdsV1;
+    targetAfterCompress: number;
+    preserveRecentTurns: number;
+    renewalCarryover: number;
+    collapseOldAssistantNarration: boolean;
+    idleMicroCompactMinutes: number;
+}
+export interface ContextPolicyWireV1 {
+    version: typeof CONTEXT_POLICY_VERSION;
+    pressure_thresholds_ppm: ContextPressureThresholdsV1;
+    target_after_compress_ppm: number;
+    preserve_recent_turns: number;
+    renewal_carryover_ppm: number;
+    collapse_old_assistant_narration: boolean;
+    idle_micro_compact_minutes: number;
+}
+export interface ContextPolicyOverridesV1 extends Partial<Omit<ContextPolicyV1, "pressureThresholds">> {
+    pressureThresholds?: Partial<ContextPressureThresholdsV1>;
+}
+export declare const DEFAULT_CONTEXT_POLICY_V1: Readonly<ContextPolicyV1>;
+/** Resolve ergonomic partial SDK options into one complete, atomically validated policy. */
+export declare function contextPolicyV1(overrides?: ContextPolicyOverridesV1): ContextPolicyV1;
+/** Convert the public ratio-based policy to the canonical integer-only ABI wire shape. */
+export declare function normalizeContextPolicyV1(policy: ContextPolicyV1): ContextPolicyWireV1;
+export declare function ratioToPpm(value: number, field?: string): number;

package/dist/runtime/context-policy.js

@@ -0,0 +1,66 @@
+export const CONTEXT_POLICY_VERSION = 1;
+export const PPM_SCALE = 1_000_000;
+export const DEFAULT_CONTEXT_POLICY_V1 = Object.freeze({
+    pressureThresholds: Object.freeze({ snip: 0.70, micro: 0.80, collapse: 0.90, auto: 0.95, renewal: 0.98 }),
+    targetAfterCompress: 0.65,
+    preserveRecentTurns: 2,
+    renewalCarryover: 0.05,
+    collapseOldAssistantNarration: true,
+    idleMicroCompactMinutes: 60,
+});
+/** Resolve ergonomic partial SDK options into one complete, atomically validated policy. */
+export function contextPolicyV1(overrides = {}) {
+    const policy = {
+        ...DEFAULT_CONTEXT_POLICY_V1,
+        ...overrides,
+        pressureThresholds: {
+            ...DEFAULT_CONTEXT_POLICY_V1.pressureThresholds,
+            ...overrides.pressureThresholds,
+        },
+    };
+    normalizeContextPolicyV1(policy);
+    return policy;
+}
+/** Convert the public ratio-based policy to the canonical integer-only ABI wire shape. */
+export function normalizeContextPolicyV1(policy) {
+    const pressure_thresholds_ppm = {
+        snip: ratioToPpm(policy.pressureThresholds.snip, "pressureThresholds.snip"),
+        micro: ratioToPpm(policy.pressureThresholds.micro, "pressureThresholds.micro"),
+        collapse: ratioToPpm(policy.pressureThresholds.collapse, "pressureThresholds.collapse"),
+        auto: ratioToPpm(policy.pressureThresholds.auto, "pressureThresholds.auto"),
+        renewal: ratioToPpm(policy.pressureThresholds.renewal, "pressureThresholds.renewal"),
+    };
+    const ordered = Object.values(pressure_thresholds_ppm);
+    if (!ordered.every((value, index) => index === 0 || ordered[index - 1] < value)) {
+        throw new RangeError("context pressure thresholds must satisfy snip < micro < collapse < auto < renewal");
+    }
+    const target_after_compress_ppm = ratioToPpm(policy.targetAfterCompress, "targetAfterCompress");
+    if (target_after_compress_ppm >= pressure_thresholds_ppm.snip) {
+        throw new RangeError("targetAfterCompress must be lower than the snip threshold");
+    }
+    assertIntegerAtLeast(policy.preserveRecentTurns, 1, "preserveRecentTurns");
+    assertIntegerAtLeast(policy.idleMicroCompactMinutes, 0, "idleMicroCompactMinutes");
+    if (typeof policy.collapseOldAssistantNarration !== "boolean") {
+        throw new TypeError("collapseOldAssistantNarration must be boolean");
+    }
+    return {
+        version: CONTEXT_POLICY_VERSION,
+        pressure_thresholds_ppm,
+        target_after_compress_ppm,
+        preserve_recent_turns: policy.preserveRecentTurns,
+        renewal_carryover_ppm: ratioToPpm(policy.renewalCarryover, "renewalCarryover"),
+        collapse_old_assistant_narration: policy.collapseOldAssistantNarration,
+        idle_micro_compact_minutes: policy.idleMicroCompactMinutes,
+    };
+}
+export function ratioToPpm(value, field = "ratio") {
+    if (!Number.isFinite(value) || value < 0 || value > 1) {
+        throw new RangeError(`${field} must be a finite number between 0 and 1`);
+    }
+    return Math.floor(value * PPM_SCALE + 0.5);
+}
+function assertIntegerAtLeast(value, minimum, field) {
+    if (!Number.isSafeInteger(value) || value < minimum) {
+        throw new RangeError(`${field} must be a safe integer >= ${minimum}`);
+    }
+}

package/dist/runtime/eval.d.ts

@@ -12,6 +12,8 @@ export interface Criterion {
     text: string;
     required?: boolean;
     weight?: number;
+    id?: string;
+    machineCheckable?: boolean;
 }
 export interface VerdictDetail {
     criterion: string;