@deepstrike/sdk 0.2.52 → 0.2.61

package/dist/providers/model-registry.js

@@ -0,0 +1,379 @@
+import { endpointProfiles, } from "./endpoints.js";
+import { ANTHROPIC_PROTOCOL_CAPABILITIES, GEMINI_PROTOCOL_CAPABILITIES, OLLAMA_PROTOCOL_CAPABILITIES, OPENAI_CHAT_PROTOCOL_CAPABILITIES, OPENAI_RESPONSES_PROTOCOL_CAPABILITIES, } from "./protocol-capabilities.js";
+export const MODEL_CAPABILITY_STATES = [
+    "supported",
+    "unsupported",
+    "unknown",
+];
+export const registryEvidence = [
+    {
+        ruleId: "provider-prefix-routing",
+        classification: "routing",
+        source: "node/tests/model-registry.test.ts",
+        verifiedAt: "2026-08-12",
+    },
+    {
+        ruleId: "runtime-policy-resolution",
+        classification: "policy",
+        source: "node/tests/model-registry.test.ts",
+        verifiedAt: "2026-08-12",
+    },
+    {
+        ruleId: "protocol-wire-capabilities",
+        classification: "protocol",
+        source: "node/tests/characterization/wire-request.test.ts",
+        verifiedAt: "2026-08-12",
+    },
+    {
+        ruleId: "native-token-counting",
+        classification: "endpoint",
+        source: "node/tests/anthropic-count-tokens.test.ts; node/tests/gemini-count-tokens.test.ts",
+        verifiedAt: "2026-08-12",
+    },
+];
+export const cacheCapabilityEvidence = [
+    {
+        endpointId: "anthropic.messages",
+        source: "https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching",
+        verifiedAt: "2026-08-26",
+        classification: "documentation",
+        usageFields: ["cache_read_input_tokens", "cache_creation_input_tokens"],
+    },
+    {
+        endpointId: "deepseek.openai",
+        source: "https://api-docs.deepseek.com/guides/kv_cache",
+        verifiedAt: "2026-08-26",
+        classification: "documentation",
+        usageFields: ["prompt_cache_hit_tokens", "prompt_cache_miss_tokens"],
+    },
+];
+export const tokenMeasurementEvidence = [
+    {
+        endpointId: "anthropic.messages",
+        source: "https://github.com/anthropics/anthropic-sdk-typescript/blob/main/api.md#count-tokens",
+        verifiedAt: "2026-08-26",
+        providerApiState: "supported",
+        adapterState: "available",
+        method: "provider_preflight",
+        coverage: ["system", "messages", "tools"],
+        sdk: "@anthropic-ai/sdk ^0.99.0",
+    },
+    {
+        endpointId: "gemini.google",
+        source: "https://ai.google.dev/api/tokens#method-models.countTokens",
+        verifiedAt: "2026-08-26",
+        providerApiState: "supported",
+        adapterState: "available",
+        method: "provider_preflight",
+        coverage: ["contents", "system", "tools", "provider_options"],
+        sdk: "@google/generative-ai ^0.24.1",
+    },
+    {
+        endpointId: "openai.responses",
+        source: "https://github.com/openai/openai-node/tree/master/src/resources/responses/input-tokens.ts",
+        verifiedAt: "2026-08-26",
+        providerApiState: "supported",
+        adapterState: "available",
+        method: "provider_preflight",
+        coverage: ["input", "instructions", "tools", "provider_options"],
+        sdk: "openai ^7.5.0",
+    },
+];
+const POLICY = {
+    "anthropic/claude-opus-4-1": { maxTurns: 50 },
+    "anthropic/claude-opus-4-7": { maxTurns: 50 },
+    "anthropic/claude-opus-4-6": { maxTurns: 50 },
+    "anthropic/claude-opus-4-0": { maxTurns: 50 },
+    "anthropic/claude-sonnet-4-6": { maxTurns: 25 },
+    "anthropic/claude-sonnet-4-0": { maxTurns: 25 },
+    "anthropic/claude-haiku-4-5": { maxTurns: 15 },
+    "anthropic/claude-3-5-haiku-latest": { maxTurns: 15 },
+    "deepseek/deepseek-chat": { maxTurns: 25 },
+    "deepseek/deepseek-reasoner": { maxTurns: 50 },
+    "deepseek/deepseek-v4-flash": { maxTurns: 20 },
+    "deepseek/deepseek-v4-pro": { maxTurns: 35 },
+    "kimi/moonshot-v1-8k": { maxTurns: 15 },
+    "kimi/moonshot-v1-32k": { maxTurns: 20 },
+    "kimi/moonshot-v1-128k": { maxTurns: 30 },
+    "kimi/kimi-k2.5": { maxTurns: 30 },
+    "kimi/kimi-k2.6": { maxTurns: 35 },
+    "kimi/kimi-k2-thinking": { maxTurns: 50 },
+    "kimi/kimi-k2-thinking-turbo": { maxTurns: 40 },
+    "qwen/qwen3.7-max-preview": { maxTurns: 45 },
+    "qwen/qwen3.7-plus-preview": { maxTurns: 40 },
+    "qwen/qwen3.6-max-preview": { maxTurns: 40 },
+    "qwen/qwen3.6-plus": { maxTurns: 35 },
+    "qwen/qwen3.6-flash": { maxTurns: 20 },
+    "qwen/qwen3.6-35b-a3b": { maxTurns: 25 },
+    "qwen/qwen3.6-27b": { maxTurns: 25 },
+    "qwen/qwen3.5-plus": { maxTurns: 35 },
+    "qwen/qwen3.5-flash": { maxTurns: 20 },
+    "qwen/qwen3.5-397b-a17b": { maxTurns: 35 },
+    "qwen/qwen3.5-122b-a10b": { maxTurns: 25 },
+    "qwen/qwen3.5-35b-a3b": { maxTurns: 20 },
+    "qwen/qwen3.5-27b": { maxTurns: 20 },
+    "glm/glm-5.2": { maxTurns: 50 },
+    "glm/glm-5.1": { maxTurns: 50 },
+    "glm/glm-4-plus": { maxTurns: 35 },
+    "glm/glm-4-flash": { maxTurns: 15 },
+    "glm/glm-4-air": { maxTurns: 20 },
+    "minimax/MiniMax-M3": { maxTurns: 35 },
+    "minimax/MiniMax-M3-highspeed": { maxTurns: 35 },
+    "minimax/MiniMax-M2.7": { maxTurns: 35 },
+    "minimax/MiniMax-M2.7-highspeed": { maxTurns: 35 },
+    "minimax/MiniMax-M2.5": { maxTurns: 25 },
+    "minimax/MiniMax-M2.5-highspeed": { maxTurns: 25 },
+    "minimax/MiniMax-M2.1": { maxTurns: 25 },
+    "minimax/MiniMax-M2.1-highspeed": { maxTurns: 25 },
+    "minimax/MiniMax-M2": { maxTurns: 20 },
+    "minimax/MiniMax-Text-01": { maxTurns: 20 },
+    "gemini/gemini-3-pro-preview": { maxTurns: 50 },
+    "gemini/gemini-3-flash-preview": { maxTurns: 25 },
+    "gemini/gemini-3.5-flash": { maxTurns: 30 },
+    "gemini/gemini-2.5-pro": { maxTurns: 35 },
+    "gemini/gemini-2.5-flash": { maxTurns: 20 },
+    "gemini/gemini-2.0-flash": { maxTurns: 15 },
+    "gemini/gemini-2.0-flash-lite": { maxTurns: 10 },
+    "gemini/gemini-1.5-pro": { maxTurns: 30 },
+    "gemini/gemini-1.5-flash": { maxTurns: 15 },
+    "openai/gpt-5.5": { maxTurns: 60 },
+    "openai/gpt-5.4": { maxTurns: 50 },
+    "openai/gpt-5.4-mini": { maxTurns: 25 },
+    "openai/gpt-5.4-nano": { maxTurns: 15 },
+    "openai/gpt-5.2": { maxTurns: 50 },
+    "openai/gpt-5.2-pro": { maxTurns: 60 },
+    "openai/gpt-5.1": { maxTurns: 50 },
+    "openai/gpt-4o": { maxTurns: 25 },
+    "openai/gpt-4o-mini": { maxTurns: 15 },
+    "openai/gpt-4.1": { maxTurns: 35 },
+    "openai/gpt-4.1-mini": { maxTurns: 20 },
+    "openai/gpt-4.1-nano": { maxTurns: 15 },
+    "openai/gpt-5": { maxTurns: 50 },
+    "openai/gpt-5-pro": { maxTurns: 60 },
+    "openai/gpt-5-mini": { maxTurns: 25 },
+    "openai/gpt-5-nano": { maxTurns: 15 },
+    "openai/o1": { maxTurns: 50 },
+    "openai/o1-mini": { maxTurns: 25 },
+    "openai/o3": { maxTurns: 50 },
+    "openai/o3-mini": { maxTurns: 25 },
+    "openai/o4-mini": { maxTurns: 25 },
+};
+const DEFAULT_ENDPOINT = {
+    anthropic: "anthropic.messages",
+    openai: "openai.chat",
+    minimax: "minimax.anthropic",
+    deepseek: "deepseek.openai",
+    kimi: "kimi.openai",
+    qwen: "qwen.dashscope",
+    gemini: "gemini.google",
+    glm: "glm.openai",
+    baai: "baai.self-hosted.embeddings",
+    ollama: "ollama.local",
+};
+const DEFAULT_MODEL = {
+    anthropic: "claude-sonnet-4-6",
+    openai: "gpt-4o",
+    minimax: "MiniMax-M3",
+    deepseek: "deepseek-v4-flash",
+    kimi: "kimi-k2.6",
+    qwen: "qwen3.6-plus",
+    gemini: "gemini-2.0-flash",
+    glm: "glm-5.2",
+    baai: "bge-m3",
+    ollama: "llama3",
+};
+export function defaultModelForProvider(providerId) {
+    return DEFAULT_MODEL[providerId];
+}
+export function defaultEndpointForProvider(providerId) {
+    return DEFAULT_ENDPOINT[providerId];
+}
+function endpointFor(providerId, modelId) {
+    if (providerId === "openai") {
+        if (modelId.startsWith("text-embedding-"))
+            return "openai.embeddings";
+        if (/^(gpt-5|gpt-4\.1|o3|o4-mini)/.test(modelId))
+            return "openai.responses";
+    }
+    if (providerId === "qwen") {
+        if (modelId.startsWith("text-embedding-"))
+            return "qwen.dashscope.embeddings";
+        if (/^(qwen2\.5-vl-embedding|qwen3-vl-embedding)$/.test(modelId)) {
+            return "qwen.dashscope.multimodal-embeddings";
+        }
+    }
+    if (providerId === "gemini" && modelId.startsWith("gemini-embedding-")) {
+        return "gemini.google.embeddings";
+    }
+    if (providerId === "glm" && modelId.startsWith("embedding-")) {
+        return "glm.openai.embeddings";
+    }
+    return DEFAULT_ENDPOINT[providerId];
+}
+function modelKind(endpointId) {
+    return generationProtocol(endpointProfiles[endpointId].protocol) ? "generation" : "embedding";
+}
+function registration(providerId, rawModelId) {
+    const modelId = normalizeModelId(providerId, rawModelId);
+    const endpointId = endpointFor(providerId, modelId);
+    const policy = providerId === "ollama" ? ollamaPolicy(modelId) : POLICY[`${providerId}/${modelId}`];
+    return {
+        descriptor: {
+            id: `${providerId}/${modelId}`,
+            providerId,
+            kind: modelKind(endpointId),
+            intrinsic: {},
+        },
+        defaultEndpointId: endpointId,
+        ...(policy ? { recommendedRuntimePolicy: policy } : {}),
+    };
+}
+const dynamicResolvers = Object.fromEntries(Object.keys(DEFAULT_ENDPOINT).map(providerId => [providerId, {
+        providerId,
+        resolve(modelId) {
+            return registration(providerId, modelId);
+        },
+    }]));
+export class ModelRegistry {
+    resolve(modelId, providerId) {
+        const resolvedProvider = providerId ?? providerPrefix(modelId);
+        if (!resolvedProvider)
+            return undefined;
+        return dynamicResolvers[resolvedProvider].resolve(modelId);
+    }
+}
+export const modelRegistry = new ModelRegistry();
+export function normalizeModelId(providerId, modelId) {
+    const prefix = `${providerId}/`;
+    return modelId.startsWith(prefix) ? modelId.slice(prefix.length) : modelId;
+}
+export function getRuntimePolicy(providerId, modelId) {
+    if (!isKnownProviderId(providerId))
+        return {};
+    return modelRegistry.resolve(modelId, providerId)?.recommendedRuntimePolicy ?? {};
+}
+function providerPrefix(modelId) {
+    const slash = modelId.indexOf("/");
+    if (slash <= 0)
+        return undefined;
+    const value = modelId.slice(0, slash);
+    return isKnownProviderId(value) ? value : undefined;
+}
+function ollamaPolicy(modelId) {
+    const lower = modelId.toLowerCase();
+    const rows = [
+        ["deepseek-r1", 40], ["qwq", 35], ["llama3.3", 25], ["llama3.2", 20],
+        ["llama3.1", 20], ["llama3", 20], ["mistral", 20], ["gemma2", 20],
+        ["phi4", 20], ["phi3", 15], ["codellama", 20],
+    ];
+    return { maxTurns: rows.find(([prefix]) => lower.startsWith(prefix))?.[1] ?? 20 };
+}
+export const protocolRuntimeCapabilities = {
+    "anthropic-messages": ANTHROPIC_PROTOCOL_CAPABILITIES,
+    "openai-chat": OPENAI_CHAT_PROTOCOL_CAPABILITIES,
+    "openai-responses": OPENAI_RESPONSES_PROTOCOL_CAPABILITIES,
+    gemini: GEMINI_PROTOCOL_CAPABILITIES,
+    "ollama-chat": OLLAMA_PROTOCOL_CAPABILITIES,
+};
+export const endpointRuntimeCapabilities = {
+    "anthropic.messages": { nativeTokenCounting: true, promptCaching: true },
+    "deepseek.openai": { promptCaching: true },
+    "gemini.google": { nativeTokenCounting: true },
+    "openai.responses": { nativeTokenCounting: true },
+};
+export function resolveEffectiveCapability(layers) {
+    const evidence = layers.filter(layer => layer.state !== "unknown").map(layer => layer.layer);
+    if (layers.some(layer => layer.state === "unsupported"))
+        return { state: "unsupported", evidence };
+    if (layers.length > 0 && layers.every(layer => layer.state === "supported")) {
+        const valued = [...layers].reverse().find(layer => layer.value !== undefined);
+        return { state: "supported", ...(valued ? { value: valued.value } : {}), evidence };
+    }
+    return { state: "unknown", evidence };
+}
+const inputModalities = ["text", "image", "audio", "video", "file"];
+const outputModalities = ["text", "image", "audio", "embedding"];
+function booleanState(value) {
+    return value === undefined ? "unknown" : value ? "supported" : "unsupported";
+}
+function membershipState(values, value) {
+    return values === undefined ? "unknown" : values.includes(value) ? "supported" : "unsupported";
+}
+export function resolveEffectiveModelCapabilities(input) {
+    const protocol = protocolRuntimeCapabilities[input.protocol];
+    const overrides = input.endpointCapabilities?.protocolOverrides;
+    const modality = (layer, value) => {
+        const modelValues = layer === "input"
+            ? input.model.intrinsic.inputModalities
+            : input.model.intrinsic.outputModalities;
+        const protocolValues = layer === "input"
+            ? protocol.acceptedInputModalities
+            : protocol.emittedOutputModalities;
+        const overrideValues = layer === "input"
+            ? overrides?.acceptedInputModalities
+            : overrides?.emittedOutputModalities;
+        return resolveEffectiveCapability([
+            { layer: "model", state: membershipState(modelValues, value) },
+            { layer: "protocol", state: membershipState(protocolValues, value) },
+            ...(overrideValues ? [{ layer: "endpoint", state: membershipState(overrideValues, value) }] : []),
+        ]);
+    };
+    const booleanCapability = (modelValue, protocolValue, endpointValue) => resolveEffectiveCapability([
+        { layer: "model", state: booleanState(modelValue) },
+        { layer: "protocol", state: booleanState(protocolValue) },
+        ...(endpointValue === undefined ? [] : [{ layer: "endpoint", state: booleanState(endpointValue) }]),
+    ]);
+    const protocolBoolean = (protocolValue, endpointValue) => resolveEffectiveCapability([
+        { layer: "protocol", state: booleanState(protocolValue) },
+        ...(endpointValue === undefined ? [] : [{ layer: "endpoint", state: booleanState(endpointValue) }]),
+    ]);
+    const media = (key) => protocolBoolean(protocol.mediaForms[key], overrides?.mediaForms?.[key]);
+    return {
+        inputModalities: Object.fromEntries(inputModalities.map(value => [value, modality("input", value)])),
+        outputModalities: Object.fromEntries(outputModalities.map(value => [value, modality("output", value)])),
+        tools: booleanCapability(input.model.intrinsic.tools, protocol.tools, overrides?.tools),
+        reasoning: resolveEffectiveCapability([
+            { layer: "model", state: booleanState(input.model.intrinsic.reasoning) },
+            { layer: "protocol", state: protocol.reasoningReplay === "none" ? "unknown" : "supported" },
+        ]),
+        parallelToolCalls: protocolBoolean(protocol.parallelToolCalls, overrides?.parallelToolCalls),
+        structuredOutput: protocolBoolean(protocol.structuredOutput, overrides?.structuredOutput),
+        promptCaching: resolveEffectiveCapability([
+            { layer: "protocol", state: booleanState(protocol.promptCaching), value: protocol.promptCaching },
+            {
+                layer: "endpoint",
+                state: booleanState(input.endpointCapabilities?.promptCaching),
+                value: input.endpointCapabilities?.promptCaching,
+            },
+        ]),
+        nativeTokenCounting: resolveEffectiveCapability([
+            { layer: "endpoint", state: booleanState(input.endpointCapabilities?.nativeTokenCounting) },
+        ]),
+        mediaForms: {
+            imageUrl: media("imageUrl"), imageBase64: media("imageBase64"), fileId: media("fileId"),
+            audioUrl: media("audioUrl"), audioBase64: media("audioBase64"),
+        },
+    };
+}
+export function generationProtocol(protocol) {
+    switch (protocol) {
+        case "anthropic-messages":
+        case "openai-chat":
+        case "openai-responses":
+        case "gemini":
+        case "ollama-chat":
+            return protocol;
+        default:
+            return undefined;
+    }
+}
+export function endpointCapabilitiesFor(endpointId, preserveEndpointIdentity, preserveCacheEvidence = preserveEndpointIdentity) {
+    const capabilities = preserveEndpointIdentity ? endpointRuntimeCapabilities[endpointId] : undefined;
+    if (!capabilities || preserveCacheEvidence)
+        return capabilities;
+    const { promptCaching: _promptCaching, ...withoutCacheEvidence } = capabilities;
+    return withoutCacheEvidence;
+}
+export function isKnownProviderId(value) {
+    return value in DEFAULT_ENDPOINT;
+}

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

