@deepstrike/wasm 0.2.52 → 0.2.60

package/dist/memory/durable.js

@@ -0,0 +1,42 @@
+/** Binds host storage to the public durable Memory contract for one agent and namespace. */
+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(recordId) {
+        const record = await this.store.get(this.agentId, recordId);
+        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(recordId) {
+        if (await this.get(recordId) !== null)
+            await this.store.delete(this.agentId, recordId);
+    }
+}
+function sameScope(left, right) {
+    return left.tenant_id === right.tenant_id && left.namespace === right.namespace;
+}

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

@@ -1,27 +1,29 @@
 /**
- * `InMemoryDreamStore` — a lightweight `DreamStore` implementation backed by per-agent `Map`s.
+ * `InMemoryMemoryStore` — a lightweight `MemoryStore` 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 { DreamStore, MemoryQuery, MemoryRecall, MemoryRecallLifecycle, MemoryRecord, SessionData } from "./index.js";
-export interface InMemoryDreamStoreOptions {
+import type { MemoryStore, MemoryQuery, MemoryRecall, MemoryRecallLifecycle, MemoryRecord, SessionData } from "./index.js";
+export interface InMemoryMemoryStoreOptions {
     maxRecords?: number;
     staleWarningDays?: number;
     now?: () => number;
 }
-export declare class InMemoryDreamStore implements DreamStore {
+export declare class InMemoryMemoryStore implements MemoryStore {
     private readonly initialMemories;
     private memories;
     readonly savedSessions: SessionData[];
     private readonly maxRecords?;
     private readonly staleWarningDays;
     private readonly now;
-    constructor(initialMemories?: MemoryRecord[], options?: InMemoryDreamStoreOptions);
+    constructor(initialMemories?: MemoryRecord[], options?: InMemoryMemoryStoreOptions);
     private recordsFor;
     private evictToCapacity;
-    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>;
     search(agentId: string, query: MemoryQuery): Promise<MemoryRecall[]>;
     saveSession(data: SessionData): Promise<void>;
     recordRecall(agentId: string, recalls: MemoryRecallLifecycle[]): Promise<void>;

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();
     savedSessions = [];
@@ -34,7 +34,7 @@ export class InMemoryDreamStore {
         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) {
+    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
@@ -45,6 +45,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));
+    }
     async search(agentId, query) {
         const all = this.recordsFor(agentId);
         const candidates = all.filter(record => record.scope.tenant_id === query.scope.tenant_id

package/dist/memory/index.d.ts

@@ -72,8 +72,24 @@ export interface MemoryRecallLifecycle {
     recall_count: number;
     last_recalled_at: number;
 }
-export interface DreamStore {
-    upsert(agentId: string, record: MemoryRecord): Promise<void>;
+export interface MemorySearchOptions {
+    topK?: number;
+    kinds?: MemoryKind[];
+    minScore?: number;
+}
+/** Public durable memory bound to one agent and scope, distinct from `WorkingMemory`. */
+export interface Memory {
+    readonly namespace?: string;
+    search(query: string, options?: MemorySearchOptions): Promise<MemoryRecord[]>;
+    get(recordId: string): Promise<MemoryRecord | null>;
+    put(record: MemoryRecord): Promise<void>;
+    delete(recordId: 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 a completed session before the runner's one extraction pass. */
     saveSession(data: SessionData): Promise<void>;

package/dist/providers/anthropic.d.ts

@@ -6,6 +6,15 @@ export declare class AnthropicProvider implements LLMProvider {
     private nativeAssistantBlocks;
     constructor(apiKey: string, model?: string, maxTokens?: number);
     descriptor(): ProviderDescriptor;
+    requestPlanIdentity(): {
+        providerId: string;
+        modelId: string;
+        endpoint: {
+            id: string;
+            protocol: "anthropic-messages";
+            baseURL: string;
+        };
+    };
     peekProviderReplay(message: Pick<Message, "content" | "toolCalls">): ProviderReplay | undefined;
     seedProviderReplay(message: Pick<Message, "content" | "toolCalls">, replay: ProviderReplay): void;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;

package/dist/providers/anthropic.js

@@ -141,20 +141,21 @@ export class AnthropicProvider {
             },
         };
     }
+    requestPlanIdentity() {
+        return {
+            providerId: "anthropic",
+            modelId: this.model,
+            endpoint: { id: "anthropic.messages", protocol: "anthropic-messages", baseURL: "https://api.anthropic.com" },
+        };
+    }
     peekProviderReplay(message) {
         const blocks = this.nativeAssistantBlocks.get(assistantReplayKey(message));
-        return blocks?.length ? { native_blocks: blocks } : undefined;
+        return blocks?.length ? { protocol: "anthropic-messages", native_blocks: blocks } : undefined;
     }
     seedProviderReplay(message, replay) {
-        if (replay.native_blocks?.length) {
+        if (replay.protocol === "anthropic-messages" && replay.native_blocks?.length) {
             this.nativeAssistantBlocks.set(assistantReplayKey(message), replay.native_blocks);
-            return;
         }
-        // Legacy log without persisted native blocks: reconstruct neutral
-        // text + tool_use blocks so a tool-use turn can be replayed.
-        const blocks = reconstructAnthropicBlocks(message);
-        if (blocks.length)
-            this.nativeAssistantBlocks.set(assistantReplayKey(message), blocks);
     }
     async complete(context, tools, extensions) {
         return collectStreamMessage(this.stream(context, tools, extensions));
@@ -208,8 +209,9 @@ export class AnthropicProvider {
             body: JSON.stringify(body),
             ...(signal ? { signal } : {}), // #2-B-ii: a preempt aborts the in-flight request at the socket.
         });
-        if (!resp.ok)
-            throw new Error(`Anthropic ${resp.status}: ${await resp.text()}`);
+        if (!resp.ok) {
+            throw Object.assign(new Error(`Anthropic ${resp.status}: ${await resp.text()}`), { status: resp.status });
+        }
         const toolBlocks = {};
         const nativeBlocks = {};
         let finalText = "";
@@ -322,26 +324,3 @@ export class AnthropicProvider {
         this.nativeAssistantBlocks.set(assistantReplayKey(message), blocks);
     }
 }
-/**
- * Reconstruct Anthropic assistant content blocks from a neutral transcript when
- * no provider replay was persisted. Only meaningful for tool-use turns.
- */
-function reconstructAnthropicBlocks(message) {
-    const toolCalls = message.toolCalls ?? [];
-    if (!toolCalls.length)
-        return [];
-    const blocks = [];
-    if (message.content)
-        blocks.push({ type: "text", text: message.content });
-    for (const tc of toolCalls) {
-        let input = {};
-        try {
-            input = JSON.parse(tc.arguments || "{}");
-        }
-        catch {
-            input = {};
-        }
-        blocks.push({ type: "tool_use", id: tc.id, name: tc.name, input });
-    }
-    return blocks;
-}

package/dist/providers/content-policy.d.ts

@@ -0,0 +1,16 @@
+export type ContentPlacement = "message" | "tool_result";
+export type ContentDisposition = "native" | "bridge" | "unsupported";
+export type InputModality = "text" | "image" | "audio" | "video" | "file";
+/**
+ * Provider serialization policy for canonical content. A bridge preserves the deterministic
+ * visible text projection; it never permits a serializer to drop the block or replace it with
+ * empty content.
+ */
+export declare function contentDispositionFor(protocol: string, modality: InputModality, placement: ContentPlacement): ContentDisposition;
+export declare class ContentPolicyError extends Error {
+    readonly protocol: string;
+    readonly modality: InputModality;
+    readonly placement: ContentPlacement;
+    constructor(protocol: string, modality: InputModality, placement: ContentPlacement);
+}
+export declare function requireContentDisposition(protocol: string, modality: InputModality, placement: ContentPlacement): ContentDisposition;

package/dist/providers/content-policy.js

@@ -0,0 +1,39 @@
+/**
+ * Provider serialization policy for canonical content. A bridge preserves the deterministic
+ * visible text projection; it never permits a serializer to drop the block or replace it with
+ * empty content.
+ */
+export function contentDispositionFor(protocol, modality, placement) {
+    if (modality === "text" || modality === "image") {
+        if (protocol === "ollama-chat" && modality === "image" && placement === "tool_result")
+            return "bridge";
+        return "native";
+    }
+    if (protocol === "openai-responses" && modality === "file" && placement === "message")
+        return "native";
+    if (protocol === "openai-responses" && modality === "file" && placement === "tool_result")
+        return "bridge";
+    if (protocol === "openai-chat" && (modality === "audio" || modality === "file" || modality === "video"))
+        return "bridge";
+    if (protocol === "gemini" && (modality === "audio" || modality === "file" || modality === "video"))
+        return "bridge";
+    return "unsupported";
+}
+export class ContentPolicyError extends Error {
+    protocol;
+    modality;
+    placement;
+    constructor(protocol, modality, placement) {
+        super(`Unsupported content policy: ${modality} ${placement} is not supported by ${protocol}`);
+        this.protocol = protocol;
+        this.modality = modality;
+        this.placement = placement;
+        this.name = "ContentPolicyError";
+    }
+}
+export function requireContentDisposition(protocol, modality, placement) {
+    const disposition = contentDispositionFor(protocol, modality, placement);
+    if (disposition === "unsupported")
+        throw new ContentPolicyError(protocol, modality, placement);
+    return disposition;
+}

package/dist/providers/openai.d.ts

@@ -1,9 +1,38 @@
-import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, Message } from "../types.js";
+import type { RenderedContext, ToolSchema, StreamEvent, LLMProvider, Message, ProviderDescriptor } from "../types.js";
+type OpenAIProviderDialect = "openai" | "qwen" | "deepseek" | "minimax";
+export interface OpenAIProviderOptions {
+    apiKey: string;
+    model?: string;
+    baseURL?: string;
+    provider?: string;
+    endpointId?: string;
+    dialect?: OpenAIProviderDialect;
+}
+export interface BackendProviderOptions {
+    apiKey: string;
+    model?: string;
+    baseURL?: string;
+}
 export declare class OpenAIProvider implements LLMProvider {
     protected readonly apiKey: string;
     protected readonly model: string;
     protected readonly baseUrl: string;
-    constructor(apiKey: string, model?: string, baseUrl?: string);
+    private readonly provider;
+    private readonly endpoint;
+    private readonly dialect;
+    constructor(options: OpenAIProviderOptions);
+    protected providerId(): string;
+    protected endpointId(): string;
+    descriptor(): ProviderDescriptor;
+    requestPlanIdentity(): {
+        providerId: string;
+        modelId: string;
+        endpoint: {
+            id: string;
+            protocol: "openai-chat";
+            baseURL: string;
+        };
+    };
     protected buildTools(tools: ToolSchema[]): {
         type: string;
         function: {
@@ -16,18 +45,8 @@ export declare class OpenAIProvider implements LLMProvider {
     protected streamInner(context: RenderedContext, tools: ToolSchema[], extraBody: Record<string, unknown>, exposeReasoning?: boolean, signal?: AbortSignal): AsyncIterable<StreamEvent>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: unknown, signal?: AbortSignal): AsyncIterable<StreamEvent>;
 }
-export declare class QwenProvider extends OpenAIProvider {
-    constructor(apiKey: string, model?: string);
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: unknown, signal?: AbortSignal): AsyncIterable<StreamEvent>;
-}
-export declare class DeepSeekProvider extends OpenAIProvider {
-    constructor(apiKey: string, model?: string);
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: unknown, signal?: AbortSignal): AsyncIterable<StreamEvent>;
-}
-export declare class MiniMaxProvider extends OpenAIProvider {
-    constructor(apiKey: string, model?: string);
-    stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>, _state?: unknown, signal?: AbortSignal): AsyncIterable<StreamEvent>;
-}
-export declare class KimiProvider extends OpenAIProvider {
-    constructor(apiKey: string, model?: string);
-}
+export declare function qwen(options: BackendProviderOptions): LLMProvider;
+export declare function deepseek(options: BackendProviderOptions): LLMProvider;
+export declare function minimax(options: BackendProviderOptions): LLMProvider;
+export declare function kimi(options: BackendProviderOptions): LLMProvider;
+export {};

