@deepstrike/sdk 0.2.51 → 0.2.60

package/dist/providers/ollama-adapter.js

@@ -0,0 +1,188 @@
+import { projectToolOutputToText } from "./content-normalization.js";
+import { normalizeToolCall } from "./base.js";
+import { ProtocolResponseError, OLLAMA_PROTOCOL_CAPABILITIES, } from "./protocol-adapter.js";
+function messageContent(message) {
+    const text = [];
+    const images = [];
+    for (const item of message.blocks) {
+        if (item.type === "tool_result") {
+            text.push(projectToolOutputToText(item.blocks));
+        }
+        else if (item.type === "text") {
+            text.push(item.text);
+        }
+        else if (item.type === "image" && item.source.kind === "base64") {
+            images.push(item.source.data);
+            text.push("[image]");
+        }
+        else {
+            throw new ProtocolResponseError("ollama-chat", `cannot serialize ${item.type}`);
+        }
+    }
+    return {
+        role: message.role,
+        content: text.join("\n"),
+        ...(images.length ? { images } : {}),
+    };
+}
+function requestExtensions(extensions) {
+    const blocked = new Set([
+        "model",
+        "messages",
+        "tools",
+        "stream",
+        "__deepstrikeThinkingEnabled",
+        "degradeMissingReasoningReplay",
+    ]);
+    return Object.fromEntries(Object.entries(extensions).filter(([key]) => !blocked.has(key)));
+}
+function validCount(raw, field) {
+    const value = raw[field];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+        throw new ProtocolResponseError("ollama-chat", `${field} must be a non-negative finite number`);
+    }
+    return value;
+}
+export class OllamaNdjsonDecoder {
+    buffer = "";
+    push(text) {
+        this.buffer += text;
+        const lines = this.buffer.split("\n");
+        this.buffer = lines.pop() ?? "";
+        return this.parse(lines);
+    }
+    finish(text = "") {
+        this.buffer += text;
+        const tail = this.buffer;
+        this.buffer = "";
+        return this.parse(tail ? [tail] : []);
+    }
+    parse(lines) {
+        const chunks = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const value = JSON.parse(line);
+                if (value && typeof value === "object" && !Array.isArray(value)) {
+                    chunks.push(value);
+                }
+            }
+            catch {
+                // Preserve the established Ollama behavior: malformed complete lines are skipped.
+            }
+        }
+        return chunks;
+    }
+}
+export class OllamaAdapter {
+    protocol = "ollama-chat";
+    protocolCapabilities = OLLAMA_PROTOCOL_CAPABILITIES;
+    buildRequest(input) {
+        const messages = [];
+        if (input.context.systemText) {
+            messages.push({ role: "system", content: input.context.systemText });
+        }
+        const turns = input.context.stateTurn
+            ? [...input.context.turns, input.context.stateTurn]
+            : input.context.turns;
+        messages.push(...turns.map(messageContent));
+        return {
+            ...requestExtensions(input.extensions),
+            model: input.resolved.identity.modelId,
+            messages,
+            ...(input.tools.length ? {
+                tools: input.tools.map(tool => ({
+                    type: "function",
+                    function: {
+                        name: tool.name,
+                        description: tool.description,
+                        parameters: JSON.parse(tool.parameters),
+                    },
+                })),
+            } : {}),
+        };
+    }
+    decodeComplete(raw, _input) {
+        return {
+            message: {
+                role: "assistant",
+                content: raw.message?.content ?? "",
+            },
+        };
+    }
+    createStreamState(input) {
+        return { input: input.input, pendingToolCalls: new Map() };
+    }
+    pushStreamChunk(chunk, state) {
+        const events = [];
+        if (chunk.message?.content) {
+            events.push({ type: "text_delta", delta: chunk.message.content });
+        }
+        for (const call of chunk.message?.tool_calls ?? []) {
+            const normalized = normalizeToolCall("", call.function.name, call.function.arguments);
+            if (!normalized)
+                continue;
+            const key = `${normalized.name}:${normalized.arguments}`;
+            if (!state.pendingToolCalls.has(key)) {
+                state.pendingToolCalls.set(key, {
+                    id: `call_${state.pendingToolCalls.size + 1}`,
+                    name: normalized.name,
+                    arguments: JSON.parse(normalized.arguments),
+                });
+            }
+        }
+        if (chunk.done)
+            state.finalChunk = chunk;
+        return { events };
+    }
+    finishStream(state, final) {
+        const terminal = final ?? state.finalChunk;
+        const events = Array.from(state.pendingToolCalls.values(), call => ({ type: "tool_call", ...call }));
+        const usage = this.normalizeUsage(terminal);
+        if (usage) {
+            const rawStopReason = terminal?.done_reason;
+            const stopReason = this.normalizeStopReason(rawStopReason);
+            events.push({
+                type: "usage",
+                totalTokens: usage.inputTokens + usage.outputTokens,
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                providerUsage: usage,
+                ...(stopReason ? { stopReason } : {}),
+                ...(rawStopReason ? { rawStopReason } : {}),
+            });
+        }
+        return { events };
+    }
+    normalizeUsage(raw) {
+        if (raw === undefined || raw === null)
+            return undefined;
+        if (typeof raw !== "object" || Array.isArray(raw)) {
+            throw new ProtocolResponseError("ollama-chat", "usage source must be an object");
+        }
+        const record = raw;
+        const inputTokens = validCount(record, "prompt_eval_count");
+        const outputTokens = validCount(record, "eval_count");
+        if (inputTokens === undefined && outputTokens === undefined)
+            return undefined;
+        return {
+            inputTokens: inputTokens ?? 0,
+            outputTokens: outputTokens ?? 0,
+        };
+    }
+    normalizeStopReason(raw) {
+        if (raw === undefined)
+            return undefined;
+        switch (raw) {
+            case "stop": return "end_turn";
+            case "length": return "max_tokens";
+            default: return "other";
+        }
+    }
+    createNdjsonDecoder() {
+        return new OllamaNdjsonDecoder();
+    }
+}

