@open-matrix/driver-ollama 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { type InferenceDriver, type DriverCapabilities, type InferRequest, type InferResponse, type HealthResult } from "@open-matrix/inference";
+export interface OllamaDriverConfig {
+    model?: string;
+    baseUrl?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+/** Check if an Ollama model supports native tool calling */
+export declare function modelSupportsTools(model: string): boolean;
+export declare class OllamaDriver implements InferenceDriver {
+    readonly id = "ollama";
+    readonly capabilities: DriverCapabilities;
+    private model;
+    private baseUrl;
+    private maxTokens;
+    private temperature;
+    constructor(config?: OllamaDriverConfig);
+    infer(request: InferRequest): Promise<InferResponse>;
+    health(): Promise<HealthResult>;
+}

package/dist/index.js

@@ -0,0 +1,86 @@
+// @omega/driver-ollama
+// InferenceDriver implementation for the Ollama local inference API.
+// Supports: local models, optional tool calling (model-dependent).
+// ZERO imports from OmegaLLM internals.
+import { InferenceError, } from "@open-matrix/inference";
+/** Check if an Ollama model supports native tool calling */
+export function modelSupportsTools(model) {
+    const toolModels = ["llama3.1", "llama3.2", "mistral", "mixtral", "qwen2.5", "command-r"];
+    return toolModels.some(m => model.toLowerCase().includes(m));
+}
+export class OllamaDriver {
+    id = "ollama";
+    capabilities;
+    model;
+    baseUrl;
+    maxTokens;
+    temperature;
+    constructor(config) {
+        this.model = config?.model ?? process.env.OLLAMA_MODEL ?? "llama3.2";
+        this.baseUrl = config?.baseUrl ?? process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
+        this.maxTokens = config?.maxTokens ?? 4096;
+        this.temperature = config?.temperature ?? 0.7;
+        const hasTools = modelSupportsTools(this.model);
+        this.capabilities = {
+            oracleProtocol: { reentrant: false, supportedOps: [] },
+            tooling: { native: hasTools, format: hasTools ? "ollama" : undefined },
+            session: { multiTurn: false, streaming: false, managedSessions: false, maxContext: 8192 },
+            io: { vision: false, audio: false, structuredOutput: false, fileUpload: false, artifacts: false },
+            transport: { kind: "local-process", latency: "seconds" },
+            mcp: { client: false, server: false },
+        };
+    }
+    async infer(request) {
+        const start = Date.now();
+        const model = request.model ?? this.model;
+        const body = {
+            model,
+            prompt: request.prompt,
+            system: request.systemPrompt,
+            options: {
+                num_predict: request.maxTokens ?? this.maxTokens,
+                temperature: request.temperature ?? this.temperature,
+            },
+            stream: false,
+        };
+        const resp = await fetch(`${this.baseUrl}/api/generate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!resp.ok) {
+            const text = await resp.text();
+            throw new InferenceError(`Ollama API ${resp.status}: ${text}`, this.id, "network");
+        }
+        const data = await resp.json();
+        const latencyMs = Date.now() - start;
+        return {
+            content: data.response ?? "",
+            latencyMs,
+            driverId: this.id,
+            usage: data.eval_count ? {
+                inputTokens: data.prompt_eval_count ?? 0,
+                outputTokens: data.eval_count ?? 0,
+            } : undefined,
+        };
+    }
+    async health() {
+        try {
+            const start = Date.now();
+            const resp = await fetch(`${this.baseUrl}/api/tags`);
+            if (!resp.ok)
+                return { ok: false, message: `HTTP ${resp.status}` };
+            const data = await resp.json();
+            const models = (data.models ?? []).map((m) => m.name);
+            const hasModel = models.some((n) => n.includes(this.model));
+            return {
+                ok: true,
+                latencyMs: Date.now() - start,
+                message: hasModel ? undefined : `Model "${this.model}" not found. Available: ${models.join(", ")}`,
+            };
+        }
+        catch (e) {
+            return { ok: false, message: `Ollama not reachable: ${e.message}` };
+        }
+    }
+}

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@open-matrix/driver-ollama",
+  "version": "0.1.0",
+  "description": "Ollama local inference driver — raw fetch, zero SDK deps",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf dist"
+  },
+  "dependencies": {
+    "@open-matrix/inference": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.5.0"
+  }
+}