@causyne/agent 0.0.0-stage → 1.10.0

package/src/providers/gemini.js

@@ -0,0 +1,346 @@
+import { canonicalModelId } from '../modelIds.js';
+import { DEFAULT_MODEL_BY_PROVIDER } from '../modelCatalogue.js';
+import { LLMProvider, mimeTypeForAudioFormat } from './base.js';
+
+// Gemini's FunctionDeclaration schema is an OpenAPI subset, and it is strict in
+// two ways that matter here:
+//   1. `additionalProperties` is not part of the subset.
+//   2. An OBJECT that declares no properties is rejected.
+// Crucially, one bad declaration fails the *entire* request — so a single
+// free-form object anywhere in the 69-tool catalogue takes every tool down with
+// it. `web_fetch.headers` is exactly that shape and web_fetch is a CORE tool,
+// which meant Gemini could not complete step one of any task at all.
+//
+// Rather than delete those parameters and lose the capability, free-form maps
+// travel as JSON strings and are decoded again on the way back, so the tool
+// still receives a real object. The paths that were rewritten are recorded per
+// tool so the decode knows exactly where to look.
+
+const FREE_FORM_NOTE = ' Pass this as a JSON object encoded in a string, for example {"key":"value"}.';
+
+function isEmptyObjectSchema(schema) {
+  return schema
+    && schema.type === 'object'
+    && (!schema.properties || Object.keys(schema.properties).length === 0);
+}
+
+/**
+ * Rewrite one JSON Schema into Gemini's subset.
+ *
+ * @param {object} schema     The source schema.
+ * @param {Array}  path       Segments walked so far; '[]' denotes array items.
+ * @param {Array}  rewritten  Collects the paths converted to JSON strings.
+ * @returns {object} A schema Gemini will accept.
+ */
+function adaptSchemaForGemini(schema, path, rewritten) {
+  if (Array.isArray(schema)) {
+    return schema.map(entry => adaptSchemaForGemini(entry, path, rewritten));
+  }
+  if (schema === null || typeof schema !== 'object') {
+    return schema;
+  }
+
+  const adapted = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === 'additionalProperties') continue;
+
+    if (key === 'properties' && value && typeof value === 'object') {
+      const properties = {};
+      for (const [name, child] of Object.entries(value)) {
+        const childPath = [...path, name];
+        if (isEmptyObjectSchema(child)) {
+          rewritten.push(childPath);
+          properties[name] = {
+            type: 'string',
+            description: (child.description || 'Free-form object.') + FREE_FORM_NOTE
+          };
+        } else {
+          properties[name] = adaptSchemaForGemini(child, childPath, rewritten);
+        }
+      }
+      adapted.properties = properties;
+      continue;
+    }
+
+    if (key === 'items') {
+      adapted.items = adaptSchemaForGemini(value, [...path, '[]'], rewritten);
+      continue;
+    }
+
+    adapted[key] = adaptSchemaForGemini(value, path, rewritten);
+  }
+
+  return adapted;
+}
+
+/** Walk a decoded argument object and JSON.parse the fields that were stringified. */
+function decodeFreeFormArgs(args, paths) {
+  if (!args || paths.length === 0) return args;
+
+  for (const path of paths) {
+    applyAtPath(args, path, value => {
+      if (typeof value !== 'string') return value;
+      try {
+        return JSON.parse(value);
+      } catch (e) {
+        // The model sent something that is not JSON. Hand it through untouched
+        // rather than destroying the argument.
+        return value;
+      }
+    });
+  }
+
+  return args;
+}
+
+function applyAtPath(node, path, transform) {
+  if (node === null || typeof node !== 'object') return;
+
+  const [head, ...rest] = path;
+
+  if (head === '[]') {
+    if (!Array.isArray(node)) return;
+    for (const entry of node) applyAtPath(entry, rest, transform);
+    return;
+  }
+
+  if (rest.length === 0) {
+    if (head in node) node[head] = transform(node[head]);
+    return;
+  }
+
+  applyAtPath(node[head], rest, transform);
+}
+
+/**
+ * Translate Gemini's `usageMetadata` into the OpenAI-shaped object that
+ * `LLMProvider.normalizeUsage()` consumes, so every provider ends up on one
+ * normalisation path instead of Gemini hand-rolling its own.
+ *
+ * TWO BUGS THIS FIXES, both in the cost the user is shown:
+ *
+ * 1. `cachedContentTokenCount` was dropped entirely. Gemini caches implicitly
+ *    on a stable prefix, so the cache WAS working and `calculateCost()` IS
+ *    cache-aware — it was simply fed a zero, and every cached token was
+ *    displayed at the full input rate instead of 0.5x. Overstating the bill is
+ *    how a user concludes Causyne is expensive and goes direct instead.
+ *
+ * 2. `thoughtsTokenCount` was dropped, and thinking tokens ARE billed as
+ *    output ("Response pricing is the sum of output tokens and thinking
+ *    tokens"). That understated the bill — the worse direction, because the
+ *    real invoice then exceeds what Causyne promised.
+ *
+ * WHY `totalTokenCount` IS THE ANCHOR: whether `thoughtsTokenCount` is already
+ * folded into `candidatesTokenCount` DIFFERS BY BACKEND — it is on the Gemini
+ * API and is not on Vertex AI, and reports exist of the Gemini API behaving
+ * both ways across model versions. Deriving completion as `total - prompt` is
+ * correct under either convention; adding thoughts to candidates is correct
+ * under only one and double-counts under the other. The sum is used only when
+ * the total is missing or incoherent, where overstating is the safer error.
+ *
+ * @param   {object} usageMetadata  Gemini's usage block, possibly undefined.
+ * @returns {object}                OpenAI-shaped usage for normalizeUsage().
+ */
+export function geminiUsageToOpenAIShape(usageMetadata) {
+  const prompt = usageMetadata?.promptTokenCount || 0;
+  const candidates = usageMetadata?.candidatesTokenCount || 0;
+  const thoughts = usageMetadata?.thoughtsTokenCount || 0;
+  const total = usageMetadata?.totalTokenCount || 0;
+
+  const completion = total > prompt ? total - prompt : candidates + thoughts;
+
+  return {
+    prompt_tokens: prompt,
+    completion_tokens: completion,
+    // normalizeUsage() clamps this to prompt_tokens, which also protects
+    // against a backend that reports the cached count OUTSIDE the prompt total.
+    prompt_tokens_details: { cached_tokens: usageMetadata?.cachedContentTokenCount || 0 }
+  };
+}
+
+export class GeminiProvider extends LLMProvider {
+  constructor(config) {
+    super(config);
+    this.model = canonicalModelId(config.model || DEFAULT_MODEL_BY_PROVIDER['gemini']);
+    this.baseUrl = `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:generateContent?key=${this.apiKey}`;
+    // Every Gemini model from 1.5 onward accepts image input.
+    this.visionModels = ['gemini-'];
+    this.imagePayloadFormat = 'gemini';
+    // Gemini takes audio the same way it takes images — inlineData with a real
+    // MIME type — across the whole gemini- family, and accepts m4a/aac natively,
+    
+    // smaller than WAV, so it clears the transport ceiling far more often.
+    this.audioModels = ['gemini-'];
+    this.audioPayloadFormat = 'gemini';
+  }
+
+  async chat(messages, options = {}) {
+    messages = this.prepareMessages(messages);
+    // Map OpenAI messages to Gemini contents.
+    // System blocks ACCUMULATE. Assigning instead of appending meant that with
+    // the agent's three-block system stack only the last block survived: the
+    // core SYSTEM_PROMPT, the capability-pack catalogue and every playbook were
+    // silently discarded on every single Gemini request.
+    const systemParts = [];
+    const contents = [];
+
+    for (const msg of messages) {
+      if (msg.role === 'system') {
+        const text = typeof msg.content === 'string'
+          ? msg.content
+          : JSON.stringify(msg.content);
+        if (text) systemParts.push({ text });
+        continue;
+      }
+
+      const role = msg.role === 'assistant' ? 'model' : 'user';
+
+      if (msg.tool_calls) {
+        // The assistant's own words travel with its calls. Dropping the text
+        // meant the model's stated reasoning never re-entered the history.
+        const parts = [];
+        if (msg.content) parts.push({ text: String(msg.content) });
+        for (const tc of msg.tool_calls) {
+          parts.push({
+            functionCall: {
+              name: tc.function.name,
+              args: typeof tc.function.arguments === 'string'
+                ? JSON.parse(tc.function.arguments || '{}')
+                : (tc.function.arguments || {})
+            }
+          });
+        }
+        contents.push({ role, parts });
+      } else if (msg.role === 'tool') {
+        // Add tool response
+        contents.push({
+          role: 'user', // Gemini expects tool responses to come from 'user' or 'function'
+          parts: [{
+            functionResponse: {
+              name: msg.name,
+              response: { result: msg.content }
+            }
+          }]
+        });
+      } else {
+        if (Array.isArray(msg.content)) {
+          const mappedParts = msg.content.map(part => {
+            if (part.type === 'text') return { text: part.text };
+            if (part.type === 'image_url') {
+              const b64 = part.image_url.url.split('base64,')[1];
+              const mime = part.image_url.url.split(';')[0].replace('data:', '');
+              return { inlineData: { mimeType: mime, data: b64 } };
+            }
+            // Anthropic-shaped image block. Without this branch it fell through
+            // to the empty-text default and the image vanished silently.
+            if (part.type === 'image' && part.source?.type === 'base64') {
+              return { inlineData: { mimeType: part.source.media_type, data: part.source.data } };
+            }
+            // Audio normalised by prepareMessages already arrives as inlineData;
+            // this branch covers an input_audio block replayed from history that
+            // predates the normaliser. The MIME type is derived from the clip's
+            // real container instead of the old hardcoded audio/mp4, which
+            
+            if (part.type === 'input_audio') {
+              return {
+                inlineData: {
+                  mimeType: mimeTypeForAudioFormat(part.input_audio?.format),
+                  data: part.input_audio?.data
+                }
+              };
+            }
+            if (part.inlineData) return part;
+            return { text: '' };
+          });
+          contents.push({ role, parts: mappedParts });
+        } else {
+          contents.push({ role, parts: [{ text: msg.content }] });
+        }
+      }
+    }
+
+    const payload = {
+      contents,
+      generationConfig: {
+        temperature: options.temperature || 0.1,
+      }
+    };
+
+    if (systemParts.length > 0) {
+      payload.systemInstruction = { parts: systemParts };
+    }
+
+    // Map tools. freeFormPaths remembers which arguments were stringified so the
+    // response handler can turn them back into objects.
+    const freeFormPaths = new Map();
+
+    if (options.tools && options.tools.length > 0) {
+      payload.tools = [{
+        functionDeclarations: options.tools.map(t => {
+          const toolObj = t.function ? t.function : t;
+          const declaration = {
+            name: toolObj.name,
+            description: toolObj.description || ''
+          };
+
+          const source = toolObj.parameters || toolObj.input_schema;
+          // A tool that takes no arguments must omit `parameters` entirely —
+          // an OBJECT with empty properties is rejected outright.
+          if (source && !isEmptyObjectSchema(source)) {
+            const rewritten = [];
+            declaration.parameters = adaptSchemaForGemini(source, [], rewritten);
+            if (rewritten.length > 0) freeFormPaths.set(toolObj.name, rewritten);
+          }
+
+          return declaration;
+        })
+      }];
+    }
+
+    const response = await fetch(this.baseUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload)
+    });
+
+    if (!response.ok) {
+      const errorData = await response.text();
+      throw new Error(`Gemini API Error (${response.status}): ${errorData}`);
+    }
+
+    const data = await response.json();
+
+    const firstCandidate = data.candidates?.[0];
+    if (!firstCandidate) {
+      throw new Error('No candidate returned from Gemini');
+    }
+
+    let content = '';
+    let toolCalls = [];
+
+    for (const part of firstCandidate.content.parts) {
+      if (part.text) {
+        content += part.text;
+      } else if (part.functionCall) {
+        const args = decodeFreeFormArgs(
+          part.functionCall.args || {},
+          freeFormPaths.get(part.functionCall.name) || []
+        );
+        toolCalls.push({
+          id: `call_${Math.random().toString(36).substr(2, 9)}`,
+          type: 'function',
+          function: {
+            name: part.functionCall.name,
+            arguments: JSON.stringify(args)
+          }
+        });
+      }
+    }
+
+    return {
+      content: content.trim(),
+      toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+      usage: this.normalizeUsage(geminiUsageToOpenAIShape(data.usageMetadata))
+    };
+  }
+}