package/dist/providers/ollama.d.ts

@@ -1,12 +1,17 @@
 import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+import { type CanonicalAdapterInput } from "./content-normalization.js";
+type ResolvedOllamaRuntime = CanonicalAdapterInput["resolved"];
 export declare class OllamaProvider implements LLMProvider {
     private readonly model;
     private readonly baseUrl;
-    constructor(model?: string, baseUrl?: string);
+    private readonly resolvedRuntimePolicy;
+    private resolvedRuntime?;
+    private readonly adapter;
+    constructor(model?: string, baseUrl?: string, resolvedRuntimePolicy?: RuntimePolicy, resolvedRuntime?: ResolvedOllamaRuntime | undefined);
     runtimePolicy(): RuntimePolicy;
-    private toOllamaMessages;
-    private buildTools;
-    private requestExtensions;
+    bindResolvedRuntime(resolved: ResolvedOllamaRuntime): void;
+    private adapterInput;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
 }
+export {};

package/dist/providers/ollama.js

@@ -1,129 +1,116 @@
-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 }],
-    ["qwq", { maxTurns: 35 }],
-    ["llama3.3", { maxTurns: 25 }],
-    ["llama3.2", { maxTurns: 20 }],
-    ["llama3.1", { maxTurns: 20 }],
-    ["llama3", { maxTurns: 20 }],
-    ["mistral", { maxTurns: 20 }],
-    ["gemma2", { maxTurns: 20 }],
-    ["phi4", { maxTurns: 20 }],
-    ["phi3", { maxTurns: 15 }],
-    ["codellama", { maxTurns: 20 }],
-];
+import { normalizeCanonicalAdapterInput, } from "./content-normalization.js";
+import { endpointProfiles } from "./endpoints.js";
+import { OllamaAdapter } from "./ollama-adapter.js";
+import { classifyProviderError, ProviderError } from "./provider-error.js";
 export class OllamaProvider {
     model;
     baseUrl;
-    constructor(model = "llama3", baseUrl = "http://localhost:11434") {
+    resolvedRuntimePolicy;
+    resolvedRuntime;
+    adapter = new OllamaAdapter();
+    constructor(model = "llama3", baseUrl = "http://localhost:11434", resolvedRuntimePolicy = {}, resolvedRuntime) {
         this.model = model;
         this.baseUrl = baseUrl;
+        this.resolvedRuntimePolicy = resolvedRuntimePolicy;
+        this.resolvedRuntime = resolvedRuntime;
     }
     runtimePolicy() {
-        const m = this.model.toLowerCase();
-        for (const [prefix, policy] of OLLAMA_PREFIX_POLICIES) {
-            if (m.startsWith(prefix))
-                return policy;
-        }
-        return { maxTurns: 20 };
+        return this.resolvedRuntimePolicy;
     }
-    toOllamaMessages(context) {
-        const result = [];
-        if (context.systemText)
-            result.push({ role: "system", content: context.systemText });
-        for (const m of turnsWithStateAppended(context)) {
-            const images = [];
-            if (m.contentParts?.length) {
-                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 } : {}) });
+    bindResolvedRuntime(resolved) {
+        if (resolved.identity.protocol !== "ollama-chat"
+            || resolved.identity.modelId !== this.model) {
+            throw new Error("OllamaProvider received a mismatched resolved runtime");
         }
-        return result;
+        this.resolvedRuntime = resolved;
     }
-    buildTools(tools) {
-        return tools.map(t => ({
-            type: "function",
-            function: { name: t.name, description: t.description, parameters: JSON.parse(t.parameters) },
-        }));
-    }
-    requestExtensions(extensions) {
-        return omitExtensionKeys(extensions, ["model", "messages", "tools", "stream"]);
+    adapterInput(context, tools, extensions) {
+        const resolved = this.resolvedRuntime ?? {
+            identity: {
+                providerId: "ollama",
+                modelId: this.model,
+                endpointId: "ollama.local",
+                protocol: "ollama-chat",
+            },
+            model: { id: `ollama/${this.model}`, providerId: "ollama", kind: "generation", intrinsic: {} },
+            endpoint: endpointProfiles["ollama.local"],
+            adapter: this,
+            effectiveCapabilities: {
+                inputModalities: Object.fromEntries(["text", "image", "audio", "video", "file"].map(modality => [modality, { state: modality === "audio" || modality === "video" || modality === "file" ? "unsupported" : "unknown", evidence: [] }])),
+                outputModalities: Object.fromEntries(["text", "image", "audio", "embedding"].map(modality => [modality, { state: "unknown", evidence: [] }])),
+                tools: { state: "unknown", evidence: [] },
+                reasoning: { state: "unknown", evidence: [] },
+                parallelToolCalls: { state: "unknown", evidence: [] },
+                structuredOutput: { state: "unknown", evidence: [] },
+                promptCaching: { state: "unknown", evidence: [] },
+                nativeTokenCounting: { state: "unknown", evidence: [] },
+                mediaForms: Object.fromEntries(["imageUrl", "imageBase64", "fileId", "audioUrl", "audioBase64"].map(form => [form, { state: "unknown", evidence: [] }])),
+            },
+        };
+        return normalizeCanonicalAdapterInput({ context, tools, resolved, extensions });
     }
     async complete(context, tools, extensions) {
-        const resp = await fetch(`${this.baseUrl}/api/chat`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                ...this.requestExtensions(extensions),
-                model: this.model,
-                messages: this.toOllamaMessages(context),
-                ...(tools.length ? { tools: this.buildTools(tools) } : {}),
-                stream: false,
-            }),
-        });
-        if (!resp.ok)
-            throw new Error(`Ollama error: ${resp.status}`);
-        const data = await resp.json();
-        return { role: "assistant", content: data.message.content };
+        try {
+            const input = this.adapterInput(context, tools, extensions);
+            const body = { ...this.adapter.buildRequest(input), stream: false };
+            const resp = await fetch(`${this.baseUrl}/api/chat`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            if (!resp.ok)
+                throw ollamaHttpError(resp.status);
+            const data = await resp.json();
+            return this.adapter.decodeComplete(data, { input }).message;
+        }
+        catch (error) {
+            throw classifyProviderError("ollama", error);
+        }
     }
     async *stream(context, tools, extensions) {
-        const resp = await fetch(`${this.baseUrl}/api/chat`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                ...this.requestExtensions(extensions),
-                model: this.model,
-                messages: this.toOllamaMessages(context),
-                ...(tools.length ? { tools: this.buildTools(tools) } : {}),
-                stream: true,
-            }),
-        });
-        if (!resp.ok)
-            throw new Error(`Ollama error: ${resp.status}`);
-        const reader = resp.body.getReader();
-        const decoder = new TextDecoder();
-        let buf = "";
-        const pendingToolCalls = new Map();
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buf += decoder.decode(value, { stream: true });
-            const lines = buf.split("\n");
-            buf = lines.pop() ?? "";
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                try {
-                    const chunk = JSON.parse(line);
-                    if (chunk.message?.content)
-                        yield { type: "text_delta", delta: chunk.message.content };
-                    for (const tc of chunk.message?.tool_calls ?? []) {
-                        const norm = normalizeToolCall("", tc.function.name, tc.function.arguments);
-                        if (!norm)
-                            continue;
-                        const args = JSON.parse(norm.arguments);
-                        const key = `${norm.name}:${norm.arguments}`;
-                        if (!pendingToolCalls.has(key)) {
-                            pendingToolCalls.set(key, {
-                                id: `call_${pendingToolCalls.size + 1}`,
-                                name: norm.name,
-                                arguments: args,
-                            });
-                        }
-                    }
+        try {
+            const input = this.adapterInput(context, tools, extensions);
+            const body = { ...this.adapter.buildRequest(input), stream: true };
+            const resp = await fetch(`${this.baseUrl}/api/chat`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            if (!resp.ok)
+                throw ollamaHttpError(resp.status);
+            if (!resp.body) {
+                throw new ProviderError({
+                    provider: "ollama",
+                    kind: "protocol",
+                    retryable: false,
+                    message: "Ollama stream response has no body",
+                });
+            }
+            const reader = resp.body.getReader();
+            const decoder = new TextDecoder();
+            const ndjson = this.adapter.createNdjsonDecoder();
+            const state = this.adapter.createStreamState({ input });
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                for (const chunk of ndjson.push(decoder.decode(value, { stream: true }))) {
+                    for (const event of this.adapter.pushStreamChunk(chunk, state).events)
+                        yield event;
                 }
-                catch { /* skip malformed lines */ }
             }
+            for (const chunk of ndjson.finish(decoder.decode())) {
+                for (const event of this.adapter.pushStreamChunk(chunk, state).events)
+                    yield event;
+            }
+            for (const event of this.adapter.finishStream(state, state.finalChunk).events)
+                yield event;
         }
-        for (const tc of pendingToolCalls.values()) {
-            yield { type: "tool_call", id: tc.id, name: tc.name, arguments: tc.arguments };
+        catch (error) {
+            throw classifyProviderError("ollama", error);
         }
     }
 }