package/dist/providers/openai.js

@@ -6,10 +6,35 @@ export class OpenAIProvider {
     apiKey;
     model;
     baseUrl;
-    constructor(apiKey, model = "gpt-4o", baseUrl = "https://api.openai.com/v1") {
-        this.apiKey = apiKey;
-        this.model = model;
-        this.baseUrl = baseUrl;
+    provider;
+    endpoint;
+    dialect;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.model = options.model ?? "gpt-4o";
+        this.baseUrl = options.baseURL ?? "https://api.openai.com/v1";
+        this.provider = options.provider ?? "openai";
+        this.endpoint = options.endpointId ?? "openai.chat";
+        this.dialect = options.dialect ?? "openai";
+    }
+    providerId() { return this.provider; }
+    endpointId() { return this.endpoint; }
+    descriptor() {
+        const reasoning = DEEPSEEK_REASONERS.has(this.model) || MINIMAX_REASONERS.has(this.model);
+        return {
+            provider: this.providerId(),
+            protocol: "openai-chat",
+            model: this.model,
+            reasoning: { supported: reasoning, preserveAcrossToolTurns: reasoning },
+            toolCalls: { supported: true, requiresStrictPairing: true },
+        };
+    }
+    requestPlanIdentity() {
+        return {
+            providerId: this.providerId(),
+            modelId: this.model,
+            endpoint: { id: this.endpointId(), protocol: "openai-chat", baseURL: this.baseUrl },
+        };
     }
     buildTools(tools) {
         return tools.map(t => ({ type: "function", function: { name: t.name, description: t.description, parameters: JSON.parse(t.parameters) } }));
@@ -31,8 +56,9 @@ export class OpenAIProvider {
             body: JSON.stringify(body),
             ...(signal ? { signal } : {}), // #2-B-ii: a preempt aborts the in-flight request at the socket.
         });
-        if (!resp.ok)
-            throw new Error(`OpenAI ${resp.status}: ${await resp.text()}`);
+        if (!resp.ok) {
+            throw Object.assign(new Error(`OpenAI ${resp.status}: ${await resp.text()}`), { status: resp.status });
+        }
         const toolAccum = {};
         const reader = resp.body.getReader();
         const decoder = new TextDecoder();
@@ -91,51 +117,65 @@ export class OpenAIProvider {
         }
     }
     async *stream(context, tools, extensions, _state, signal) {
+        if (this.dialect === "qwen") {
+            const enableThinking = Boolean(extensions?.enableThinking);
+            const thinkingBudget = extensions?.thinkingBudget;
+            const { enableThinking: _, thinkingBudget: __, expose_reasoning: ___, exposeReasoning: ____, ...passthrough } = extensions ?? {};
+            yield* this.streamInner(context, tools, {
+                ...passthrough,
+                ...(enableThinking ? { enable_thinking: true, ...(thinkingBudget ? { thinking_budget: thinkingBudget } : {}) } : {}),
+            }, enableThinking, signal);
+            return;
+        }
+        if (this.dialect === "deepseek" || this.dialect === "minimax") {
+            const exposeReasoning = Boolean(extensions?.exposeReasoning);
+            const isReasoner = this.dialect === "deepseek"
+                ? DEEPSEEK_REASONERS.has(this.model)
+                : MINIMAX_REASONERS.has(this.model);
+            const { exposeReasoning: _, expose_reasoning: __, ...passthrough } = extensions ?? {};
+            yield* this.streamInner(context, isReasoner ? [] : tools, passthrough, exposeReasoning, signal);
+            return;
+        }
         const { expose_reasoning: _, exposeReasoning: __, ...passthrough } = extensions ?? {};
         yield* this.streamInner(context, tools, passthrough, false, signal);
     }
 }
