@jxburros/ai-nugget 0.3.1 → 0.6.0

package/dist/adapters/engines/anthropic.d.ts

@@ -1,8 +1,14 @@
-import type { ChatRequest, ChatResult, ProviderAdapter, ResolvedConnection, StreamEvent } from '../../types.js';
+import type { ChatRequest, ChatResult, ModelInfo, ProviderAdapter, ResolvedConnection, StreamEvent } from '../../types.js';
 export declare class AnthropicAdapter implements ProviderAdapter {
     readonly provider: string;
     constructor(provider: string);
     chat(conn: ResolvedConnection, req: ChatRequest): Promise<ChatResult>;
     stream(conn: ResolvedConnection, req: ChatRequest): AsyncIterable<StreamEvent>;
+    /**
+     * Lists models from Anthropic's `/v1/models` endpoint (auth + version headers
+     * already applied to `conn.headers`). The endpoint does not report a context
+     * window, so `contextWindow` is left undefined rather than guessed.
+     */
+    listModels(conn: ResolvedConnection): Promise<ModelInfo[]>;
 }
 //# sourceMappingURL=anthropic.d.ts.map

package/dist/adapters/engines/anthropic.js

@@ -1,8 +1,8 @@
 import { AIError } from '../../errors.js';
 import { estimatedUsage } from '../../tokens.js';