+function ollamaHttpError(status) {
+    return classifyProviderError("ollama", Object.assign(new Error(`Ollama error: ${status}`), { status }));
+}

package/dist/providers/openai-chat-dialects.d.ts

@@ -0,0 +1,154 @@
+import type { ProviderDescriptor, ProviderReplay, ToolCall } from "../types.js";
+import type { EndpointProfileId, ProviderId } from "./endpoints.js";
+export interface OpenAIChatTurnReasoning {
+    reasoningContent: string;
+    reasoningDetails?: unknown;
+    nativeToolCalls: unknown[];
+}
+export type OpenAIChatReplayStrategy = "none" | "generic_stream" | "deepseek" | "minimax";
+export interface OpenAIChatWireDialect {
+    readonly id: string;
+    readonly providerId: ProviderId;
+    readonly endpointId: EndpointProfileId;
+    readonly descriptor: {
+        reasoning: ProviderDescriptor["reasoning"];
+    };
+    readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+    readonly serverTools?: (extensions: Readonly<Record<string, unknown>>) => unknown[];
+    readonly cacheKey: "openai" | "none";
+    readonly inlineThinkingTags: boolean;
+    readonly exposeReasoning: (extensions: Readonly<Record<string, unknown>>) => boolean;
+    readonly requireReasoningReplay: (extensions: Readonly<Record<string, unknown>>) => boolean;
+    readonly replay: OpenAIChatReplayStrategy;
+}
+export declare const openAIChatDialects: {
+    readonly openai: {
+        readonly id: "openai";
+        readonly providerId: "openai";
+        readonly endpointId: "openai.chat";
+        readonly descriptor: {
+            readonly reasoning: {
+                supported: boolean;
+                preserveAcrossToolTurns: boolean;
+                requiresReplayForToolTurns?: boolean;
+            };
+        };
+        readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+        readonly cacheKey: "openai";
+        readonly inlineThinkingTags: true;
+        readonly exposeReasoning: () => boolean;
+        readonly requireReasoningReplay: () => boolean;
+        readonly replay: "generic_stream";
+    };
+    readonly deepseek: {
+        readonly id: "deepseek";
+        readonly providerId: "deepseek";
+        readonly endpointId: "deepseek.openai";
+        readonly descriptor: {
+            readonly reasoning: {
+                supported: boolean;
+                preserveAcrossToolTurns: boolean;
+                requiresReplayForToolTurns?: boolean;
+            };
+        };
+        readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => {
+            __deepstrikeThinkingEnabled: boolean;
+            reasoning_effort: string;
+            extra_body: {
+                thinking: {
+                    type: string;
+                };
+            };
+            degradeMissingReasoningReplay?: boolean | undefined;
+        };
+        readonly cacheKey: "none";
+        readonly inlineThinkingTags: false;
+        readonly exposeReasoning: (extensions: Readonly<Record<string, unknown>>) => boolean;
+        readonly requireReasoningReplay: (extensions: Readonly<Record<string, unknown>>) => boolean;
+        readonly replay: "deepseek";
+    };
+    readonly kimi: {
+        readonly id: "kimi";
+        readonly providerId: "kimi";
+        readonly endpointId: "kimi.openai";
+        readonly descriptor: {
+            readonly reasoning: {
+                supported: boolean;
+                preserveAcrossToolTurns: boolean;
+                requiresReplayForToolTurns?: boolean;
+            };
+        };
+        readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+        readonly cacheKey: "openai";
+        readonly inlineThinkingTags: true;
+        readonly exposeReasoning: () => boolean;
+        readonly requireReasoningReplay: () => boolean;
+        readonly replay: "generic_stream";
+    };
+    readonly qwen: {
+        readonly id: "qwen";
+        readonly providerId: "qwen";
+        readonly endpointId: "qwen.dashscope";
+        readonly descriptor: {
+            readonly reasoning: {
+                supported: boolean;
+                preserveAcrossToolTurns: boolean;
+                requiresReplayForToolTurns?: boolean;
+            };
+        };
+        readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => {
+            extra_body?: Record<string, unknown> | undefined;
+        };
+        readonly cacheKey: "none";
+        readonly inlineThinkingTags: false;
+        readonly exposeReasoning: () => boolean;
+        readonly requireReasoningReplay: () => boolean;
+        readonly replay: "generic_stream";
+    };
+    readonly glm: {
+        readonly id: "glm";
+        readonly providerId: "glm";
+        readonly endpointId: "glm.openai";
+        readonly descriptor: {
+            readonly reasoning: {
+                supported: boolean;
+                preserveAcrossToolTurns: boolean;
+                requiresReplayForToolTurns?: boolean;
+            };
+        };
+        readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => Record<string, unknown>;
+        readonly serverTools: (extensions: Readonly<Record<string, unknown>>) => {
+            type: string;
+            web_search: object;
+        }[];
+        readonly cacheKey: "openai";
+        readonly inlineThinkingTags: true;
+        readonly exposeReasoning: () => boolean;
+        readonly requireReasoningReplay: () => boolean;
+        readonly replay: "generic_stream";
+    };
+    readonly minimax: {
+        readonly id: "minimax";
+        readonly providerId: "minimax";
+        readonly endpointId: "minimax.openai";
+        readonly descriptor: {
+            readonly reasoning: {
+                supported: boolean;
+                preserveAcrossToolTurns: boolean;
+                requiresReplayForToolTurns?: boolean;
+            };
+        };
+        readonly prepareExtensions: (extensions: Readonly<Record<string, unknown>>) => {
+            __deepstrikeThinkingEnabled: boolean;
+            reasoning_split: boolean;
+            degradeMissingReasoningReplay?: boolean | undefined;
+        };
+        readonly cacheKey: "none";
+        readonly inlineThinkingTags: false;
+        readonly exposeReasoning: (extensions: Readonly<Record<string, unknown>>) => boolean;
+        readonly requireReasoningReplay: (extensions: Readonly<Record<string, unknown>>) => boolean;
+        readonly replay: "minimax";
+    };
+};
+export type OpenAIChatDialectId = keyof typeof openAIChatDialects;
+export declare function replayForTurn(dialect: OpenAIChatWireDialect, phase: "complete" | "stream", model: string, content: string, toolCalls: ToolCall[], reasoning: OpenAIChatTurnReasoning): ProviderReplay | undefined;