okengine 0.18.5 → 0.19.0

package/src/drivers/ai-ollama-tools.integration.test.ts

@@ -1,109 +0,0 @@
-/**
- * Live Ollama tool-calling through fx.ask → fx.call (capability + ledger).
- *
- * Opt-in via `OKE_TEST_OLLAMA_URL` (reachable Ollama). A local daemon on
- * :11434 is not enough — set the URL explicitly. Never an empty pass.
- */
-
-import { describe, expect, test } from "bun:test";
-import { memoryKvDriver } from "./index.ts";
-import { ai, aiRateGate, createAiRuntime } from "../elements/ai.ts";
-import { createGateRuntime, gate } from "../elements/gate.ts";
-import { createFxContext } from "../kernel/fx.ts";
-import { OLLAMA_DEFAULT_MODEL, openOllama } from "./ai-ollama.ts";
-
-const ENV_URL = process.env.OKE_TEST_OLLAMA_URL?.trim();
-
-async function probeOllama(url: string): Promise<boolean> {
-  try {
-    const res = await fetch(`${url}/api/tags`, { signal: AbortSignal.timeout(1_500) });
-    return res.ok;
-  } catch {
-    return false;
-  }
-}
-
-const reachable = ENV_URL ? await probeOllama(ENV_URL) : false;
-const canLive = Boolean(ENV_URL) && reachable;
-
-if (!canLive) {
-  console.log(
-    ENV_URL
-      ? `skip: live ollama tool-calling e2e (unreachable at ${ENV_URL})`
-      : "skip: live ollama tool-calling e2e (OKE_TEST_OLLAMA_URL not set)",
-  );
-}
-const live = canLive ? test : test.skip;
-
-describe("ollama live — tool-calling via fx.call", () => {
-  live(
-    "gated ask → real tool call → capability ledger portal entry",
-    async () => {
-      const url = ENV_URL!;
-      const model = process.env.OKE_AI_MODEL?.trim() || OLLAMA_DEFAULT_MODEL;
-
-      const kv = await memoryKvDriver.open({ name: "ollama-tools-rate" });
-      const askRate = aiRateGate("ask");
-      const gates = createGateRuntime({
-        gates: [gate.public, askRate],
-        kv,
-        now: () => Date.now(),
-      });
-
-      // Simulate HTTP beforeHandle rate gate (AI ask preset).
-      const allowed = await gates.allow([askRate.name], {
-        auth: { userId: "user-1", scopes: new Set() },
-        operator: { id: null },
-      });
-      expect(allowed).toBe(true);
-
-      const client = await openOllama({ baseUrl: url, model });
-      const smart = ai.model("smart", { provider: "ollama", model });
-      const prompt = smart.prompt("tool-host");
-      const runtime = createAiRuntime({
-        models: [smart],
-        prompts: [prompt],
-        clients: { smart: client },
-        forceJournal: false,
-      });
-
-      const toolInvocations: Array<{ name: string; input: unknown }> = [];
-      const { fx, ledger } = createFxContext({
-        flow: "assistant.chat",
-        effects: {
-          asks: ["tool-host"],
-          calls: ["lookup.echo"],
-        },
-        aiRuntime: runtime,
-        callHandler: async (name, input) => {
-          toolInvocations.push({ name, input });
-          return { ok: true, echoed: input };
-        },
-      });
-
-      await fx.ask(
-        prompt,
-        [
-          "You are a tool-using assistant.",
-          'You MUST call the function lookup.echo with arguments {"text":"pong"}.',
-          "Do not answer in plain text until after the tool has been called.",
-        ].join(" "),
-        { tools: ["lookup.echo"], maxSteps: 4 },
-      );
-
-      expect(toolInvocations.length).toBeGreaterThan(0);
-      expect(toolInvocations.some((c) => c.name === "lookup.echo")).toBe(true);
-      expect(ledger.entries.some((e) => e.kind === "ask" && e.resource === "tool-host")).toBe(true);
-      expect(
-        ledger.entries.some(
-          (e) => e.kind === "call" && e.resource === "lookup.echo" && e.reversibility === "portal",
-        ),
-      ).toBe(true);
-
-      await kv.close();
-    },
-    // Match ai-ollama.integration.test.ts — cold model load on a 6GB+ pull
-    // can exceed a short CI wall clock even when the hot path is ~7s.
-    25 * 60_000,
-  );
-});