-import { postResponse, sseLines } from '../../transport.js';
-import { asNumber, asRecord, asString, textFromMessages } from '../../util.js';
-import { streamError, streamTimeout } from './base.js';
+import { fetchJson, postResponse, sseLines } from '../../transport.js';
+import { applyProviderOptions, asNumber, asRecord, asString, joinUrl, textFromMessages } from '../../util.js';
+import { DEFAULT_TIMEOUT_MS, parseArgs, randomId, safeParse, streamAnomaly, streamError, streamTimeout } from './base.js';
 const JSON_MODE_TOOL = 'json_output';
 export class AnthropicAdapter {
     provider;
@@ -29,11 +29,22 @@ export class AnthropicAdapter {
         let inputTokens;
         let outputTokens;
         let stopReason;
+        let sawTerminal = false;
         const emittedTools = [];
         // Partial tool_use blocks keyed by content-block index (input_json_delta accumulation).
         const blocks = new Map();
         const timeout = streamTimeout(conn, req.signal);
         yield { type: 'start', callId: '', provider: conn.provider, model: req.model };
+        // Anthropic JSON mode is implemented as a forced `json_output` tool, which
+        // cannot coexist with the caller's own tools — same silent-downgrade shape
+        // as Gemini, so it gets the same signal rather than quietly dropping.
+        if (req.responseFormat?.type === 'json' && req.tools?.length) {
+            yield {
+                type: 'context',
+                kind: 'json_mode_downgraded',
+                data: { reason: 'Anthropic JSON mode uses a forced tool and cannot be combined with caller tools; the request was sent without JSON mode', provider: conn.provider },
+            };
+        }
         try {
             const res = await postResponse(`${conn.baseUrl}/v1/messages`, body(req, jsonMode), conn.headers, timeout.signal, conn.provider);
             const contentType = res.headers.get('content-type') ?? '';
@@ -43,6 +54,7 @@ export class AnthropicAdapter {
                 inputTokens = parsed.inputTokens;
                 outputTokens = parsed.outputTokens;
                 stopReason = parsed.stopReason;
+                sawTerminal = true;
                 if (jsonMode) {
                     text = jsonTextFrom(parsed.toolCalls, parsed.text);
                     if (text)
@@ -60,6 +72,7 @@ export class AnthropicAdapter {
             }
             else {
                 for await (const line of sseLines(res)) {
+                    timeout.bump();
                     const record = asRecord(safeParse(line));
                     if (!record)
                         continue;
@@ -88,6 +101,12 @@ export class AnthropicAdapter {
                                 yield { type: 'delta', text: piece };
                             }
                         }
+                        else if (delta?.type === 'thinking_delta') {
+                            // Extended-thinking tokens ride the reasoning channel, kept out of `text`.
+                            const piece = asString(delta.thinking) ?? '';
+                            if (piece)
+                                yield { type: 'reasoning', text: piece };
+                        }
                         else if (delta?.type === 'input_json_delta') {
                             const partial = blocks.get(index);
                             if (partial)
@@ -112,14 +131,21 @@ export class AnthropicAdapter {
                             }
                         }
                     }
+                    else if (type === 'message_stop') {
+                        sawTerminal = true;
+                    }
                     else if (type === 'message_delta') {
                         const delta = asRecord(record.delta);
+                        if (asString(delta?.stop_reason))
+                            sawTerminal = true;
                         stopReason = asString(delta?.stop_reason) ?? stopReason;
                         const usage = asRecord(record.usage);
                         outputTokens = asNumber(usage?.output_tokens) ?? outputTokens;
                     }
                 }
             }
+            if (!sawTerminal)
+                yield streamAnomaly('stream ended without a stop_reason or message_stop');
             const hasTools = emittedTools.length > 0;
             yield { type: 'done', result: {
                     text,
@@ -138,6 +164,24 @@ export class AnthropicAdapter {
             timeout.done();
         }
     }
+    /**
+     * Lists models from Anthropic's `/v1/models` endpoint (auth + version headers
+     * already applied to `conn.headers`). The endpoint does not report a context
+     * window, so `contextWindow` is left undefined rather than guessed.
+     */
+    async listModels(conn) {
+        const { data } = await fetchJson(joinUrl(conn.baseUrl, '/v1/models'), {
+            method: 'GET',
+            headers: conn.headers,
+            timeoutMs: Math.min(conn.timeoutMs ?? DEFAULT_TIMEOUT_MS, 15_000),
+            provider: conn.provider,
+        });
+        const rows = Array.isArray(asRecord(data)?.data) ? asRecord(data).data : [];
+        return rows
+            .map((row) => asString(asRecord(row)?.id))
+            .filter((id) => Boolean(id))
+            .map((id) => ({ id, source: { provider: conn.provider, connectionId: conn.id, baseUrl: conn.baseUrl } }));
+    }
 }
 function body(req, jsonMode) {
     const system = req.messages.filter((m) => m.role === 'system').map((m) => textContent(m.content)).join('\n\n') || undefined;
@@ -166,7 +210,9 @@ function body(req, jsonMode) {
         else if (req.toolChoice === 'none')
             base.tool_choice = { type: 'none' };
     }
-    return base;
+    // providerOptions carries Anthropic-native fields (`thinking`, `metadata`,
+    // top-level `cache_control` extras, `service_tier`, …) without a release.
+    return applyProviderOptions(base, req.providerOptions);
 }
 function toAnthropicMessages(messages) {
     const out = [];
@@ -188,29 +234,29 @@ function toAnthropicMessages(messages) {
     return out;
 }
 function toAnthropicMessage(m) {
-    // tool result messages map to a user turn carrying a tool_result content block.
-    if (m.role === 'tool') {
-        return {
-            role: 'user',
-            content: [{ type: 'tool_result', tool_use_id: m.toolCallId ?? '', content: typeof m.content === 'string' ? m.content : '' }],
-        };
-    }
-    // assistant turns that carried tool calls replay them as tool_use blocks.
+    // Tool-role messages are handled by toAnthropicMessages' batching loop and
+    // never reach here, so no tool branch is needed.
+    // assistant turns that carried tool calls replay them as tool_use blocks,
+    // preserving any text/image content parts that accompanied the calls.
     if (m.role === 'assistant' && m.toolCalls?.length) {
-        const content = [];
-        if (typeof m.content === 'string' && m.content)
-            content.push({ type: 'text', text: m.content });
+        const content = [...contentBlocks(m.content)];
         for (const call of m.toolCalls)
             content.push({ type: 'tool_use', id: call.id, name: call.name, input: call.arguments ?? {} });
         return { role: 'assistant', content };
     }
     return {
         role: m.role === 'assistant' ? 'assistant' : 'user',
-        content: typeof m.content === 'string' ? m.content : m.content.map((part) => part.type === 'image'
-            ? { type: 'image', source: { type: 'base64', media_type: part.mimeType ?? 'image/png', data: part.imageBase64 ?? '' } }
-            : { type: 'text', text: part.text ?? '' }),
+        content: typeof m.content === 'string' ? m.content : contentBlocks(m.content),
     };
 }
+/** Maps text/image content — a string or a ContentPart[] — onto Anthropic content blocks. */
+function contentBlocks(content) {
+    if (typeof content === 'string')
+        return content ? [{ type: 'text', text: content }] : [];
+    return content.map((part) => part.type === 'image'
+        ? { type: 'image', source: { type: 'base64', media_type: part.mimeType ?? 'image/png', data: part.imageBase64 ?? '' } }
+        : { type: 'text', text: part.text ?? '' });
+}
 function textContent(content) {
     if (typeof content === 'string')
         return content;
@@ -256,23 +302,4 @@ function mapStop(stop, hasTools) {
         return 'length';
     return 'stop';
 }
-function parseArgs(raw) {
-    try {
-        return raw ? JSON.parse(raw) : {};
-    }
-    catch {
-        return {};
-    }
-}
-function safeParse(line) {
-    try {
-        return JSON.parse(line);
-    }
-    catch {
-        return undefined;
-    }
-}
-function randomId() {
-    return globalThis.crypto?.randomUUID?.() ?? `tool_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-}
 //# sourceMappingURL=anthropic.js.map

package/dist/adapters/engines/base.d.ts

@@ -12,12 +12,39 @@ export declare const DEFAULT_TIMEOUT_MS = 120000;
 export declare function streamError(error: unknown, timeout: {
     timedOut(): boolean;
 }, provider: string): AIError;
-/** Create a timeout/abort scope covering the full stream lifetime. */
+/**
+ * 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.
+ */
 export declare function streamTimeout(conn: ResolvedConnection, signal?: AbortSignal): ReturnType<typeof withTimeout>;
 export declare function listOpenModels(conn: ResolvedConnection, profile: ProviderProfile): Promise<ModelInfo[]>;
 export declare function health(conn: ResolvedConnection, profile: ProviderProfile): Promise<{
     ok: boolean;
     detail?: string;
 }>;
-export declare function requireResponse(condition: unknown, message: string): asserts condition;
+/**
+ * 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.
+ */
+export declare function parseArgs(raw: unknown): unknown;
+/** JSON.parse that returns undefined instead of throwing — for per-line stream frames. */
+export declare function safeParse(line: string): unknown;
+/** Stable-enough id for a tool call a provider didn't give one for. */
+export declare function randomId(): string;
+/**
+ * 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.
+ */
+export declare function streamAnomaly(reason?: string): {
+    type: 'context';
+    kind: string;
+    data: unknown;
+};
 //# sourceMappingURL=base.d.ts.map

package/dist/adapters/engines/base.js

@@ -1,6 +1,6 @@
 import { AIError, fromUnknown } from '../../errors.js';
 import { fetchJson, withTimeout } from '../../transport.js';
-import { asRecord, asString } from '../../util.js';
+import { asRecord, asString, joinUrl } from '../../util.js';
 export const DEFAULT_TIMEOUT_MS = 120_000;
 /**
  * Maps a raw streaming failure onto a typed {@link AIError}. A fired timeout is
@@ -13,14 +13,18 @@ export function streamError(error, timeout, provider) {
         return new AIError('Request timed out', { kind: 'timeout', provider });
     return fromUnknown(error, provider);
 }
-/** Create a timeout/abort scope covering the full stream lifetime. */
+/**
+ * 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.
+ */
 export function streamTimeout(conn, signal) {
-    return withTimeout(conn.timeoutMs ?? DEFAULT_TIMEOUT_MS, signal);
+    return withTimeout(conn.timeoutMs ?? DEFAULT_TIMEOUT_MS, signal, conn.idleTimeoutMs);
 }
 export async function listOpenModels(conn, profile) {
     if (!profile.listModelsPath)
         return [];
-    const { data } = await fetchJson(`${conn.baseUrl}${profile.listModelsPath}`, {
+    const { data } = await fetchJson(joinUrl(conn.baseUrl, profile.listModelsPath), {
         method: 'GET',
         headers: conn.headers,
         timeoutMs: conn.timeoutMs ?? DEFAULT_TIMEOUT_MS,
@@ -53,7 +57,7 @@ export async function health(conn, profile) {
     if (!path)
         return { ok: true };
     try {
-        await fetchJson(`${conn.baseUrl}${path}`, {
+        await fetchJson(joinUrl(conn.baseUrl, path), {
             method: 'GET',
             headers: conn.headers,
             timeoutMs: Math.min(conn.timeoutMs ?? DEFAULT_TIMEOUT_MS, 10_000),
@@ -65,9 +69,49 @@ export async function health(conn, profile) {
         return { ok: false, detail: error instanceof Error ? error.message : 'Health check failed' };
     }
 }
-export function requireResponse(condition, message) {
-    if (!condition)
-        throw new AIError(message, { kind: 'invalid_response' });
+/**
+ * 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.
+ */
+export 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. */
+export 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. */
+export 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.
+ */
+export 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

package/dist/adapters/engines/google.d.ts

@@ -1,8 +1,24 @@
-import type { ChatRequest, ChatResult, ProviderAdapter, ResolvedConnection, StreamEvent } from '../../types.js';
+import type { ChatRequest, ChatResult, ModelInfo, ProviderAdapter, ResolvedConnection, StreamEvent } from '../../types.js';
 export declare class GoogleAdapter implements ProviderAdapter {
     readonly provider: string;
     constructor(provider: string);
     chat(conn: ResolvedConnection, req: ChatRequest): Promise<ChatResult>;
     stream(conn: ResolvedConnection, req: ChatRequest): AsyncIterable<StreamEvent>;
+    /**
+     * `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.
+     */
+    health(conn: ResolvedConnection): Promise<{
+        ok: boolean;
+        detail?: string;
+    }>;
+    /**
+     * Lists models from Google's `/v1beta/models`. Strips the `models/` name
+     * prefix, and maps `inputTokenLimit` → `contextWindow` and
+     * `supportedGenerationMethods` → `capabilities`.
+     */
+    listModels(conn: ResolvedConnection): Promise<ModelInfo[]>;
 }
 //# sourceMappingURL=google.d.ts.map

package/dist/adapters/engines/google.js

@@ -1,8 +1,8 @@
 import { AIError } from '../../errors.js';
 import { estimatedUsage } from '../../tokens.js';
-import { postResponse, sseLines } from '../../transport.js';
-import { asNumber, asRecord, asString, textFromMessages } from '../../util.js';
-import { streamError, streamTimeout } from './base.js';
+import { fetchJson, postResponse, sseLines } from '../../transport.js';
+import { applyProviderOptions, asNumber, asRecord, asString, joinUrl, textFromMessages } from '../../util.js';
+import { DEFAULT_TIMEOUT_MS, randomId, safeParse, streamAnomaly, streamError, streamTimeout } from './base.js';
 export class GoogleAdapter {
     provider;
     constructor(provider) {
@@ -30,12 +30,23 @@ export class GoogleAdapter {
         const toolCalls = [];
         const timeout = 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 postResponse(streamUrl, body(req), conn.headers, timeout.signal, conn.provider);
             const contentType = res.headers.get('content-type') ?? '';
             const chunks = contentType.includes('text/event-stream') ? sseLines(res) : singleJsonLine(res);
             for await (const line of chunks) {
+                timeout.bump();
                 const parsed = safeParse(line);
                 const record = asRecord(parsed);
                 const promptFeedback = asRecord(record?.promptFeedback);
@@ -44,6 +55,12 @@ export class GoogleAdapter {
                 for (const part of candidateParts(record)) {
                     const partText = asString(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 (asRecord(part)?.thought === true) {
+                            yield { type: 'reasoning', text: partText };
+                            continue;
+                        }
                         if (firstTokenMs === null)
                             firstTokenMs = Date.now() - started;
                         text += partText;
@@ -66,6 +83,8 @@ export class GoogleAdapter {
                 inputTokens = asNumber(usage?.promptTokenCount) ?? inputTokens;
                 outputTokens = asNumber(usage?.candidatesTokenCount) ?? outputTokens;
             }
+            if (!finish)
+                yield streamAnomaly('stream ended without a finishReason');
             const hasTools = toolCalls.length > 0;
             yield { type: 'done', result: {
                     text,
@@ -84,6 +103,61 @@ export class GoogleAdapter {
             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 fetchJson(joinUrl(conn.baseUrl, '/v1beta/models'), {
+                method: 'GET',
+                headers: conn.headers,
+                timeoutMs: Math.min(conn.timeoutMs ?? 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 fetchJson(joinUrl(conn.baseUrl, '/v1beta/models'), {
+            method: 'GET',
+            headers: conn.headers,
+            timeoutMs: Math.min(conn.timeoutMs ?? DEFAULT_TIMEOUT_MS, 15_000),
+            provider: conn.provider,
+        });
+        const rows = Array.isArray(asRecord(data)?.models) ? asRecord(data).models : [];
+        const models = [];
+        for (const value of rows) {
+            const row = asRecord(value);
+            const name = 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 = 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;
+    }
+}
+/** 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');
@@ -110,7 +184,10 @@ function body(req) {
             config.allowedFunctionNames = [req.toolChoice.name];
         payload.toolConfig = { functionCallingConfig: config };
     }
-    return payload;
+    // providerOptions reaches Google-native fields: top-level `safetySettings`,
+    // `cachedContent`, and `generationConfig` extras (`thinkingConfig`,
+    // `responseModalities`, …) merged one level deep into generationConfig.
+    return applyProviderOptions(payload, req.providerOptions, ['generationConfig']);
 }
 function toGoogleContents(messages) {
     const contents = [];
@@ -132,29 +209,27 @@ function toGoogleContents(messages) {
     return contents;
 }
 function toGoogleContent(m) {
-    if (m.role === 'tool') {
-        return {
-            role: 'user',
-            parts: [{ functionResponse: { name: m.name ?? 'unknown', response: toolResponseObject(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 = [];
-        if (typeof m.content === 'string' && m.content)
-            parts.push({ text: m.content });
+        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: typeof m.content === 'string'
-            ? [{ text: m.content }]
-            : m.content.map((part) => part.type === 'image'
-                ? { inlineData: { mimeType: part.mimeType ?? 'image/png', data: part.imageBase64 ?? '' } }
-                : { text: part.text ?? '' }),
+        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;
@@ -203,15 +278,4 @@ function mapFinish(finish, hasTools) {
         return 'content_filter';
     return 'stop';
 }
-function safeParse(line) {
-    try {
-        return JSON.parse(line);
-    }
-    catch {
-        return undefined;
-    }
-}
-function randomId() {
-    return globalThis.crypto?.randomUUID?.() ?? `tool_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-}
 //# sourceMappingURL=google.js.map

package/dist/adapters/engines/ollama.d.ts

@@ -1,10 +1,11 @@
-import type { ChatRequest, ChatResult, ModelInfo, ProviderAdapter, ResolvedConnection, StreamEvent } from '../../types.js';
+import type { ChatRequest, ChatResult, EmbedRequest, EmbedResult, ModelInfo, ProviderAdapter, ResolvedConnection, StreamEvent } from '../../types.js';
 export declare class OllamaAdapter implements ProviderAdapter {
     readonly provider: string;
     constructor(provider: string);
     chat(conn: ResolvedConnection, req: ChatRequest): Promise<ChatResult>;
     stream(conn: ResolvedConnection, req: ChatRequest): AsyncIterable<StreamEvent>;
     listModels(conn: ResolvedConnection): Promise<ModelInfo[]>;
+    embed(conn: ResolvedConnection, req: EmbedRequest): Promise<EmbedResult>;
     private showModel;
 }
 //# sourceMappingURL=ollama.d.ts.map