@sisu-ai/adapter-ollama 9.0.3 → 10.0.1

package/README.md

@@ -15,14 +15,28 @@ npm i @sisu-ai/adapter-ollama
 
 - Start Ollama locally: `ollama serve`
 - Pull a tools-capable model: `ollama pull llama3.1:latest`
+- Base URL env: `BASE_URL`
+
+## Transport and compatibility
+
+- The adapter now uses the official `ollama` JavaScript client for chat transport.
+- Public Sisu behavior remains stable: normalized messages/tool-calls, streaming events, and image URL-to-base64 preprocessing.
+- `GenerateOptions.toolChoice` semantics are normalized at the adapter layer:
+  - `auto` / `required` keeps all declared tools available to the model
+  - `none` omits tools for that call
+  - named tool choice narrows the sent tool list to that tool
+- Cancellation is propagated for request execution and image preprocessing fetches.
 
 
 ## Usage
 ```ts
-import { ollamaAdapter } from '@sisu-ai/adapter-ollama';
+import { ollamaAdapter, ollamaEmbeddings } from '@sisu-ai/adapter-ollama';
 
 const model = ollamaAdapter({ model: 'llama3.1' });
 // or with custom base URL: { baseUrl: 'http://localhost:11435' }
+
+const embeddings = ollamaEmbeddings({ model: 'embeddinggemma' });
+const vectors = await embeddings.embed(['first text', 'second text']);
 ```
 
 ## Images (Vision)
@@ -103,8 +117,8 @@ await app.handler()(ctx);
 
 ## Notes
 - Tool choice forcing is model-dependent; current loop asks for tools on first turn and plain completion on second.
-- Streaming can be added via Ollama's streaming API if desired.
- - Env: `OLLAMA_BASE_URL` or `BASE_URL` can override the base URL (or pass `baseUrl` in code). Examples may also support a CLI flag `--base-url` to override env.
+- Streaming is supported and mapped to Sisu `token` + final `assistant_message` events.
+ - Env: `BASE_URL` overrides the base URL (or pass `baseUrl` in code). Examples may also support a CLI flag `--base-url` to override env.
 
 
 # Community & Support
@@ -152,9 +166,9 @@ Discover what you can do through examples or documentation. Check it out at http
 - [@sisu-ai/tool-azure-blob](packages/tools/azure-blob/README.md)
 - [@sisu-ai/tool-extract-urls](packages/tools/extract-urls/README.md)
 - [@sisu-ai/tool-github-projects](packages/tools/github-projects/README.md)
+- [@sisu-ai/tool-rag](packages/tools/rag/README.md)
 - [@sisu-ai/tool-summarize-text](packages/tools/summarize-text/README.md)
 - [@sisu-ai/tool-terminal](packages/tools/terminal/README.md)
-- [@sisu-ai/tool-vec-chroma](packages/tools/vec-chroma/README.md)
 - [@sisu-ai/tool-web-fetch](packages/tools/web-fetch/README.md)
 - [@sisu-ai/tool-web-search-duckduckgo](packages/tools/web-search-duckduckgo/README.md)
 - [@sisu-ai/tool-web-search-google](packages/tools/web-search-google/README.md)
@@ -162,6 +176,19 @@ Discover what you can do through examples or documentation. Check it out at http
 - [@sisu-ai/tool-wikipedia](packages/tools/wikipedia/README.md)
 </details>
 
+<details>
+<summary>All RAG packages</summary>
+
+- [@sisu-ai/rag-core](packages/rag/core/README.md)
+</details>
+
+<details>
+<summary>All vector packages</summary>
+
+- [@sisu-ai/vector-core](packages/vector/core/README.md)
+- [@sisu-ai/vector-chroma](packages/vector/chroma/README.md)
+</details>
+
 <details>
 <summary>All examples</summary>
 

package/dist/index.d.ts

@@ -1,7 +1,13 @@
-import type { LLM } from "@sisu-ai/core";
+import type { LLM, EmbeddingsProvider } from "@sisu-ai/core";
 export interface OllamaAdapterOptions {
     model: string;
     baseUrl?: string;
     headers?: Record<string, string>;
 }