package/src/drivers/ai-ollama.integration.test.ts

@@ -1,184 +0,0 @@
-/**
- * Live Ollama round-trip — real prompt, real response, documented default model.
- *
- * Opt-in (never auto-pull a multi-GB model in ordinary `bun test`):
- * 1. `OKE_TEST_OLLAMA_URL` — point at any reachable Ollama
- * 2. `OKE_TEST_OLLAMA_DOCKER=1` — start `ollama/ollama` via the recipe; host-side
- *    `ensureOllamaModel` POSTs `/api/pull` for `qwen3.5:9b` (slow first run)
- *
- * Without one of those, the suite skips with a visible reason (never an empty pass).
- * A local daemon on :11434 is not enough — set `OKE_TEST_OLLAMA_URL` explicitly.
- */
-
-import { afterAll, describe, expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { deriveInfrastructure, writeDerivedFiles } from "../docker/index.ts";
-import { ai } from "../elements/ai.ts";
-import { bindAi } from "../kernel/boot-bind/ai.ts";
-import { OLLAMA_DEFAULT_MODEL, openOllama } from "./ai-ollama.ts";
-
-const OLLAMA_IMAGE = "ollama/ollama:latest";
-const ENV_URL = process.env.OKE_TEST_OLLAMA_URL?.trim();
-const WANT_DOCKER = process.env.OKE_TEST_OLLAMA_DOCKER === "1";
-
-function dockerAvailable(): boolean {
-  try {
-    return Bun.spawnSync(["docker", "info"], { stdout: "pipe", stderr: "pipe" }).exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-
-const DOCKER = dockerAvailable();
-const canLive = Boolean(ENV_URL) || (WANT_DOCKER && DOCKER);
-
-if (!canLive) {
-  const reasons: string[] = [];
-  if (!ENV_URL) reasons.push("OKE_TEST_OLLAMA_URL not set");
-  if (!WANT_DOCKER) reasons.push("OKE_TEST_OLLAMA_DOCKER≠1");
-  else if (!DOCKER) reasons.push("docker daemon not available");
-  console.log(`skip: live ollama e2e (${reasons.join("; ")})`);
-}
-const live = canLive ? test : test.skip;
-
-let cleanup: (() => Promise<void>) | undefined;
-
-afterAll(async () => {
-  if (cleanup) await cleanup();
-});
-
-async function waitForOllama(url: string, timeoutMs: number, requireModel: boolean): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    try {
-      const res = await fetch(`${url}/api/tags`);
-      if (res.ok) {
-        if (!requireModel) return;
-        const body = (await res.json()) as { models?: readonly { name?: string }[] };
-        const names = (body.models ?? []).map((m) => m.name ?? "");
-        if (
-          names.some((n) => n === OLLAMA_DEFAULT_MODEL || n.startsWith(`${OLLAMA_DEFAULT_MODEL}`))
-        ) {
-          return;
-        }
-      }
-    } catch {
-      // still starting
-    }
-    await Bun.sleep(1_000);
-  }
-  throw new Error(
-    `ollama not ready at ${url} within ${timeoutMs}ms${
-      requireModel ? ` (need model ${OLLAMA_DEFAULT_MODEL})` : ""
-    }`,
-  );
-}
-
-async function resolveLiveUrl(): Promise<{ url: string; model: string }> {
-  if (ENV_URL) {
-    await waitForOllama(ENV_URL, 30_000, false);
-    return { url: ENV_URL, model: process.env.OKE_AI_MODEL?.trim() || OLLAMA_DEFAULT_MODEL };
-  }
-
-  const dir = await mkdtemp(join(tmpdir(), "oke-ollama-"));
-  const dockerDir = join(dir, "docker");
-  const project = `oke-ollama-${Date.now()}`;
-  const instanceId = crypto.randomUUID().replace(/-/g, "").slice(0, 6);
-  const derived = deriveInfrastructure({
-    images: { ai: OLLAMA_IMAGE },
-    app: "ollama-e2e",
-    host: "127.0.0.1",
-    includeApp: false,
-    composeDir: "docker",
-    instanceId,
-    controls: { OKE_AI_MODEL: OLLAMA_DEFAULT_MODEL },
-  });
-  await writeDerivedFiles(derived, dockerDir, { writeStackEnv: true });
-
-  const composeFiles = ["compose.yml", "compose.ai.yml"];
-  const up = Bun.spawn(
-    ["docker", "compose", "-p", project, ...composeFiles.flatMap((f) => ["-f", f]), "up", "-d"],
-    {
-      cwd: dockerDir,
-      stdout: "pipe",
-      stderr: "pipe",
-      env: { ...process.env, ...derived.stackEnv, OKE_AI_MODEL: OLLAMA_DEFAULT_MODEL },
-    },
-  );
-  const [upErr, upCode] = await Promise.all([new Response(up.stderr).text(), up.exited]);
-  if (upCode !== 0) {
-    await rm(dir, { recursive: true, force: true });
-    throw new Error(`docker compose up failed: ${upErr}`);
-  }
-
-  const url = derived.stackEnv.OKE_AI_URL!;
-  cleanup = async () => {
-    const down = Bun.spawn(
-      ["docker", "compose", "-p", project, ...composeFiles.flatMap((f) => ["-f", f]), "down", "-v"],
-      { cwd: dockerDir, stdout: "pipe", stderr: "pipe" },
-    );
-    await down.exited;
-    await rm(dir, { recursive: true, force: true });
-  };
-
-  // Serve must answer before we POST /api/pull (same path as `oke dev -d`).
-  await waitForOllama(url, 120_000, false);
-  const { ensureOllamaModel } = await import("../docker/ollama-pull.ts");
-  await ensureOllamaModel({ url, model: OLLAMA_DEFAULT_MODEL });
-  await waitForOllama(url, 60_000, true);
-  return { url, model: OLLAMA_DEFAULT_MODEL };
-}
-
-describe("ollama live — real completion", () => {
-  live(
-    "boots against a real Ollama, completes with a real model, returns a real response",
-    async () => {
-      const { url, model } = await resolveLiveUrl();
-      const prevUrl = process.env.OKE_AI_URL;
-      const prevModel = process.env.OKE_AI_MODEL;
-      process.env.OKE_AI_URL = url;
-      process.env.OKE_AI_MODEL = model;
-
-      try {
-        const smart = ai.model("smart", { provider: "ollama", model });
-        const ping = smart.prompt("ollama-ping", { version: 1 });
-
-        const runtime = bindAi(
-          {
-            config: { drivers: { ai: { test: "ollama", dev: "ollama" } } },
-            ai: { models: [smart], prompts: [ping] },
-          },
-          undefined,
-          () => Date.now(),
-          "test",
-          false,
-        );
-        expect(runtime.prompts.has("ollama-ping")).toBe(true);
-
-        const client = await openOllama({ baseUrl: url, model });
-        const result = await client.complete({
-          messages: [
-            {
-              role: "user",
-              content: "Reply with exactly the single word: pong",
-            },
-          ],
-          temperature: 0,
-          maxTokens: 32,
-        });
-
-        expect(result.driverId).toBe("ollama");
-        expect(result.text.trim().length).toBeGreaterThan(0);
-        expect(result.text.toLowerCase()).toContain("pong");
-      } finally {
-        if (prevUrl === undefined) delete process.env.OKE_AI_URL;
-        else process.env.OKE_AI_URL = prevUrl;
-        if (prevModel === undefined) delete process.env.OKE_AI_MODEL;
-        else process.env.OKE_AI_MODEL = prevModel;
-      }
-    },
-    25 * 60_000,
-  );
-});

package/src/drivers/ai-ollama.ts

@@ -1,389 +0,0 @@
-/**
- * `ollama` AI driver — thin fetch client for the native Ollama HTTP API.
- *
- * Any pulled model works via `model` / `OKE_AI_MODEL`. The documented local-dev
- * default is `qwen3.5:9b` (balanced starting point — override freely; on Apple
- * Silicon consider `qwen3.5:9b-mlx`). Fail-loud:
- * configured but unreachable throws {@link OllamaUnavailableError} — never a
- * silent mock fallback.
- *
- * Native API: `POST /api/chat` and `POST /api/embeddings` (not the OpenAI-compat
- * shim). Default base URL `http://127.0.0.1:11434`. Supports `complete`,
- * `stream` (NDJSON), `embed`, and tools.
- */
-
-import type {
-  AiCompleteOptions,
-  AiCompleteResult,
-  AiDriver,
-  AiEmbedOptions,
-  AiEmbedResult,
-  AiModelClient,
-  AiOpenOptions,
-  AiStreamChunk,
-  AiToolCall,
-} from "./ai-types.ts";
-
-/** Documented local-dev default — override via `model` / `OKE_AI_MODEL`. */
-export const OLLAMA_DEFAULT_MODEL = "qwen3.5:9b";
-
-/** Default Ollama listen URL (host installs + compose host port). */
-export const OLLAMA_DEFAULT_BASE_URL = "http://127.0.0.1:11434";
-
-/** Error thrown when Ollama is unreachable / unhealthy / rejects a call. */
-export class OllamaUnavailableError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "OllamaUnavailableError";
-  }
-}
-
-/**
- * Normalize a base URL or bare `host:port` (as in `OLLAMA_HOST`) to an origin.
- *
- * @param raw - URL or host:port
- */
-export function normalizeOllamaBaseUrl(raw: string): string {
-  const trimmed = raw.trim().replace(/\/$/, "");
-  if (!trimmed) return OLLAMA_DEFAULT_BASE_URL;
-  if (/^https?:\/\//i.test(trimmed)) return trimmed.replace(/\/v1\/?$/i, "");
-  return `http://${trimmed}`;
-}
-
-/**
- * Resolve the Ollama base URL from options / env (never invent a cloud endpoint).
- *
- * @param options - Open options
- */
-export function resolveOllamaBaseUrl(options: AiOpenOptions = {}): string {
-  const raw =
-    options.baseUrl?.trim() ||
-    process.env.OKE_AI_URL?.trim() ||
-    process.env.OLLAMA_HOST?.trim() ||
-    OLLAMA_DEFAULT_BASE_URL;
-  return normalizeOllamaBaseUrl(raw);
-}
-
-/**
- * Resolve the model name — fully configurable; documented default only.
- *
- * @param options - Open options
- * @param override - Per-call model override
- */
-export function resolveOllamaModel(options: AiOpenOptions = {}, override?: string): string {
-  return (
-    override?.trim() ||
-    options.model?.trim() ||
-    process.env.OKE_AI_MODEL?.trim() ||
-    OLLAMA_DEFAULT_MODEL
-  );
-}
-
-/**
- * Open an Ollama chat client. Health-checks `/api/tags` before returning.
- *
- * @param options - model / baseUrl / injectable fetch
- */
-export async function openOllama(options: AiOpenOptions = {}): Promise<AiModelClient> {
-  const baseUrl = resolveOllamaBaseUrl(options);
-  const model = resolveOllamaModel(options);
-  const fetchFn = options.fetch ?? globalThis.fetch;
-
-  await healthCheck(baseUrl, fetchFn);
-
-  return {
-    driverId: "ollama",
-    model,
-    async complete(opts: AiCompleteOptions): Promise<AiCompleteResult> {
-      const resolvedModel = resolveOllamaModel(options, opts.model);
-      const body = buildChatBody(resolvedModel, opts, false);
-
-      let res: Response;
-      try {
-        res = await fetchFn(`${baseUrl}/api/chat`, {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify(body),
-          ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
-        });
-      } catch (err) {
-        if (isAbortError(err)) throw err;
-        throw new OllamaUnavailableError(
-          `ollama: unreachable at ${baseUrl} — ${err instanceof Error ? err.message : String(err)}`,
-        );
-      }
-
-      const raw = (await res.json().catch(() => ({}))) as OllamaChatResponse;
-      if (!res.ok) {
-        const msg = raw.error ?? `ollama HTTP ${res.status}`;
-        throw new OllamaUnavailableError(`ollama: ${msg}`);
-      }
-
-      const text = raw.message?.content ?? "";
-      const toolCalls = parseOllamaToolCalls(raw.message?.tool_calls);
-      return {
-        text,
-        raw,
-        model: raw.model ?? resolvedModel,
-        driverId: "ollama",
-        ...(toolCalls !== undefined ? { toolCalls } : {}),
-        usage: {
-          inputTokens: raw.prompt_eval_count,
-          outputTokens: raw.eval_count,
-        },
-      };
-    },
-    async *stream(opts: AiCompleteOptions): AsyncIterable<AiStreamChunk> {
-      const resolvedModel = resolveOllamaModel(options, opts.model);
-      const body = buildChatBody(resolvedModel, opts, true);
-
-      let res: Response;
-      try {
-        res = await fetchFn(`${baseUrl}/api/chat`, {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify(body),
-          ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
-        });
-      } catch (err) {
-        if (isAbortError(err)) throw err;
-        throw new OllamaUnavailableError(
-          `ollama: unreachable at ${baseUrl} — ${err instanceof Error ? err.message : String(err)}`,
-        );
-      }
-      if (!res.ok) {
-        const raw = (await res.json().catch(() => ({}))) as OllamaChatResponse;
-        const msg = raw.error ?? `ollama HTTP ${res.status}`;
-        throw new OllamaUnavailableError(`ollama: ${msg}`);
-      }
-      yield* readOllamaNdjson(res, opts.signal);
-    },
-    async embed(opts: AiEmbedOptions): Promise<AiEmbedResult> {
-      const resolvedModel = resolveOllamaModel(options, opts.model);
-      const inputs = Array.isArray(opts.input) ? opts.input : [opts.input];
-      const vectors: number[][] = [];
-
-      for (const prompt of inputs) {
-        let res: Response;
-        try {
-          res = await fetchFn(`${baseUrl}/api/embeddings`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ model: resolvedModel, prompt }),
-          });
-        } catch (err) {
-          throw new OllamaUnavailableError(
-            `ollama: unreachable at ${baseUrl} — ${err instanceof Error ? err.message : String(err)}`,
-          );
-        }
-        const raw = (await res.json().catch(() => ({}))) as OllamaEmbedResponse;
-        if (!res.ok) {
-          const msg = raw.error ?? `ollama embed HTTP ${res.status}`;
-          throw new OllamaUnavailableError(`ollama: ${msg}`);
-        }
-        if (!Array.isArray(raw.embedding)) {
-          throw new OllamaUnavailableError("ollama: embed response missing embedding");
-        }
-        vectors.push(raw.embedding);
-      }
-
-      return {
-        vectors,
-        model: resolvedModel,
-        driverId: "ollama",
-      };
-    },
-  };
-}
-
-/** Protocol-named ollama driver. */
-export const ollamaAiDriver: AiDriver = {
-  id: "ollama",
-  open: openOllama,
-};
-
-function buildChatBody(
-  resolvedModel: string,
-  opts: AiCompleteOptions,
-  stream: boolean,
-): Record<string, unknown> {
-  const body: Record<string, unknown> = {
-    model: resolvedModel,
-    messages: opts.messages.map((m) => {
-      const msg: Record<string, unknown> = {
-        role: m.role,
-        content: m.content,
-      };
-      if (m.name !== undefined) msg.name = m.name;
-      if (m.toolCalls !== undefined && m.toolCalls.length > 0) {
-        msg.tool_calls = m.toolCalls.map((tc) => ({
-          type: "function",
-          function: {
-            name: tc.name,
-            arguments: tc.arguments,
-          },
-        }));
-      }
-      return msg;
-    }),
-    stream,
-    // Thinking models (e.g. qwen3 / qwen3.5) otherwise spend the token budget in
-    // `message.thinking` and leave `content` empty — baseline complete
-    // wants the answer text.
-    think: false,
-  };
-  const modelOptions: Record<string, unknown> = {};
-  if (opts.temperature !== undefined) modelOptions.temperature = opts.temperature;
-  if (opts.maxTokens !== undefined) modelOptions.num_predict = opts.maxTokens;
-  if (Object.keys(modelOptions).length > 0) body.options = modelOptions;
-  if (opts.responseFormat !== undefined) body.format = opts.responseFormat;
-  if (opts.tools !== undefined && opts.tools.length > 0) {
-    body.tools = opts.tools.map((t) => ({
-      type: "function",
-      function: {
-        name: t.name,
-        ...(t.description !== undefined ? { description: t.description } : {}),
-        ...(t.parameters !== undefined ? { parameters: t.parameters } : {}),
-      },
-    }));
-  }
-  return body;
-}
-
-function parseOllamaToolCalls(
-  raw: readonly OllamaToolCall[] | undefined,
-): readonly AiToolCall[] | undefined {
-  if (!raw || raw.length === 0) return undefined;
-  return raw.map((tc, i) => ({
-    id: `ollama_call_${i}`,
-    name: tc.function?.name ?? "",
-    arguments: tc.function?.arguments ?? {},
-  }));
-}
-
-/**
- * Parse Ollama NDJSON stream lines via {@link Bun.JSONL.parseChunk}.
- *
- * @param res - Streaming response
- * @param signal - Optional abort
- */
-async function* readOllamaNdjson(
-  res: Response,
-  signal?: AbortSignal,
-): AsyncGenerator<AiStreamChunk> {
-  const reader = res.body?.getReader();
-  if (!reader) {
-    throw new OllamaUnavailableError("ollama: stream response has no body");
-  }
-  const decoder = new TextDecoder();
-  let pending = "";
-  try {
-    while (true) {
-      if (signal?.aborted) throw abortAsError(signal.reason);
-      const { done, value } = await reader.read();
-      if (done) break;
-      pending += decoder.decode(value, { stream: true });
-      const parsed = bunJsonl().parseChunk(pending);
-      pending = pending.slice(parsed.read);
-      for (const row of parsed.values) {
-        const chunk = row as OllamaChatResponse;
-        const delta = chunk.message?.content;
-        if (typeof delta === "string" && delta.length > 0) {
-          yield { text: delta };
-        }
-        if (chunk.done) {
-          yield { text: "", done: true };
-          return;
-        }
-      }
-      if (parsed.error) {
-        const nl = pending.indexOf("\n");
-        if (nl === -1) continue;
-        pending = pending.slice(nl + 1);
-      }
-    }
-    yield { text: "", done: true };
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-interface BunJsonlParse {
-  readonly values: readonly unknown[];
-  readonly read: number;
-  readonly done: boolean;
-  readonly error: unknown;
-}
-
-function bunJsonl(): {
-  parse(text: string): unknown[];
-  parseChunk(text: string): BunJsonlParse;
-} {
-  const jsonl = (
-    Bun as typeof Bun & {
-      JSONL?: { parse: (t: string) => unknown[]; parseChunk: (t: string) => BunJsonlParse };
-    }
-  ).JSONL;
-  if (!jsonl) {
-    throw new Error("ollama: Bun.JSONL is required (Bun >= 1.4.0)");
-  }
-  return jsonl;
-}
-
-/**
- * Probe Ollama — fail loud before the first completion.
- *
- * @param baseUrl - Origin
- * @param fetchFn - Injectable fetch
- */
-async function healthCheck(baseUrl: string, fetchFn: typeof globalThis.fetch): Promise<void> {
-  let res: Response;
-  try {
-    res = await fetchFn(`${baseUrl}/api/tags`, { method: "GET" });
-  } catch (err) {
-    throw new OllamaUnavailableError(
-      `ollama: unreachable at ${baseUrl} — ${err instanceof Error ? err.message : String(err)}`,
-    );
-  }
-  if (!res.ok) {
-    const detail = await res.text().catch(() => "");
-    throw new OllamaUnavailableError(
-      `ollama: health check failed at ${baseUrl}/api/tags (${res.status})${
-        detail ? ` — ${detail.slice(0, 200)}` : ""
-      }`,
-    );
-  }
-}
-
-function isAbortError(err: unknown): boolean {
-  return err instanceof Error && err.name === "AbortError";
-}
-
-function abortAsError(reason?: unknown): Error {
-  if (reason instanceof Error) return reason;
-  const err = new Error(reason !== undefined ? String(reason) : "This operation was aborted");
-  err.name = "AbortError";
-  return err;
-}
-
-interface OllamaToolCall {
-  readonly function?: { readonly name?: string; readonly arguments?: unknown };
-}
-
-interface OllamaChatResponse {
-  readonly model?: string;
-  readonly message?: {
-    readonly role?: string;
-    readonly content?: string;
-    readonly tool_calls?: readonly OllamaToolCall[];
-  };
-  readonly done?: boolean;
-  readonly prompt_eval_count?: number;
-  readonly eval_count?: number;
-  readonly error?: string;
-}
-
-interface OllamaEmbedResponse {
-  readonly embedding?: readonly number[];
-  readonly error?: string;
-}

package/src/drivers/ollama.ts

@@ -1,14 +0,0 @@
-/**
- * Protocol-named re-export — prefer `okengine/drivers/ai-ollama` or
- * `okengine/drivers` (`ollamaAiDriver`). Same surface as {@link ./ai-ollama.ts}.
- */
-export {
-  ollamaAiDriver,
-  openOllama,
-  OllamaUnavailableError,
-  OLLAMA_DEFAULT_MODEL,
-  OLLAMA_DEFAULT_BASE_URL,
-  normalizeOllamaBaseUrl,
-  resolveOllamaBaseUrl,
-  resolveOllamaModel,
-} from "./ai-ollama.ts";