-export class QwenProvider extends OpenAIProvider {
-    constructor(apiKey, model = "qwen-max") {
-        super(apiKey, model, "https://dashscope.aliyuncs.com/compatible-mode/v1");
-    }
-    async *stream(context, tools, extensions, _state, signal) {
-        const enableThinking = Boolean(extensions?.enableThinking);
-        const thinkingBudget = extensions?.thinkingBudget;
-        const { enableThinking: _, thinkingBudget: __, expose_reasoning: ___, exposeReasoning: ____, ...passthrough } = extensions ?? {};
-        const extra = {
-            ...passthrough,
-            ...(enableThinking ? { enable_thinking: true, ...(thinkingBudget ? { thinking_budget: thinkingBudget } : {}) } : {}),
-        };
-        yield* this.streamInner(context, tools, extra, enableThinking, signal);
-    }
+export function qwen(options) {
+    return new OpenAIProvider({
+        ...options,
+        model: options.model ?? "qwen-max",
+        baseURL: options.baseURL ?? "https://dashscope.aliyuncs.com/compatible-mode/v1",
+        provider: "qwen",
+        endpointId: "qwen.dashscope",
+        dialect: "qwen",
+    });
 }
-export class DeepSeekProvider extends OpenAIProvider {
-    constructor(apiKey, model = "deepseek-chat") {
-        super(apiKey, model, "https://api.deepseek.com/v1");
-    }
-    async *stream(context, tools, extensions, _state, signal) {
-        const exposeReasoning = Boolean(extensions?.exposeReasoning);
-        const isReasoner = DEEPSEEK_REASONERS.has(this.model);
-        const filteredTools = isReasoner ? [] : tools;
-        const { exposeReasoning: _, expose_reasoning: __, ...passthrough } = extensions ?? {};
-        yield* this.streamInner(context, filteredTools, passthrough, exposeReasoning, signal);
-    }
+export function deepseek(options) {
+    return new OpenAIProvider({
+        ...options,
+        model: options.model ?? "deepseek-chat",
+        baseURL: options.baseURL ?? "https://api.deepseek.com/v1",
+        provider: "deepseek",
+        endpointId: "deepseek.openai",
+        dialect: "deepseek",
+    });
 }
-export class MiniMaxProvider extends OpenAIProvider {
-    constructor(apiKey, model = "MiniMax-Text-01") {
-        super(apiKey, model, "https://api.minimax.chat/v1");
-    }
-    async *stream(context, tools, extensions, _state, signal) {
-        const exposeReasoning = Boolean(extensions?.exposeReasoning);
-        const isReasoner = MINIMAX_REASONERS.has(this.model);
-        const filteredTools = isReasoner ? [] : tools;
-        const { exposeReasoning: _, expose_reasoning: __, ...passthrough } = extensions ?? {};
-        yield* this.streamInner(context, filteredTools, passthrough, exposeReasoning, signal);
-    }
+export function minimax(options) {
+    return new OpenAIProvider({
+        ...options,
+        model: options.model ?? "MiniMax-Text-01",
+        baseURL: options.baseURL ?? "https://api.minimax.chat/v1",
+        provider: "minimax",
+        endpointId: "minimax.openai",
+        dialect: "minimax",
+    });
 }
-export class KimiProvider extends OpenAIProvider {
-    constructor(apiKey, model = "moonshot-v1-8k") {
-        super(apiKey, model, "https://api.moonshot.cn/v1");
-    }
+export function kimi(options) {
+    return new OpenAIProvider({
+        ...options,
+        model: options.model ?? "moonshot-v1-8k",
+        baseURL: options.baseURL ?? "https://api.moonshot.cn/v1",
+        provider: "kimi",
+        endpointId: "kimi.openai",
+    });
 }

package/dist/providers/provider-error.d.ts

@@ -0,0 +1,22 @@
+export type ProviderErrorKind = "transport" | "auth" | "rate_limit" | "context_overflow" | "invalid_request" | "modality" | "model_unavailable" | "protocol" | "unknown";
+export interface ProviderErrorOptions {
+    provider: string;
+    kind: ProviderErrorKind;
+    retryable: boolean;
+    message: string;
+    httpStatus?: number;
+    providerCode?: string;
+    cause?: unknown;
+}
+/** The only provider-failure shape allowed across the runner/kernel boundary. */
+export declare class ProviderError extends Error {
+    readonly provider: string;
+    readonly kind: ProviderErrorKind;
+    readonly retryable: boolean;
+    readonly httpStatus?: number;
+    readonly providerCode?: string;
+    readonly cause: unknown;
+    constructor(options: ProviderErrorOptions);
+}
+export declare function classifyProviderError(provider: string, error: unknown): ProviderError;
+export declare function providerErrorEventFields(error: ProviderError): Record<string, unknown>;

package/dist/providers/provider-error.js

@@ -0,0 +1,90 @@
+/** The only provider-failure shape allowed across the runner/kernel boundary. */
+export class ProviderError extends Error {
+    provider;
+    kind;
+    retryable;
+    httpStatus;
+    providerCode;
+    cause;
+    constructor(options) {
+        super(options.message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = "ProviderError";
+        this.provider = options.provider;
+        this.kind = options.kind;
+        this.retryable = options.retryable;
+        this.httpStatus = options.httpStatus;
+        this.providerCode = options.providerCode;
+        this.cause = options.cause;
+    }
+}
+const CONTEXT_OVERFLOW_CODES = new Set(["context_length_exceeded", "prompt_too_long"]);
+const NETWORK_CODES = new Set(["ECONNABORTED", "ECONNREFUSED", "ECONNRESET", "EHOSTUNREACH", "ENETUNREACH", "ETIMEDOUT"]);
+function object(value) {
+    return value && typeof value === "object" ? value : undefined;
+}
+function scalarString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function scalarStatus(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599 ? value : undefined;
+}
+function status(error) {
+    const outer = object(error);
+    const response = object(outer?.response);
+    return scalarStatus(outer?.httpStatus) ?? scalarStatus(outer?.status) ?? scalarStatus(response?.status);
+}
+function code(error) {
+    const outer = object(error);
+    const nested = object(outer?.error);
+    const bodyError = object(object(outer?.body)?.error);
+    return scalarString(outer?.providerCode)
+        ?? scalarString(outer?.code)
+        ?? scalarString(outer?.error_code)
+        ?? scalarString(nested?.code)
+        ?? scalarString(nested?.error_code)
+        ?? scalarString(bodyError?.code)
+        ?? scalarString(bodyError?.error_code);
+}
+function kind(error, httpStatus, providerCode) {
+    if (httpStatus === 413 || (providerCode && CONTEXT_OVERFLOW_CODES.has(providerCode.toLowerCase())))
+        return "context_overflow";
+    if (httpStatus === 401 || httpStatus === 403)
+        return "auth";
+    if (httpStatus === 429)
+        return "rate_limit";
+    if (providerCode === "model_not_found" || httpStatus === 404 || (httpStatus !== undefined && httpStatus >= 500))
+        return "model_unavailable";
+    if (httpStatus === 408 || httpStatus === 409)
+        return "transport";
+    if (httpStatus === 400 || httpStatus === 422)
+        return "invalid_request";
+    if (providerCode && NETWORK_CODES.has(providerCode.toUpperCase()))
+        return "transport";
+    if (error instanceof TypeError && httpStatus === undefined)
+        return "transport";
+    return "unknown";
+}
+export function classifyProviderError(provider, error) {
+    if (error instanceof ProviderError)
+        return error;
+    const httpStatus = status(error);
+    const providerCode = code(error);
+    const classified = kind(error, httpStatus, providerCode);
+    return new ProviderError({
+        provider,
+        kind: classified,
+        retryable: classified === "transport" || classified === "rate_limit" || classified === "model_unavailable",
+        message: error instanceof Error && error.message ? error.message : typeof error === "string" ? error : "Provider request failed",
+        ...(httpStatus !== undefined ? { httpStatus } : {}),
+        ...(providerCode !== undefined ? { providerCode } : {}),
+        cause: error,
+    });
+}
+export function providerErrorEventFields(error) {
+    return {
+        error_kind: error.kind,
+        retryable: error.retryable,
+        ...(error.httpStatus !== undefined ? { http_status: error.httpStatus } : {}),
+        ...(error.providerCode !== undefined ? { provider_code: error.providerCode } : {}),
+    };
+}