@@ -0,0 +1,65 @@
+import type { Message, ProviderUsage } from "../types.js";
+import type { CanonicalAdapterInput } from "./content-normalization.js";
+import { type AdapterDecodeInput, type AdapterOutput, type AdapterStreamInput, type CanonicalStopReason, type ProtocolAdapter } from "./protocol-adapter.js";
+export interface OllamaMessage {
+    role: string;
+    content: string;
+    images?: string[];
+}
+export interface OllamaRequest {
+    model: string;
+    messages: OllamaMessage[];
+    tools?: Array<{
+        type: "function";
+        function: {
+            name: string;
+            description: string;
+            parameters: unknown;
+        };
+    }>;
+    [key: string]: unknown;
+}
+export interface OllamaChunk {
+    message?: {
+        content?: string;
+        tool_calls?: Array<{
+            function: {
+                name: string;
+                arguments: unknown;
+            };
+        }>;
+    };
+    done?: boolean;
+    done_reason?: string;
+    prompt_eval_count?: number;
+    eval_count?: number;
+}
+export interface OllamaStreamState {
+    readonly input: CanonicalAdapterInput;
+    readonly pendingToolCalls: Map<string, {
+        id: string;
+        name: string;
+        arguments: Record<string, unknown>;
+    }>;
+    finalChunk?: OllamaChunk;
+}
+export declare class OllamaNdjsonDecoder {
+    private buffer;
+    push(text: string): OllamaChunk[];
+    finish(text?: string): OllamaChunk[];
+    private parse;
+}
+export declare class OllamaAdapter implements ProtocolAdapter<OllamaRequest, OllamaChunk, OllamaChunk, OllamaStreamState, OllamaChunk | undefined> {
+    readonly protocol: "ollama-chat";
+    readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
+    buildRequest(input: CanonicalAdapterInput): OllamaRequest;
+    decodeComplete(raw: OllamaChunk, _input: AdapterDecodeInput): {
+        message: Message;
+    };
+    createStreamState(input: AdapterStreamInput): OllamaStreamState;
+    pushStreamChunk(chunk: OllamaChunk, state: OllamaStreamState): AdapterOutput;
+    finishStream(state: OllamaStreamState, final: OllamaChunk | undefined): AdapterOutput;
+    normalizeUsage(raw: unknown): ProviderUsage | undefined;
+    normalizeStopReason(raw: string | undefined): CanonicalStopReason | undefined;
+    createNdjsonDecoder(): OllamaNdjsonDecoder;
+}

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.isSafeInteger(value) || value < 0) {
+        throw new ProtocolResponseError("ollama-chat", `${field} must be a non-negative safe integer`);
+    }
+    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 {};