@deepstrike/sdk 0.2.38 → 0.2.40

package/dist/memory/protocols.d.ts

@@ -19,67 +19,73 @@ export interface SessionData {
     createdAtMs: number;
     updatedAtMs: number;
 }
-export interface MemoryEntry {
-    text: string;
-    score: number;
-    metadata: unknown;
-}
-export interface CurationStats {
-    insightsProcessed: number;
-    duplicatesRemoved: number;
-    conflictsResolved: number;
-    entriesAdded: number;
-}
-export interface CurationResult {
-    toAdd: MemoryEntry[];
-    /** Indices into the `existingMemories` array passed to `DreamStore.loadMemories`. */
-    toRemoveIndices: number[];
-    stats: CurationStats;
+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 DreamStore {
-    loadSessions(agentId: string): Promise<SessionData[]>;
-    loadMemories(agentId: string): Promise<MemoryEntry[]>;
-    commit(agentId: string, result: CurationResult, existing: MemoryEntry[]): Promise<void>;
-    /** Semantic search over the agent's long-term memories. Called on demand during a run. */
-    search(agentId: string, query: string, topK?: number): Promise<MemoryEntry[]>;
-    /** Persist a completed session for future consolidation via `Agent.dream()`. */
-    saveSession(data: SessionData): Promise<void>;
+export interface MemoryProvenance {
+    session_id?: string;
+    author: MemoryAuthor;
+    trust: MemoryTrustLevel;
+    evidence_refs: string[];
 }
-/** Memory kind (4 types, mirroring Claude Code). */
-export type MemoryKind = "user" | "feedback" | "project" | "reference";
-/** Memory metadata (kernel stores, SDK provides full content). */
-export interface MemoryMetadata {
+export interface MemoryRecord {
+    record_id: string;
+    scope: MemoryScope;
     name: string;
+    kind: MemoryKind;
+    content: string;
     description: string;
-    kind?: MemoryKind;
+    provenance: MemoryProvenance;
     created_at: number;
     updated_at: number;
-    session_id?: string;
-    user_role?: string;
-    expertise_level?: string;
-    preference_rule?: string;
-    approved_pattern?: string;
-    project_phase?: string;
-    relative_date?: string;
-    external_url?: string;
-    ticket_ref?: string;
+    last_recalled_at?: number;
+    recall_count: number;
+    confidence: number;
+    links: string[];
+    pinned: boolean;
+    ttl_days?: number;
 }
-/** Memory write request (SDK → kernel). */
-export interface MemoryWriteRequest {
-    metadata: MemoryMetadata;
-    content: string;
+export interface MemoryRecall {
+    record: MemoryRecord;
+    score: number;
+    why: string;
+}
+/** One record's recall lifecycle, mirrored from the kernel's `memory_recalled` observation. */
+export interface MemoryRecallLifecycle {
+    record_id: string;
+    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(agentId: string, query: MemoryQuery): Promise<MemoryRecall[]>;
+    /** Persist the completed session before the runner performs its one extraction pass. */
+    saveSession(data: SessionData): Promise<void>;
+    /**
+     * M3: mirror the kernel's journaled recall lifecycle into the durable store so recall history
+     * (count + last-recalled turn) survives across sessions. Optional: a store that does not track
+     * recall history omits it. The runner calls it when it observes `memory_recalled`.
+     */
+    recordRecall?(agentId: string, recalls: MemoryRecallLifecycle[]): Promise<void>;
+    /**
+     * M4: set (or clear) a record's pin. Pinned records are exempt from the store's retention
+     * eviction. Optional. The runner calls it when the host/model acts on a promotion suggestion.
+     */
+    setPinned?(agentId: string, recordId: string, pinned: boolean): Promise<void>;
 }
 /** Memory query request (kernel → SDK). */
 export interface MemoryQuery {
-    current_context: string;
-    active_tools: string[];
-    already_surfaced: string[];
+    scope: MemoryScope;
+    query: string;
     top_k: number;
-}
-/** Memory retrieval response (SDK → kernel). */
-export interface MemoryRetrieval {
-    selected_memory_ids: string[];
-    selection_rationale: string;
+    kinds: MemoryKind[];
+    min_score?: number;
 }
 /** Memory validation error (mirroring kernel MemoryValidationError). */
 export type MemoryValidationError = {
@@ -102,9 +108,3 @@ export type MemoryValidationError = {
     limit: number;
 };
 /** Durable transcript storage for same-session conversational continuity. */
-export interface DreamResult {
-    sessionsProcessed: number;
-    insightsExtracted: number;
-    entriesAdded: number;
-    entriesRemoved: number;
-}

package/dist/memory/protocols.js

@@ -1 +1,2 @@
 export {};
+/** Durable transcript storage for same-session conversational continuity. */

package/dist/memory/public.d.ts

@@ -1,4 +1,6 @@
 export { WorkingMemory } from "./working.js";
 export { InMemoryDreamStore } from "./in-memory-store.js";
-export type { DreamStore, DreamResult, SessionData, SessionMessage, MemoryEntry, CurationResult, CurationStats, MemoryWriteRequest, MemoryQuery, MemoryRetrieval, MemoryMetadata, MemoryKind, } from "./protocols.js";
+export type { InMemoryDreamStoreOptions } from "./in-memory-store.js";
+export { memoryRetentionScore } from "./retention.js";
+export type { DreamStore, 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,3 +1,4 @@
 // `@deepstrike/sdk/memory` — long-term (dream) and working memory, plus the knowledge-source interface.
 export { WorkingMemory } from "./working.js";
 export { InMemoryDreamStore } from "./in-memory-store.js";
+export { memoryRetentionScore } from "./retention.js";

package/dist/memory/ranking.d.ts

@@ -0,0 +1,33 @@
+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>>;
+export {};

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

@@ -1,11 +1,11 @@
-export { DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, assertNativeProfile, osProfile, } from "../runtime/os-profile.js";
-export type { NativeOsProfile, OsProfileId } from "../runtime/os-profile.js";
+export { DEFAULT_NATIVE_SIGNAL_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, assertNativeProfile, osProfile, } from "../runtime/os-profile.js";
+export type { NativeOsProfile, OsProfileId, SignalPolicy } from "../runtime/os-profile.js";
 export { rebuildOsSnapshotFromSessionEvents } from "../runtime/os-snapshot.js";
 export type { OsSnapshot } from "../runtime/os-snapshot.js";
 export type { KernelEventCategory } from "../runtime/kernel-event-log.js";
 export { KernelPrimitivesDashboard } from "../runtime/kernel-primitives-dashboard.js";
 export type { MemoryPolicy, MemoryWriteRateLimit, ResourceQuota } from "../kernel.js";
-export type { SchedulerBudget } from "../runtime/runner.js";
+export type { PromptBudget, SchedulerPolicy } from "../runtime/runner.js";
 export { ScheduledPrompt } from "../signals/scheduled.js";
 export { SignalGateway } from "../signals/gateway.js";
 export { PermissionManager, PermissionMode } from "../safety/permissions.js";

package/dist/os/public.js

@@ -1,6 +1,6 @@
 // `@deepstrike/sdk/os` — Agent-OS diagnostics, profiles, signal/permission machinery, replay-testing,
 // and the scheduler/quota/policy types referenced by advanced `RuntimeOptions` fields.
-export { DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, assertNativeProfile, osProfile, } from "../runtime/os-profile.js";
+export { DEFAULT_NATIVE_SIGNAL_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, assertNativeProfile, osProfile, } from "../runtime/os-profile.js";
 export { rebuildOsSnapshotFromSessionEvents } from "../runtime/os-snapshot.js";
 export { KernelPrimitivesDashboard } from "../runtime/kernel-primitives-dashboard.js";
 // Signals + SDK-side permissions.

package/dist/providers/base.d.ts

@@ -48,6 +48,11 @@ export declare function normalizeToolCall(id: string, name: string, args: unknow
     name: string;
     arguments: string;
 } | null;
+export declare class UnsupportedModalityError extends Error {
+    readonly modality: string;
+    readonly provider: string;
+    constructor(modality: string, provider: string);
+}
 export declare function toAnthropicContent(msg: Message): string | Array<Record<string, unknown>>;
 /**
  * History turns with the volatile State turn appended as the latest turn, for
@@ -63,6 +68,9 @@ export declare function turnsWithStateAppended(context: RenderedContext): Messag
 /** Convert RenderedContext.turns to Anthropic messages array.
  *  `turns` contains only user / assistant / tool roles — no system filtering needed. */
 export declare function toAnthropicMessages(turns: Message[], nativeReplay?: (message: Message) => Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
+/** Map an audio MIME type to OpenAI's `input_audio.format` (accepts "mp3" | "wav").
+ *  `audio/mpeg` must become "mp3", not the raw "mpeg" subtype. */
+export declare function openaiAudioFormat(mediaType: string | undefined): string;
 export declare function toOpenAIContent(msg: Message): string | Array<Record<string, unknown>>;
 /** Build the full OpenAI messages array from a RenderedContext.
  *  Prepends systemText as the first system message, then converts turns. */

package/dist/providers/gemini.js

@@ -2,6 +2,7 @@ import { GoogleGenerativeAI } from "@google/generative-ai";
 import { withServerRuntimeGuard } from "../runtime/server.js";
 import { CircuitBreaker, normalizeToolCall, turnsWithStateAppended } from "./base.js";
 import { endpointProfiles } from "./profiles.js";
+import { UnsupportedModalityError } from "./base.js";
 const GEMINI_BASE = endpointProfiles["gemini.google"].baseURL;
 const GEMINI_POLICIES = {
     "gemini-3-pro-preview": { maxTurns: 50 },
@@ -68,6 +69,17 @@ export function buildContents(turns) {
                     else if (p.url)
                         parts.push({ fileData: { mimeType: p.mediaType ?? "image/png", fileUri: p.url } });
                 }
+                else if (p.type === "audio") {
+                    if (!p.data)
+                        throw new UnsupportedModalityError("audio", "gemini");
+                    parts.push({ inlineData: { mimeType: p.mediaType ?? "audio/wav", data: p.data } });
+                }
+                else if (p.type === "tool_result") {
+                    // tool results are handled via functionResponse on tool role messages
+                }
+                else {
+                    throw new UnsupportedModalityError(String(p.type ?? "unknown"), "gemini");
+                }
             }
         }
         else if (msg.content) {

package/dist/providers/ollama.js

@@ -1,4 +1,4 @@
-import { normalizeToolCall, omitExtensionKeys, turnsWithStateAppended } from "./base.js";
+import { normalizeToolCall, omitExtensionKeys, turnsWithStateAppended, UnsupportedModalityError } from "./base.js";
 // Prefix-based policy for local models (first match wins)
 const OLLAMA_PREFIX_POLICIES = [
     ["deepseek-r1", { maxTurns: 40 }],
@@ -38,6 +38,8 @@ export class OllamaProvider {
                 for (const p of m.contentParts) {
                     if (p.type === "image" && p.data)
                         images.push(p.data);
+                    else if (p.type === "audio")
+                        throw new UnsupportedModalityError("audio", "ollama");
                 }
             }
             result.push({ role: m.role, content: m.content, ...(images.length ? { images } : {}) });

package/dist/providers/openai-responses.js

@@ -2,6 +2,7 @@ import OpenAI from "openai";
 import { withServerRuntimeGuard } from "../runtime/server.js";
 import { CircuitBreaker, omitExtensionKeys } from "./base.js";
 import { normalizeToolCall } from "./base.js";
+import { UnsupportedModalityError } from "./base.js";
 export class OpenAIResponsesAdapter {
     buildTools(tools) {
         return tools.map(t => ({
@@ -111,8 +112,10 @@ export class OpenAIResponsesAdapter {
                 continue;
             }
             if (part.type === "image") {
-                const imageUrl = part.url ?? (part.data && part.mediaType
-                    ? `data:${part.mediaType};base64,${part.data}`
+                // Default the MIME type (like every other serializer) so a data-only image is
+                // not silently dropped; only a part with neither url nor data yields undefined.
+                const imageUrl = part.url ?? (part.data
+                    ? `data:${part.mediaType ?? "image/png"};base64,${part.data}`
                     : undefined);
                 if (imageUrl)
                     content.push({
@@ -120,6 +123,10 @@ export class OpenAIResponsesAdapter {
                         detail: part.detail ?? "auto",
                         image_url: imageUrl,
                     });
+                continue;
+            }
+            if (part.type === "audio") {
+                throw new UnsupportedModalityError("audio", "openai-responses");
             }
         }
         return content;

package/dist/providers/profiles.d.ts

@@ -11,6 +11,8 @@ export interface ModelProfile {
     providerId: ProviderId;
     defaultEndpointId: string;
     contextWindow?: number;
+    /** Agent-message modalities the ContentPart → provider serializer path can deliver.
+     *  Do not advertise video/pdf until ContentPart gains those variants. */
     modalities: {
         input: Array<"text" | "image" | "audio" | "video" | "pdf">;
         output: Array<"text" | "embedding">;
@@ -1448,7 +1450,7 @@ export declare const modelProfiles: {
         readonly defaultEndpointId: "qwen.dashscope.multimodal-embeddings";
         readonly contextWindow: 32000;
         readonly modalities: {
-            readonly input: ["text", "image", "video"];
+            readonly input: ["text", "image"];
             readonly output: ["embedding"];
         };
         readonly tools: {
@@ -1465,7 +1467,7 @@ export declare const modelProfiles: {
         readonly defaultEndpointId: "qwen.dashscope.multimodal-embeddings";
         readonly contextWindow: 32000;
         readonly modalities: {
-            readonly input: ["text", "image", "video"];
+            readonly input: ["text", "image"];
             readonly output: ["embedding"];
         };
         readonly tools: {
@@ -1679,7 +1681,7 @@ export declare const modelProfiles: {
         readonly defaultEndpointId: "gemini.google.embeddings";
         readonly contextWindow: 8192;
         readonly modalities: {
-            readonly input: ["text", "image", "audio", "video", "pdf"];
+            readonly input: ["text", "image", "audio"];
             readonly output: ["embedding"];
         };
         readonly tools: {

package/dist/providers/profiles.js

@@ -605,13 +605,13 @@ export const modelProfiles = {
     "qwen/qwen3-vl-embedding": {
         id: "qwen/qwen3-vl-embedding", providerId: "qwen", defaultEndpointId: "qwen.dashscope.multimodal-embeddings",
         contextWindow: 32_000,
-        modalities: { input: ["text", "image", "video"], output: ["embedding"] },
+        modalities: { input: ["text", "image"], output: ["embedding"] },
         tools: { supported: false }, reasoning: { supported: false, preserveAcrossToolTurns: false },
     },
     "qwen/qwen2.5-vl-embedding": {
         id: "qwen/qwen2.5-vl-embedding", providerId: "qwen", defaultEndpointId: "qwen.dashscope.multimodal-embeddings",
         contextWindow: 32_000,
-        modalities: { input: ["text", "image", "video"], output: ["embedding"] },
+        modalities: { input: ["text", "image"], output: ["embedding"] },
         tools: { supported: false }, reasoning: { supported: false, preserveAcrossToolTurns: false },
     },
     // ── Gemini ─────────────────────────────────────────────────────────────────
@@ -687,7 +687,7 @@ export const modelProfiles = {
     "gemini/gemini-embedding-2": {
         id: "gemini/gemini-embedding-2", providerId: "gemini", defaultEndpointId: "gemini.google.embeddings",
         contextWindow: 8_192,
-        modalities: { input: ["text", "image", "audio", "video", "pdf"], output: ["embedding"] },
+        modalities: { input: ["text", "image", "audio"], output: ["embedding"] },
         tools: { supported: false }, reasoning: { supported: false, preserveAcrossToolTurns: false },
     },
     // ── GLM ────────────────────────────────────────────────────────────────────

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}`);
+    }
+}