@jxburros/ai-nugget 0.4.1 → 0.7.0

package/dist/cjs/adapters/engines/base.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_TIMEOUT_MS = void 0;
+exports.streamError = streamError;
+exports.streamTimeout = streamTimeout;
+exports.listOpenModels = listOpenModels;
+exports.health = health;
+exports.parseArgs = parseArgs;
+exports.safeParse = safeParse;
+exports.randomId = randomId;
+exports.streamAnomaly = streamAnomaly;
+const errors_js_1 = require("../../errors.js");
+const transport_js_1 = require("../../transport.js");
+const util_js_1 = require("../../util.js");
+exports.DEFAULT_TIMEOUT_MS = 120_000;
+/**
+ * Maps a raw streaming failure onto a typed {@link AIError}. A fired timeout is
+ * reported as `timeout` regardless of how the underlying `fetch` surfaced the
+ * abort; anything else is normalized through {@link fromUnknown} (which passes
+ * an existing {@link AIError} through untouched, preserving retryability).
+ */
+function streamError(error, timeout, provider) {
+    if (timeout.timedOut())
+        return new errors_js_1.AIError('Request timed out', { kind: 'timeout', provider });
+    return (0, errors_js_1.fromUnknown)(error, provider);
+}
+/**
+ * Create a timeout/abort scope covering the full stream lifetime, plus an
+ * optional idle timeout (`conn.idleTimeoutMs`) that the engine rearms via
+ * `bump()` on each received chunk.
+ */
+function streamTimeout(conn, signal) {
+    return (0, transport_js_1.withTimeout)(conn.timeoutMs ?? exports.DEFAULT_TIMEOUT_MS, signal, conn.idleTimeoutMs);
+}
+async function listOpenModels(conn, profile) {
+    if (!profile.listModelsPath)
+        return [];
+    const { data } = await (0, transport_js_1.fetchJson)((0, util_js_1.joinUrl)(conn.baseUrl, profile.listModelsPath), {
+        method: 'GET',
+        headers: conn.headers,
+        timeoutMs: conn.timeoutMs ?? exports.DEFAULT_TIMEOUT_MS,
+        provider: conn.provider,
+    });
+    const record = (0, util_js_1.asRecord)(data);
+    const items = Array.isArray(record?.data) ? record.data : Array.isArray(record?.models) ? record.models : [];
+    const models = [];
+    for (const item of items) {
+        const row = (0, util_js_1.asRecord)(item);
+        const id = (0, util_js_1.asString)(row?.id) ?? (0, util_js_1.asString)(row?.name);
+        if (!id)
+            continue;
+        const contextWindow = asContextWindow(row);
+        const capabilities = asCapabilities(row);
+        const model = {
+            id,
+            source: { provider: conn.provider, connectionId: conn.id, baseUrl: conn.baseUrl },
+        };
+        if (contextWindow !== undefined)
+            model.contextWindow = contextWindow;
+        if (capabilities)
+            model.capabilities = capabilities;
+        models.push(model);
+    }
+    return models;
+}
+async function health(conn, profile) {
+    const path = profile.healthPath ?? profile.listModelsPath;
+    if (!path)
+        return { ok: true };
+    try {
+        await (0, transport_js_1.fetchJson)((0, util_js_1.joinUrl)(conn.baseUrl, path), {
+            method: 'GET',
+            headers: conn.headers,
+            timeoutMs: Math.min(conn.timeoutMs ?? exports.DEFAULT_TIMEOUT_MS, 10_000),
+            provider: conn.provider,
+        });
+        return { ok: true };
+    }
+    catch (error) {
+        return { ok: false, detail: error instanceof Error ? error.message : 'Health check failed' };
+    }
+}
+/**
+ * Coerce a provider's tool-call `arguments` into an object. Providers disagree
+ * on the shape: OpenAI/Anthropic stream a JSON *string*, Google and Ollama send
+ * a native object — but Ollama-compatible backends (llama.cpp and friends)
+ * sometimes send a string too. Malformed JSON degrades to `{}` so a single bad
+ * tool call surfaces as an argument-validation error rather than a stream crash.
+ */
+function parseArgs(raw) {
+    if (raw === undefined || raw === null)
+        return {};
+    if (typeof raw !== 'string')
+        return raw;
+    if (!raw.trim())
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+/** JSON.parse that returns undefined instead of throwing — for per-line stream frames. */
+function safeParse(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Stable-enough id for a tool call a provider didn't give one for. */
+function randomId() {
+    return globalThis.crypto?.randomUUID?.() ?? `tool_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+}
+/**
+ * A stream that ended without the provider's terminal marker (an OpenAI
+ * `finish_reason`, an Anthropic `message_delta.stop_reason`, a Google
+ * `finishReason`, an Ollama `done`) was almost certainly truncated. Every
+ * engine yields this so a dropped connection is diagnosable identically
+ * regardless of provider.
+ */
+function streamAnomaly(reason = 'stream ended without a terminal finish reason') {
+    return { type: 'context', kind: 'stream_anomaly', data: { reason } };
+}
+/**
+ * Pulls a context-window figure out of the many shapes providers use for it
+ * (OpenRouter `context_length`, OpenAI-style `context_window`, Ollama
+ * `/api/show` `model_info` entries surfaced as `contextWindow`).
+ */
+function asContextWindow(row) {
+    if (!row)
+        return undefined;
+    const direct = row['context_length'] ?? row['context_window'] ?? row['contextWindow'];
+    return typeof direct === 'number' && Number.isFinite(direct) ? direct : undefined;
+}
+function asCapabilities(row) {
+    if (!row)
+        return undefined;
+    const value = row['capabilities'] ?? (0, util_js_1.asRecord)(row['architecture'])?.['modality'];
+    if (Array.isArray(value) && value.every((entry) => typeof entry === 'string'))
+        return value;
+    if (typeof value === 'string')
+        return [value];
+    return undefined;
+}

package/dist/cjs/adapters/engines/google.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleAdapter = void 0;
+const errors_js_1 = require("../../errors.js");
+const tokens_js_1 = require("../../tokens.js");
+const transport_js_1 = require("../../transport.js");
+const util_js_1 = require("../../util.js");
+const base_js_1 = require("./base.js");
+class GoogleAdapter {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async chat(conn, req) {
+        let result;
+        for await (const event of this.stream(conn, req)) {
+            if (event.type === 'done')
+                result = event.result;
+            if (event.type === 'error')
+                throw event.error;
+        }
+        if (!result)
+            throw new errors_js_1.AIError('Google stream ended without a result', { kind: 'invalid_response', provider: conn.provider });
+        return result;
+    }
+    async *stream(conn, req) {
+        const started = Date.now();
+        let firstTokenMs = null;
+        let text = '';
+        let inputTokens;
+        let outputTokens;
+        let finish;
+        const toolCalls = [];
+        const timeout = (0, base_js_1.streamTimeout)(conn, req.signal);
+        yield { type: 'start', callId: '', provider: conn.provider, model: req.model };
+        // Gemini rejects `responseMimeType: application/json` combined with function
+        // declarations, so `body()` drops JSON mode when tools are present. Surface
+        // that downgrade instead of silently returning unstructured text.
+        if (jsonModeDowngraded(req)) {
+            yield {
+                type: 'context',
+                kind: 'json_mode_downgraded',
+                data: { reason: 'Gemini does not accept JSON response mode together with tools; the request was sent without JSON mode', provider: conn.provider },
+            };
+        }
+        try {
+            const streamUrl = `${conn.baseUrl}/v1beta/models/${encodeURIComponent(req.model)}:streamGenerateContent?alt=sse`;
+            const res = await (0, transport_js_1.postResponse)(streamUrl, body(req), conn.headers, timeout.signal, conn.provider);
+            const contentType = res.headers.get('content-type') ?? '';
+            const chunks = contentType.includes('text/event-stream') ? (0, transport_js_1.sseLines)(res) : singleJsonLine(res);
+            for await (const line of chunks) {
+                timeout.bump();
+                const parsed = (0, base_js_1.safeParse)(line);
+                const record = (0, util_js_1.asRecord)(parsed);
+                const promptFeedback = (0, util_js_1.asRecord)(record?.promptFeedback);
+                if (!firstCandidate(record) && promptFeedback?.blockReason)
+                    finish = 'SAFETY';
+                for (const part of candidateParts(record)) {
+                    const partText = (0, util_js_1.asString)((0, util_js_1.asRecord)(part)?.text);
+                    if (partText) {
+                        // Gemini marks reasoning parts with `thought: true`; route those to
+                        // the reasoning channel so they don't blend into the answer text.
+                        if ((0, util_js_1.asRecord)(part)?.thought === true) {
+                            yield { type: 'reasoning', text: partText };
+                            continue;
+                        }
+                        if (firstTokenMs === null)
+                            firstTokenMs = Date.now() - started;
+                        text += partText;
+                        yield { type: 'delta', text: partText };
+                    }
+                    const fnCall = (0, util_js_1.asRecord)((0, util_js_1.asRecord)(part)?.functionCall);
+                    if (fnCall) {
+                        const call = {
+                            id: (0, base_js_1.randomId)(),
+                            name: (0, util_js_1.asString)(fnCall.name) ?? 'unknown',
+                            arguments: fnCall.args ?? {},
+                            raw: JSON.stringify(fnCall.args ?? {}),
+                        };
+                        toolCalls.push(call);
+                        yield { type: 'tool_call', call };
+                    }
+                }
+                finish = (0, util_js_1.asString)((0, util_js_1.asRecord)(firstCandidate(record))?.finishReason) ?? finish;
+                const usage = (0, util_js_1.asRecord)(record?.usageMetadata);
+                inputTokens = (0, util_js_1.asNumber)(usage?.promptTokenCount) ?? inputTokens;
+                outputTokens = (0, util_js_1.asNumber)(usage?.candidatesTokenCount) ?? outputTokens;
+            }
+            if (!finish)
+                yield (0, base_js_1.streamAnomaly)('stream ended without a finishReason');
+            const hasTools = toolCalls.length > 0;
+            yield { type: 'done', result: {
+                    text,
+                    toolCalls: hasTools ? toolCalls : undefined,
+                    finishReason: mapFinish(finish, hasTools),
+                    usage: inputTokens !== undefined || outputTokens !== undefined ? { inputTokens, outputTokens, estimated: false } : (0, tokens_js_1.estimatedUsage)((0, util_js_1.textFromMessages)(req.messages), text),
+                    timing: { firstTokenMs, totalMs: Date.now() - started },
+                    model: req.model,
+                    source: { provider: conn.provider, connectionId: conn.id, baseUrl: conn.baseUrl },
+                } };
+        }
+        catch (error) {
+            throw (0, base_js_1.streamError)(error, timeout, conn.provider);
+        }
+        finally {
+            timeout.done();
+        }
+    }
+    /**
+     * `GoogleAdapter` has no `listModels`, so without a `health` probe
+     * `AIHandler.testConnection` would report `ok: true` without ever making a
+     * network call. `/v1beta/models` is a lightweight, key-authenticated GET
+     * that gives an honest connectivity/auth check.
+     */
+    async health(conn) {
+        try {
+            await (0, transport_js_1.fetchJson)((0, util_js_1.joinUrl)(conn.baseUrl, '/v1beta/models'), {
+                method: 'GET',
+                headers: conn.headers,
+                timeoutMs: Math.min(conn.timeoutMs ?? base_js_1.DEFAULT_TIMEOUT_MS, 10_000),
+                provider: conn.provider,
+            });
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, detail: error instanceof Error ? error.message : 'Health check failed' };
+        }
+    }
+    /**
+     * Lists models from Google's `/v1beta/models`. Strips the `models/` name
+     * prefix, and maps `inputTokenLimit` → `contextWindow` and
+     * `supportedGenerationMethods` → `capabilities`.
+     */
+    async listModels(conn) {
+        const { data } = await (0, transport_js_1.fetchJson)((0, util_js_1.joinUrl)(conn.baseUrl, '/v1beta/models'), {
+            method: 'GET',
+            headers: conn.headers,
+            timeoutMs: Math.min(conn.timeoutMs ?? base_js_1.DEFAULT_TIMEOUT_MS, 15_000),
+            provider: conn.provider,
+        });
+        const rows = Array.isArray((0, util_js_1.asRecord)(data)?.models) ? (0, util_js_1.asRecord)(data).models : [];
+        const models = [];
+        for (const value of rows) {
+            const row = (0, util_js_1.asRecord)(value);
+            const name = (0, util_js_1.asString)(row?.name);
+            if (!name)
+                continue;
+            const id = name.startsWith('models/') ? name.slice('models/'.length) : name;
+            const model = { id, source: { provider: conn.provider, connectionId: conn.id, baseUrl: conn.baseUrl } };
+            const contextWindow = (0, util_js_1.asNumber)(row?.inputTokenLimit);
+            if (contextWindow !== undefined)
+                model.contextWindow = contextWindow;
+            const methods = row?.supportedGenerationMethods;
+            if (Array.isArray(methods) && methods.every((m) => typeof m === 'string'))
+                model.capabilities = methods;
+            models.push(model);
+        }
+        return models;
+    }
+}
+exports.GoogleAdapter = GoogleAdapter;
+/** True when the caller asked for JSON mode but tools force it off. */
+function jsonModeDowngraded(req) {
+    return req.responseFormat?.type === 'json' && !!req.tools?.length;
+}
+function body(req) {
+    const systemText = req.messages.filter((m) => m.role === 'system').map((m) => textContent(m.content)).join('\n\n');
+    const jsonMode = req.responseFormat?.type === 'json' && !req.tools?.length;
+    const responseSchema = req.responseFormat?.type === 'json' ? req.responseFormat.schema : undefined;
+    const payload = {
+        contents: toGoogleContents(req.messages.filter((m) => m.role !== 'system')),
+        generationConfig: {
+            temperature: req.temperature,
+            topP: req.topP,
+            maxOutputTokens: req.maxTokens,
+            stopSequences: req.stopSequences,
+            responseMimeType: jsonMode ? 'application/json' : undefined,
+            responseSchema: jsonMode ? responseSchema : undefined,
+        },
+    };
+    if (systemText)
+        payload.systemInstruction = { parts: [{ text: systemText }] };
+    if (req.tools?.length) {
+        payload.tools = [{ functionDeclarations: req.tools.map((tool) => ({ name: tool.name, description: tool.description, parameters: tool.parameters })) }];
+        const mode = req.toolChoice === 'none' ? 'NONE' : typeof req.toolChoice === 'object' ? 'ANY' : 'AUTO';
+        const config = { mode };
+        if (typeof req.toolChoice === 'object')
+            config.allowedFunctionNames = [req.toolChoice.name];
+        payload.toolConfig = { functionCallingConfig: config };
+    }
+    if (req.reasoningEffort !== undefined) {
+        // First-class reasoning effort → Gemini's thinking budget. 0 disables
+        // thinking on models that allow it; others treat it as a minimum.
+        payload.generationConfig.thinkingConfig = {
+            thinkingBudget: util_js_1.REASONING_BUDGET_TOKENS[req.reasoningEffort],
+        };
+    }
+    // providerOptions reaches Google-native fields: top-level `safetySettings`,
+    // `cachedContent`, and `generationConfig` extras (`thinkingConfig`,
+    // `responseModalities`, …) merged one level deep into generationConfig.
+    return (0, util_js_1.applyProviderOptions)(payload, req.providerOptions, ['generationConfig']);
+}
+function toGoogleContents(messages) {
+    const contents = [];
+    for (let index = 0; index < messages.length; index += 1) {
+        const message = messages[index];
+        if (message.role !== 'tool') {
+            contents.push(toGoogleContent(message));
+            continue;
+        }
+        const parts = [];
+        while (index < messages.length && messages[index]?.role === 'tool') {
+            const toolMessage = messages[index];
+            parts.push({ functionResponse: { name: toolMessage.name ?? 'unknown', response: toolResponseObject(toolMessage) } });
+            index += 1;
+        }
+        index -= 1;
+        contents.push({ role: 'user', parts });
+    }
+    return contents;
+}
+function toGoogleContent(m) {
+    // Tool-role messages are handled by toGoogleContents' batching loop and never
+    // reach here, so no tool branch is needed.
+    if (m.role === 'assistant' && m.toolCalls?.length) {
+        const parts = [...googleParts(m.content)];
+        for (const call of m.toolCalls)
+            parts.push({ functionCall: { name: call.name, args: call.arguments ?? {} } });
+        return { role: 'model', parts };
+    }
+    return {
+        role: m.role === 'assistant' ? 'model' : 'user',
+        parts: googleParts(m.content),
+    };
+}
+/** Maps text/image content — a string or a ContentPart[] — onto Google parts. */
+function googleParts(content) {
+    if (typeof content === 'string')
+        return content ? [{ text: content }] : [];
+    return content.map((part) => part.type === 'image'
+        ? { inlineData: { mimeType: part.mimeType ?? 'image/png', data: part.imageBase64 ?? '' } }
+        : { text: part.text ?? '' });
+}
+function textContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!content)
+        return '';
+    return content.filter((part) => part.type === 'text').map((part) => part.text ?? '').join('\n');
+}
+function toolResponseObject(message) {
+    if (typeof message.content !== 'string')
+        return { content: textContent(message.content) };
+    try {
+        const parsed = JSON.parse(message.content);
+        if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+        // keep string fallback
+    }
+    return { content: message.content };
+}
+async function* singleJsonLine(res) {
+    const data = await res.json();
+    // Non-SSE responses may be a single object or an array of streamed chunks.
+    if (Array.isArray(data)) {
+        for (const item of data)
+            yield JSON.stringify(item);
+    }
+    else {
+        yield JSON.stringify(data);
+    }
+}
+function firstCandidate(record) {
+    const candidates = Array.isArray(record?.candidates) ? record.candidates : [];
+    return candidates[0];
+}
+function candidateParts(record) {
+    const content = (0, util_js_1.asRecord)((0, util_js_1.asRecord)(firstCandidate(record))?.content);
+    return Array.isArray(content?.parts) ? content.parts : [];
+}
+function mapFinish(finish, hasTools) {
+    if (hasTools)
+        return 'tool';
+    if (finish === 'MAX_TOKENS')
+        return 'length';
+    if (finish === 'SAFETY' || finish === 'RECITATION' || finish === 'BLOCKLIST' || finish === 'PROHIBITED_CONTENT')
+        return 'content_filter';
+    return 'stop';
+}

package/dist/cjs/adapters/engines/ollama.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaAdapter = void 0;
+const errors_js_1 = require("../../errors.js");
+const tokens_js_1 = require("../../tokens.js");
+const transport_js_1 = require("../../transport.js");
+const util_js_1 = require("../../util.js");
+const base_js_1 = require("./base.js");
+/** Max concurrent /api/show probes when listing models — enough to be fast, few enough to be polite to a local daemon. */
+const SHOW_CONCURRENCY = 6;
+class OllamaAdapter {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async chat(conn, req) {
+        let result;
+        for await (const event of this.stream(conn, req)) {
+            if (event.type === 'done')
+                result = event.result;
+            if (event.type === 'error')
+                throw event.error;
+        }
+        if (!result)
+            throw new errors_js_1.AIError('Ollama stream ended without a result', { kind: 'invalid_response', provider: conn.provider });
+        return result;
+    }
+    async *stream(conn, req) {
+        const started = Date.now();
+        let firstTokenMs = null;
+        let text = '';
+        let inputTokens;
+        let outputTokens;
+        let doneReason;
+        let sawTerminal = false;
+        const toolCalls = [];
+        const timeout = (0, base_js_1.streamTimeout)(conn, req.signal);
+        yield { type: 'start', callId: '', provider: conn.provider, model: req.model };
+        try {
+            const res = await (0, transport_js_1.postResponse)((0, util_js_1.joinUrl)(conn.baseUrl, '/api/chat'), body(req), conn.headers, timeout.signal, conn.provider);
+            for await (const value of (0, transport_js_1.ndjsonLines)(res)) {
+                timeout.bump();
+                const record = (0, util_js_1.asRecord)(value);
+                const message = (0, util_js_1.asRecord)(record?.message);
+                const thinking = (0, util_js_1.asString)(message?.thinking);
+                if (thinking)
+                    yield { type: 'reasoning', text: thinking };
+                const piece = (0, util_js_1.asString)(message?.content);
+                if (piece) {
+                    if (firstTokenMs === null)
+                        firstTokenMs = Date.now() - started;
+                    text += piece;
+                    yield { type: 'delta', text: piece };
+                }
+                inputTokens = (0, util_js_1.asNumber)(record?.prompt_eval_count) ?? inputTokens;
+                outputTokens = (0, util_js_1.asNumber)(record?.eval_count) ?? outputTokens;
+                doneReason = (0, util_js_1.asString)(record?.done_reason) ?? doneReason;
+                if (record?.done === true)
+                    sawTerminal = true;
+                const calls = Array.isArray(message?.tool_calls) ? message.tool_calls : [];
+                for (const callValue of calls) {
+                    const fn = (0, util_js_1.asRecord)((0, util_js_1.asRecord)(callValue)?.function);
+                    const args = fn?.arguments ?? {};
+                    const toolCall = {
+                        id: (0, base_js_1.randomId)(),
+                        name: (0, util_js_1.asString)(fn?.name) ?? 'unknown',
+                        // Ollama itself sends a native object, but llama.cpp-style backends
+                        // behind the same protocol send a JSON *string* — coerce either into
+                        // the object `validateToolArgs` expects.
+                        arguments: (0, base_js_1.parseArgs)(args),
+                        raw: typeof args === 'string' ? args : JSON.stringify(args),
+                    };
+                    toolCalls.push(toolCall);
+                    yield { type: 'tool_call', call: toolCall };
+                }
+            }
+            if (!sawTerminal)
+                yield (0, base_js_1.streamAnomaly)('NDJSON stream ended without a done record');
+            const hasTools = toolCalls.length > 0;
+            yield { type: 'done', result: {
+                    text,
+                    toolCalls: hasTools ? toolCalls : undefined,
+                    finishReason: hasTools ? 'tool' : doneReason === 'length' ? 'length' : 'stop',
+                    usage: inputTokens !== undefined || outputTokens !== undefined ? { inputTokens, outputTokens, estimated: false } : (0, tokens_js_1.estimatedUsage)((0, util_js_1.textFromMessages)(req.messages), text),
+                    timing: { firstTokenMs, totalMs: Date.now() - started },
+                    model: req.model,
+                    source: { provider: conn.provider, connectionId: conn.id, baseUrl: conn.baseUrl },
+                } };
+        }
+        catch (error) {
+            throw (0, base_js_1.streamError)(error, timeout, conn.provider);
+        }
+        finally {
+            timeout.done();
+        }
+    }
+    async listModels(conn) {
+        const { data } = await (0, transport_js_1.fetchJson)(`${conn.baseUrl}/api/tags`, {
+            method: 'GET',
+            headers: conn.headers,
+            timeoutMs: conn.timeoutMs ?? base_js_1.DEFAULT_TIMEOUT_MS,
+            provider: conn.provider,
+        });
+        const models = Array.isArray((0, util_js_1.asRecord)(data)?.models) ? (0, util_js_1.asRecord)(data).models : [];
+        const ids = models.map((model) => (0, util_js_1.asString)((0, util_js_1.asRecord)(model)?.name) ?? (0, util_js_1.asString)((0, util_js_1.asRecord)(model)?.model) ?? '').filter(Boolean);
+        // Probe /api/show per model for context window + capabilities (best effort),
+        // with bounded concurrency so a large model list resolves quickly without
+        // opening an unbounded number of sockets against a local daemon.
+        return (0, util_js_1.mapWithConcurrency)(ids, SHOW_CONCURRENCY, async (id) => {
+            const info = { id, source: { provider: conn.provider, connectionId: conn.id, baseUrl: conn.baseUrl } };
+            const probed = await this.showModel(conn, id).catch(() => undefined);
+            if (probed?.contextWindow !== undefined)
+                info.contextWindow = probed.contextWindow;
+            if (probed?.capabilities)
+                info.capabilities = probed.capabilities;
+            return info;
+        });
+    }
+    async embed(conn, req) {
+        const inputs = Array.isArray(req.input) ? req.input : [req.input];
+        const { data } = await (0, transport_js_1.fetchJson)((0, util_js_1.joinUrl)(conn.baseUrl, '/api/embed'), {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', ...conn.headers },
+            body: JSON.stringify((0, util_js_1.applyProviderOptions)({ model: req.model, input: inputs }, req.providerOptions)),
+            timeoutMs: conn.timeoutMs ?? base_js_1.DEFAULT_TIMEOUT_MS,
+            provider: conn.provider,
+        });
+        const record = (0, util_js_1.asRecord)(data);
+        const rows = Array.isArray(record?.embeddings) ? record.embeddings : [];
+        const embeddings = rows.map((row) => (Array.isArray(row) ? row.filter((n) => typeof n === 'number') : []));
+        const inputTokens = (0, util_js_1.asNumber)(record?.prompt_eval_count);
+        return {
+            embeddings,
+            model: req.model,
+            usage: { inputTokens, outputTokens: 0, estimated: inputTokens === undefined },
+            source: { provider: conn.provider, connectionId: conn.id, baseUrl: conn.baseUrl },
+            raw: data,
+        };
+    }
+    async showModel(conn, model) {
+        const { data } = await (0, transport_js_1.fetchJson)(`${conn.baseUrl}/api/show`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', ...conn.headers },
+            body: JSON.stringify({ model }),
+            timeoutMs: Math.min(conn.timeoutMs ?? base_js_1.DEFAULT_TIMEOUT_MS, 15_000),
+            provider: conn.provider,
+        });
+        const record = (0, util_js_1.asRecord)(data);
+        const modelInfo = (0, util_js_1.asRecord)(record?.model_info);
+        let contextWindow;
+        if (modelInfo) {
+            for (const [key, value] of Object.entries(modelInfo)) {
+                if (key.endsWith('.context_length') && typeof value === 'number') {
+                    contextWindow = value;
+                    break;
+                }
+            }
+        }
+        const caps = record?.capabilities;
+        const capabilities = Array.isArray(caps) && caps.every((c) => typeof c === 'string') ? caps : undefined;
+        const result = {};
+        if (contextWindow !== undefined)
+            result.contextWindow = contextWindow;
+        if (capabilities)
+            result.capabilities = capabilities;
+        return result;
+    }
+}
+exports.OllamaAdapter = OllamaAdapter;
+function body(req) {
+    const base = {
+        model: req.model,
+        messages: req.messages.map(toOllamaMessage),
+        stream: true,
+        options: { temperature: req.temperature, num_predict: req.maxTokens, top_p: req.topP, stop: req.stopSequences },
+        format: req.responseFormat?.type === 'json' ? (req.responseFormat.schema ?? 'json') : undefined,
+        tools: req.tools?.map((tool) => ({ type: 'function', function: { name: tool.name, description: tool.description, parameters: tool.parameters } })),
+    };
+    // First-class reasoning effort → Ollama's `think` flag (reasoning arrives in
+    // `message.thinking`, which this engine already routes to `reasoning` events).
+    // Ollama has no graded effort for most models, so anything but `'none'` is
+    // `true`. Only sent when asked for: a model without thinking support rejects it.
+    if (req.reasoningEffort !== undefined)
+        base.think = req.reasoningEffort !== 'none';
+    // providerOptions reaches Ollama's real request fields — `options.num_ctx`,
+    // `options.num_keep`, top-level `keep_alive`, `think`, etc. `options` is
+    // merged one level deep so num_ctx joins the samplers above rather than
+    // replacing them.
+    return (0, util_js_1.applyProviderOptions)(base, req.providerOptions, ['options']);
+}
+function toOllamaMessage(m) {
+    const images = typeof m.content === 'string' ? undefined : m.content.filter((part) => part.type === 'image').map((part) => part.imageBase64).filter(Boolean);
+    const message = {
+        role: m.role,
+        content: typeof m.content === 'string' ? m.content : m.content.filter((part) => part.type === 'text').map((part) => part.text ?? '').join('\n'),
+    };
+    if (images && images.length)
+        message.images = images;
+    if (m.role === 'tool' && m.name)
+        message.tool_name = m.name;
+    if (m.role === 'assistant' && m.toolCalls?.length) {
+        message.tool_calls = m.toolCalls.map((call) => ({ function: { name: call.name, arguments: call.arguments ?? {} } }));
+    }
+    return message;
+}