+export interface OllamaEmbeddingsOptions {
+    model: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+}
+export declare function ollamaEmbeddings(opts: OllamaEmbeddingsOptions): EmbeddingsProvider;
 export declare function ollamaAdapter(opts: OllamaAdapterOptions): LLM;

package/dist/index.js

@@ -1,26 +1,53 @@
-import { firstConfigValue } from "@sisu-ai/core";
+import { createEmbeddingsClient, firstConfigValue } from "@sisu-ai/core";
+import { Ollama, } from "ollama";
+function resolveBaseUrl(explicitBaseUrl, envBaseUrl, fallback) {
+    const candidate = explicitBaseUrl || envBaseUrl;
+    return (candidate && candidate !== "/" ? candidate : fallback).replace(/\/$/, "");
+}
+export function ollamaEmbeddings(opts) {
+    if (!opts.model) {
+        throw new Error("[ollamaEmbeddings] model is required");
+    }
+    const envBase = firstConfigValue(["BASE_URL", "OLLAMA_BASE_URL"]);
+    const baseUrl = resolveBaseUrl(opts.baseUrl, envBase, "http://localhost:11434");
+    return createEmbeddingsClient({
+        baseUrl,
+        path: "/api/embed",
+        headers: opts.headers,
+        model: opts.model,
+        clientName: "ollamaEmbeddings",
+        parseResponse: (raw) => {
+            const parsed = JSON.parse(raw);
+            return parsed.embeddings ?? [];
+        },
+    });
+}
 export function ollamaAdapter(opts) {
-    const envBase = firstConfigValue(["OLLAMA_BASE_URL", "BASE_URL"]);
-    const baseUrl = (opts.baseUrl ?? envBase ?? "http://localhost:11434").replace(/\/$/, "");
+    const envBase = firstConfigValue(["BASE_URL", "OLLAMA_BASE_URL"]);
+    const baseUrl = resolveBaseUrl(opts.baseUrl, envBase, "http://localhost:11434");
     const modelName = `ollama:${opts.model}`;
+    const client = new Ollama({
+        host: baseUrl,
+        headers: opts.headers,
+    });
     const generate = ((messages, genOpts) => {
         // Map messages to Ollama format; include assistant tool_calls and tool messages
-        async function mapMessagesWithImages() {
+        async function mapMessagesWithImages(signal) {
             const out = [];
             for (const m of messages) {
-                const base = { role: m.role };
+                const base = { role: m.role, content: "" };
                 const anyM = m;
                 if (m.role === "assistant" && Array.isArray(anyM.tool_calls)) {
                     base.tool_calls = anyM.tool_calls.map((tc) => ({
-                        id: tc.id,
-                        type: "function",
-                        function: { name: tc.name, arguments: tc.arguments ?? {} },
+                        function: {
+                            name: tc.name ?? "",
+                            arguments: normalizeToolCallArguments(tc.arguments),
+                        },
                     }));
                     const ti = buildTextAndImages(anyM);
-                    base.content =
-                        ti.content ?? (m.content !== undefined ? m.content : null);
+                    base.content = ti.content ?? String(m.content ?? "");
                     if (ti.images?.length)
-                        base.images = await toBase64Images(ti.images);
+                        base.images = await toBase64Images(ti.images, signal);
                 }
                 else if (m.role === "tool") {
                     base.content = String(m.content ?? "");
@@ -31,9 +58,9 @@ export function ollamaAdapter(opts) {
                 }
                 else {
                     const ti = buildTextAndImages(anyM);
-                    base.content = ti.content ?? m.content ?? "";
+                    base.content = ti.content ?? String(m.content ?? "");
                     if (ti.images?.length)
-                        base.images = await toBase64Images(ti.images);
+                        base.images = await toBase64Images(ti.images, signal);
                     if (m.name)
                         base.name = m.name;
                 }
@@ -43,94 +70,54 @@ export function ollamaAdapter(opts) {
         }
         if (genOpts?.stream === true) {
             return (async function* () {
-                const toolsParam = (genOpts?.tools ?? []).map(toOllamaTool);
-                const mapped = await mapMessagesWithImages();
-                const baseBody = {
-                    model: opts.model,
-                    messages: mapped,
-                };
-                if (toolsParam.length)
-                    baseBody.tools = toolsParam;
-                const res = await fetch(`${baseUrl}/api/chat`, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        Accept: "application/json",
-                        ...(opts.headers ?? {}),
-                    },
-                    body: JSON.stringify({ ...baseBody, stream: true }),
-                });
-                if (!res.ok || !res.body) {
-                    const err = await res.text();
-                    throw new Error(`Ollama API error: ${res.status} ${res.statusText} — ${String(err).slice(0, 500)}`);
-                }
-                const decoder = new TextDecoder();
-                let buf = "";
-                let full = "";
-                for await (const chunk of res.body) {
-                    const piece = typeof chunk === "string" ? chunk : decoder.decode(chunk);
-                    buf += piece;
-                    const lines = buf.split("\n");
-                    buf = lines.pop() ?? "";
-                    for (const line of lines) {
-                        if (!line.trim())
-                            continue;
-                        try {
-                            const j = JSON.parse(line);
-                            if (j.done) {
-                                yield {
-                                    type: "assistant_message",
-                                    message: { role: "assistant", content: full },
-                                };
-                                return;
-                            }
-                            const token = j.message?.content;
-                            if (typeof token === "string" && token) {
-                                full += token;
-                                yield { type: "token", token };
-                            }
+                try {
+                    throwIfAborted(genOpts?.signal);
+                    const toolsParam = buildOllamaTools(genOpts?.tools ?? [], genOpts?.toolChoice);
+                    const mapped = await mapMessagesWithImages(genOpts?.signal);
+                    const request = {
+                        model: opts.model,
+                        messages: mapped,
+                        stream: true,
+                    };
+                    if (toolsParam.length)
+                        request.tools = [...toolsParam];
+                    const stream = await withAbortSignal(() => client.chat(request), genOpts?.signal);
+                    let full = "";
+                    for await (const j of stream) {
+                        throwIfAborted(genOpts?.signal);
+                        if (j.done) {
+                            yield {
+                                type: "assistant_message",
+                                message: { role: "assistant", content: full },
+                            };
+                            return;
                         }
-                        catch (e) {
-                            console.error("[DEBUG_LLM] stream_parse_error", { error: e });
+                        const token = j.message?.content;
+                        if (typeof token === "string" && token) {
+                            full += token;
+                            yield { type: "token", token };
                         }
                     }
                 }
+                catch (error) {
+                    throw mapOllamaError(error);
+                }
             })();
         }
         // Non-stream path
         return (async () => {
-            const toolsParam = (genOpts?.tools ?? []).map(toOllamaTool);
-            const mapped = await mapMessagesWithImages();
-            const baseBody = {
+            const toolsParam = buildOllamaTools(genOpts?.tools ?? [], genOpts?.toolChoice);
+            const mapped = await mapMessagesWithImages(genOpts?.signal);
+            const request = {
                 model: opts.model,
                 messages: mapped,
+                stream: false,
             };
             if (toolsParam.length)
-                baseBody.tools = toolsParam;
-            const res = await fetch(`${baseUrl}/api/chat`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json",
-                    ...(opts.headers ?? {}),
-                },
-                body: JSON.stringify({ ...baseBody, stream: false }),
-            });
-            const raw = await res.text();
-            if (!res.ok) {
-                let details = raw;
-                try {
-                    const j = JSON.parse(raw);
-                    details = j.error ?? j.message ?? raw;
-                }
-                catch (e) {
-                    console.error("[DEBUG_LLM] request_error", { error: e });
-                }
-                throw new Error(`Ollama API error: ${res.status} ${res.statusText} — ${String(details).slice(0, 500)}`);
-            }
-            const data = raw ? JSON.parse(raw) : {};
-            const choice = data
-                .message ?? {};
+                request.tools = [...toolsParam];
+            const data = await withAbortSignal(() => client.chat(request), genOpts?.signal);
+            const choice = data.message ??
+                {};
             const content = choice.content;
             const tcs = Array.isArray(choice.tool_calls)
                 ? choice.tool_calls
@@ -147,7 +134,9 @@ export function ollamaAdapter(opts) {
                 ...(tcs ? { tool_calls: tcs } : {}),
             };
             return { message: out };
-        })();
+        })().catch((error) => {
+            throw mapOllamaError(error);
+        });
     });
     return {
         name: modelName,
@@ -155,6 +144,14 @@ export function ollamaAdapter(opts) {
         generate,
     };
 }
+function mapOllamaError(error) {
+    if (error instanceof Error && error.name === "AbortError") {
+        return error;
+    }
+    return error instanceof Error
+        ? new Error(`Ollama API error: ${error.message.slice(0, 500)}`)
+        : new Error(`Ollama API error: ${String(error).slice(0, 500)}`);
+}
 function toOllamaTool(tool) {
     return {
         type: "function",
@@ -165,6 +162,30 @@ function toOllamaTool(tool) {
         },
     };
 }
+function normalizeToolCallArguments(args) {
+    if (args && typeof args === "object" && !Array.isArray(args)) {
+        return args;
+    }
+    return {};
+}
+function buildOllamaTools(tools, toolChoice) {
+    const mapped = tools.map(toOllamaTool);
+    if (!mapped.length)
+        return mapped;
+    if (!toolChoice || toolChoice === "auto" || toolChoice === "required") {
+        return mapped;
+    }
+    if (toolChoice === "none")
+        return [];
+    const selected = typeof toolChoice === "string"
+        ? toolChoice
+        : typeof toolChoice === "object" && typeof toolChoice.name === "string"
+            ? toolChoice.name
+            : undefined;
+    if (!selected)
+        return mapped;
+    return mapped.filter((tool) => tool.function.name === selected);
+}
 function toJsonSchema(schema) {
     if (!schema)
         return { type: "object" };
@@ -279,12 +300,6 @@ function buildTextAndImages(m) {
     const content = typeof obj.content === "string" ? obj.content : undefined;
     return { content, images: images.length ? images : undefined };
 }
-async function toBase64Images(images) {
-    const out = [];
-    for (const src of images)
-        out.push(await toBase64(src));
-    return out;
-}
 function isHttpUrl(s) {
     return /^https?:\/\//i.test(s);
 }
@@ -303,11 +318,18 @@ function isProbablyBase64(s) {
         return false;
     return /^[A-Za-z0-9+/]+={0,2}$/.test(s);
 }
-async function toBase64(src) {
+async function toBase64Images(images, signal) {
+    const out = [];
+    for (const src of images)
+        out.push(await toBase64(src, signal));
+    return out;
+}
+async function toBase64(src, signal) {
+    throwIfAborted(signal);
     if (isDataUrl(src))
         return fromDataUrl(src);
     if (isHttpUrl(src)) {
-        const res = await fetch(src);
+        const res = await fetch(src, { signal });
         if (!res.ok)
             throw new Error(`Failed to fetch image: ${res.status} ${res.statusText}`);
         const buf = Buffer.from(await res.arrayBuffer());
@@ -315,3 +337,34 @@ async function toBase64(src) {
     }
     return isProbablyBase64(src) ? src : src;
 }
+function createAbortError() {
+    const DomExceptionCtor = globalThis.DOMException;
+    if (typeof DomExceptionCtor === "function") {
+        return new DomExceptionCtor("The operation was aborted.", "AbortError");
+    }
+    const error = new Error("The operation was aborted.");
+    error.name = "AbortError";
+    return error;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw createAbortError();
+}
+async function withAbortSignal(promiseFactory, signal) {
+    throwIfAborted(signal);
+    if (!signal)
+        return promiseFactory();
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(createAbortError());
+        signal.addEventListener("abort", onAbort, { once: true });
+        promiseFactory()
+            .then((value) => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(value);
+        })
+            .catch((error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sisu-ai/adapter-ollama",
-  "version": "9.0.3",
+  "version": "10.0.1",
   "license": "Apache-2.0",
   "type": "module",
   "main": "dist/index.js",
@@ -21,7 +21,10 @@
     "url": "https://github.com/finger-gun/sisu/issues"
   },
   "peerDependencies": {
-    "@sisu-ai/core": "^2.3.3"
+    "@sisu-ai/core": "^2.4.0"
+  },
+  "devDependencies": {
+    "@sisu-ai/core": "2.4.0"
   },
   "keywords": [
     "sisu",
@@ -31,6 +34,9 @@
     "adapter",
     "ollama"
   ],
+  "dependencies": {
+    "ollama": "^0.6.3"
+  },
   "scripts": {
     "build": "tsc -b",
     "clean": "rm -rf dist",