package/src/providers/moonshot.js

@@ -0,0 +1,73 @@
+import { canonicalModelId } from '../modelIds.js';
+import { DEFAULT_MODEL_BY_PROVIDER } from '../modelCatalogue.js';
+import { LLMProvider } from './base.js';
+
+export class MoonshotProvider extends LLMProvider {
+  constructor(config) {
+    super(config);
+    this.baseUrl = 'https://api.moonshot.ai/v1/chat/completions';
+    this.model = canonicalModelId(config.model || DEFAULT_MODEL_BY_PROVIDER['moonshot']);
+    this.visionModels = ['kimi-k3', 'kimi-k2.5', 'vision'];
+    // Kimi exposes no audio input on the chat completions API.
+    this.audioModels = [];
+  }
+
+  async chat(messages, options = {}) {
+    const sanitizedMessages = this.prepareMessages(messages);
+
+    const payload = {
+      model: this.model,
+      messages: sanitizedMessages,
+      temperature: options.temperature || 0.1,
+    };
+
+    if (options.jsonMode) {
+      payload.response_format = { type: 'json_object' };
+    }
+    
+    let headers = {
+      'Content-Type': 'application/json'
+    };
+
+    if (this.apiKey) {
+      headers['Authorization'] = `Bearer ${this.apiKey}`;
+    } else {
+      // EXPLICIT BYOK CONSTRAINT
+      throw new Error(`Moonshot AI (Kimi) API requires a valid API key (BYOK mode). Please set it in your configuration.`);
+    }
+
+    if (options.tools) {
+      payload.tools = options.tools.map(tool => ({
+        type: 'function',
+        function: tool.function ? tool.function : tool
+      }));
+      payload.tool_choice = "auto";
+    }
+
+    const response = await fetch(this.baseUrl, {
+      method: 'POST',
+      headers: headers,
+      body: JSON.stringify(payload)
+    });
+
+    if (!response.ok) {
+      const errorData = await response.text();
+      throw new Error(`Moonshot AI API Error (${response.status}): ${errorData}`);
+    }
+
+    const data = await response.json();
+    let content = '';
+    let toolCalls = [];
+    
+    if (data.choices && data.choices[0] && data.choices[0].message) {
+        content = data.choices[0].message.content || '';
+        toolCalls = data.choices[0].message.tool_calls || [];
+    }
+    
+    return {
+      content: content,
+      toolCalls: (toolCalls && toolCalls.length > 0) ? toolCalls : undefined,
+      usage: this.normalizeUsage(data.usage || { prompt_tokens: 0, completion_tokens: 0 })
+    };
+  }
+}

package/src/providers/muse.js

@@ -0,0 +1,169 @@
+import { canonicalModelId } from '../modelIds.js';
+import { DEFAULT_MODEL_BY_PROVIDER } from '../modelCatalogue.js';
+import { OpenAICompatibleProvider } from './openai-compatible.js';
+
+/**
+ * Meta Model API — the Muse family.
+ *
+ * Drop-in OpenAI-compatible, so this extends the compatible provider rather
+ * than reimplementing the wire format. Everything below is the part that is
+ * NOT generic: which models can see, which can hear, which reasoning levels a
+ * given tier will actually accept, and how wide the context is.
+ *
+ * Model IDs verified against the live status page (all seven operational):
+ * muse-spark-1.3, muse-spark-1.3-contributor, muse-spark-1.2,
+ * muse-spark-1.2-contributor, muse-spark-1.1, muse-image-1.0,
+ * muse-voice-transcribe-1.0.
+ */
+
+export const MUSE_BASE_URL = 'https://api.meta.ai/v1';
+
+/** Every Muse Spark model shares this. Not a guess — it is the published spec. */
+export const MUSE_CONTEXT_TOKENS = 1_048_576;
+
+/** The image and speech models, which are not chat models and are reached elsewhere. */
+export const MUSE_IMAGE_MODEL = 'muse-image-1.0';
+export const MUSE_TRANSCRIBE_MODEL = 'muse-voice-transcribe-1.0';
+
+/**
+ * Chat models, newest first, with what each one can actually do.
+ *
+ * `audio: false` on 1.3 is not caution, it is the documented state: "Audio
+ * understanding in Muse Spark 1.3 is currently not fully supported, and
+ * response quality for requests including audio content may be degraded."
+ * Advertising it would send a voice clip into a model that answers badly and
+ * charges for it — worse than declining, because the user cannot tell a
+ * degraded answer from a wrong one.
+ */
+export const MUSE_CHAT_MODELS = [
+  { id: 'muse-spark-1.3', tier: 'standard', audio: false, recommended: true },
+  { id: 'muse-spark-1.3-contributor', tier: 'contributor', audio: false },
+  { id: 'muse-spark-1.2', tier: 'standard', audio: true },
+  { id: 'muse-spark-1.2-contributor', tier: 'contributor', audio: true },
+  { id: 'muse-spark-1.1', tier: 'standard', audio: true }
+];
+
+/** Models that accept audio, as bare id prefixes for LLMProvider.supportsAudio. */
+const AUDIO_CAPABLE = MUSE_CHAT_MODELS.filter((m) => m.audio).map((m) => m.id);
+
+/** Is this a Contributor-tier model? Its inputs and outputs train Meta's models. */
+export function isContributorModel(model) {
+  return String(model || '').toLowerCase().endsWith('-contributor');
+}
+
+/**
+ * Reasoning effort the model will actually accept.
+ *
+ * `"max"` is Standard tier only. Sending it to a `-contributor` model is a
+ * rejected request, and a rejected request in the middle of an agent loop looks
+ * to the user like the agent broke — so it is stepped down here, once, where
+ * the reason can be written down.
+ */
+export function clampReasoningEffort(effort, model) {
+  const requested = String(effort || '').toLowerCase();
+  if (!requested || requested === 'off') return requested || null;
+  if (requested === 'max' && isContributorModel(model)) return 'high';
+  return requested;
+}
+
+export class MuseProvider extends OpenAICompatibleProvider {
+  constructor(config) {
+    super(config);
+
+    this.baseUrl = `${MUSE_BASE_URL}/chat/completions`;
+    this.model = canonicalModelId(config.model || DEFAULT_MODEL_BY_PROVIDER['muse']);
+
+    // Every Spark model takes text, image, video and PDF. The prefix covers all
+    // five ids including the -contributor variants, which share the exact same
+    // modalities as their Standard twins.
+    this.visionModels = ['muse-spark'];
+    this.imagePayloadFormat = 'openai';
+
+    // Audio is the one capability that is NOT uniform across the family.
+    this.audioModels = AUDIO_CAPABLE;
+    this.audioPayloadFormat = 'openai';
+
+    // Meta publishes no per-clip ceiling for Muse Spark, so no vendor clamp is
+    
+    // "this vendor adds no limit of its own", not "unlimited".
+    this.maxAudioSeconds = null;
+    this.maxAudioBytes = null;
+
+    this.contextTokens = MUSE_CONTEXT_TOKENS;
+    this.reasoningEffort = clampReasoningEffort(config.reasoningEffort, this.model);
+  }
+
+  /**
+   * The transcription model exists for exactly the case 1.3 creates.
+   *
+   * The recommended chat model cannot hear, and Meta's answer to that is a
+   * dedicated speech-to-text model on the same key and the same base URL. This
+   * is what lets the agent loop offer the user a real route instead of only a
+   * refusal.
+   */
+  audioAlternative() {
+    if (this.supportsAudio) return null;
+    // Keep the tier the user chose: someone on Contributor is there for the
+    // price, and answering "switch to Standard" would quietly multiply it by
+    // twelve.
+    return isContributorModel(this.model) ? 'muse-spark-1.2-contributor' : 'muse-spark-1.2';
+  }
+
+  get transcribeModel() {
+    return MUSE_TRANSCRIBE_MODEL;
+  }
+
+  get transcribeUrl() {
+    return `${MUSE_BASE_URL}/asr/transcribe`;
+  }
+
+  /**
+   * Transcribe a clip with Muse Voice Transcribe.
+   *
+   * THE REQUEST SHAPE IS INFERRED, and that is stated rather than hidden. Meta
+   * documents the endpoint (`POST /v1/asr/transcribe`) and states that Model API
+   * is drop-in compatible with the OpenAI SDK, so this sends the multipart form
+   * that OpenAI's transcription endpoint takes. If that inference is wrong the
+   * request fails, the caller catches it, and the user lands exactly where they
+   * would have without this method — never worse, and told why.
+   *
+   * Returns the transcript, or null when there is nothing to send.
+   */
+  
+  get canTranscribe() {
+    return Boolean(this.apiKey) && process.env.CAUSYNE_MUSE_ASR === '1';
+  }
+
+  async transcribeAudio(base64, mimeType = 'audio/wav') {
+    if (!base64 || !this.apiKey) return null;
+
+    const extension = String(mimeType).includes('mp3') ? 'mp3'
+      : String(mimeType).includes('mp4') || String(mimeType).includes('m4a') ? 'm4a'
+      : String(mimeType).includes('ogg') ? 'ogg'
+      : String(mimeType).includes('webm') ? 'webm'
+      : 'wav';
+
+    const form = new FormData();
+    form.append('model', MUSE_TRANSCRIBE_MODEL);
+    form.append('file', new Blob([Buffer.from(base64, 'base64')], { type: mimeType }), `clip.${extension}`);
+
+    const response = await fetch(this.transcribeUrl, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${this.apiKey}` },
+      body: form
+    });
+
+    if (!response.ok) {
+      const detail = await response.text();
+      throw new Error(`Muse Voice Transcribe (${response.status}): ${detail.slice(0, 400)}`);
+    }
+
+    const data = await response.json();
+    // Accept the shapes a transcription endpoint plausibly answers in, rather
+    // than betting the feature on one field name.
+    const text = data.text
+      || data.transcript
+      || (Array.isArray(data.turns) ? data.turns.map((t) => t.text).filter(Boolean).join(' ') : '');
+    return String(text || '').trim() || null;
+  }
+}

package/src/providers/ollama.js

@@ -0,0 +1,104 @@
+import { canonicalModelId } from '../modelIds.js';
+import { DEFAULT_MODEL_BY_PROVIDER } from '../modelCatalogue.js';
+import { LLMProvider } from './base.js';
+
+export class OllamaProvider extends LLMProvider {
+  constructor(config) {
+    super(config);
+    this.baseUrl = config.baseUrl || 'http://localhost:11434/api/chat';
+    this.model = canonicalModelId(config.model || DEFAULT_MODEL_BY_PROVIDER['ollama']);
+    // Locally installable vision models. Anything else stays text-only, and a
+    // user on an unlisted build can set config.supportsVision explicitly.
+    this.visionModels = ['llava', 'vision', 'bakllava', 'moondream', 'minicpm-v', 'gemma3', 'qwen2.5vl', 'qwen3-vl'];
+    // No local audio model is common enough to pattern-match honestly, and a
+    // wrong guess here fails as an opaque vendor error on the user's own
+    // machine. Left empty: config.supportsAudio is the deliberate opt-in,
+    // mirroring how supportsVision works for unlisted local builds.
+    this.audioModels = [];
+  }
+
+  
+  normalizeImageBlocks(msg) {
+    if (!Array.isArray(msg.content)) return msg;
+
+    const text = [];
+    const images = [];
+
+    for (const block of msg.content) {
+      if (block.type === 'text') {
+        text.push(block.text);
+      } else if (block.type === 'image' && block.source?.type === 'base64') {
+        images.push(block.source.data);
+      } else if (block.type === 'image_url' && typeof block.image_url?.url === 'string') {
+        const encoded = block.image_url.url.split('base64,')[1];
+        if (encoded) images.push(encoded);
+      }
+    }
+
+    const normalized = { ...msg, content: text.join('\n') };
+    if (images.length > 0) normalized.images = images;
+    return normalized;
+  }
+
+  async chat(messages, options = {}) {
+    const sanitizedMessages = this.prepareMessages(messages);
+
+    const payload = {
+      model: this.model,
+      messages: sanitizedMessages,
+      stream: false,
+      options: {
+        temperature: options.temperature || 0.1
+      }
+    };
+    
+    if (options.tools) {
+      payload.tools = options.tools.map(tool => ({
+        type: 'function',
+        function: tool.function ? tool.function : tool
+      }));
+    }
+
+    const response = await fetch(this.baseUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload)
+    });
+
+    if (!response.ok) {
+      const errorData = await response.text();
+      throw new Error(`Ollama API Error (${response.status}): ${errorData}`);
+    }
+
+    const data = await response.json();
+
+    // Ollama returns tool calls with no id. Every stage downstream — the tool
+    // result messages, the approval map, and sanitizeSequences, which filters an
+    // assistant turn's tool_calls against the ids of the results that follow it —
+    // keys on that id. Without one, sanitizeSequences matched nothing and
+    // stripped every tool call out of the history on the very next step, so a
+    // local model lost all memory of the actions it had just taken.
+    const rawToolCalls = data.message?.tool_calls || [];
+    const toolCalls = rawToolCalls.map((call, index) => ({
+      id: call.id || `call_ollama_${Date.now()}_${index}`,
+      type: 'function',
+      function: {
+        name: call.function?.name,
+        // Ollama hands back a parsed object where the OpenAI shape carries a
+        // JSON string. Normalise so the whole pipeline sees one contract.
+        arguments: typeof call.function?.arguments === 'string'
+          ? call.function.arguments
+          : JSON.stringify(call.function?.arguments || {})
+      }
+    }));
+
+    return {
+      content: data.message?.content || '',
+      toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+      usage: {
+        promptTokens: data.prompt_eval_count || 0,
+        completionTokens: data.eval_count || 0
+      }
+    };
+  }
+}