agentic-server 0.24.0 → 0.25.1

package/README.md

@@ -46,6 +46,10 @@ app.listen(3001, () => {
 | GET | `/v1/providers` | List configured providers |
 | GET | `/healthz` | Health check |
 
+## Streaming
+
+`POST /v1/chat/completions` with `stream: true` is relayed as a `text/event-stream`: the gateway forwards the provider's frames verbatim, so a client receives tokens as they are produced. It adds `stream_options: { include_usage: true }` unless the caller set `stream_options` itself, and meters the usage the final frame carries. Streaming is available for OpenAI-compatible providers; a provider whose stream would need translation (`ollama`, `anthropic`) is rejected `501` rather than answered with a non-streaming body.
+
 ## Identity & tenancy
 
 Requests carry tenant identity via headers: `X-Database-Id` (**required** — requests without it are rejected `400`), `X-Entity-Id`, and `X-Actor-Id`. Routing to a specific provider can be forced with `X-LLM-Provider`.

package/esm/router.js

@@ -6,13 +6,46 @@
  *   - Model-based routing: "anthropic/claude-3.5-sonnet" → anthropic provider
  *   - Header-based routing: X-LLM-Provider: ollama → ollama provider
  *   - Fire-and-forget inference metering via an injected InferenceSink
+ *   - Streaming chat completions relayed as server-sent events
  *   - /v1/usage reporting endpoint for external usage submission
  */
 import { Logger } from '@pgpmjs/logger';
 import { Router } from 'express';
 import { buildProviderHeaders, resolveProvider, resolveUpstreamUrl } from './providers';
+import { relayEventStream, withUsageStreamOptions } from './streaming';
 import { transformChatRequest, transformChatResponse, transformEmbedRequest, transformEmbedResponse } from './transforms';
 const log = new Logger('agentic-server');
+/** How long an upstream reason may be before it stops being a message. */
+const UPSTREAM_REASON_LIMIT = 300;
+/**
+ * Name the upstream reason in the message itself.
+ *
+ * Harnesses surface `error.message` and nothing else, so a bare
+ * `LLM provider error: 400` reached a run as an unattributable failure while the
+ * reason — a rejected request shape, a missing key, an unknown model — sat
+ * unread in `error.upstream`.
+ */
+function upstreamErrorMessage(provider, status, body) {
+    const parsed = (() => {
+        try {
+            const error = JSON.parse(body).error;
+            if (typeof error === 'string')
+                return error;
+            const message = error?.message;
+            return typeof message === 'string' ? message : body;
+        }
+        catch {
+            // Not every provider answers an error with JSON; the raw body is the reason.
+            return body;
+        }
+    })().trim().replace(/\s+/g, ' ');
+    const reason = parsed.length > UPSTREAM_REASON_LIMIT
+        ? `${parsed.slice(0, UPSTREAM_REASON_LIMIT)}…`
+        : parsed;
+    return reason
+        ? `${provider.type} provider error ${status}: ${reason}`
+        : `${provider.type} provider error ${status}`;
+}
 export const createRouter = (options) => {
     const router = Router();
     // Metering is backend-agnostic: the caller injects an InferenceSink. When
@@ -36,14 +69,39 @@ export const createRouter = (options) => {
             provider: provider.type,
             model: req.body?.model
         });
+        // Only the OpenAI-compatible wire carries stream frames the gateway can
+        // relay; translating Ollama's or Anthropic's stream formats is separate
+        // work, and answering a stream request with a whole JSON body would break
+        // the client silently.
+        const streaming = req.body?.stream === true;
+        if (streaming && provider.type !== 'openai') {
+            res.status(501).json({
+                error: {
+                    message: `streaming is not supported for provider type '${provider.type}'`
+                }
+            });
+            return;
+        }
         try {
             const upstreamUrl = resolveUpstreamUrl(provider, '/v1/chat/completions');
-            const body = transformChatRequest(provider, req.body || {});
+            const transformed = transformChatRequest(provider, req.body || {});
+            const body = streaming ? withUsageStreamOptions(transformed) : transformed;
             const headers = buildProviderHeaders(provider);
+            const abort = new AbortController();
+            // A client that hangs up mid-stream stops the upstream read; the request
+            // stream's own 'close' fires as soon as the body is consumed, so the
+            // response is what reports the disconnect.
+            if (streaming) {
+                res.on('close', () => {
+                    if (!res.writableEnded)
+                        abort.abort();
+                });
+            }
             const upstream = await fetch(upstreamUrl, {
                 method: 'POST',
                 headers,
-                body: JSON.stringify(body)
+                body: JSON.stringify(body),
+                ...(streaming ? { signal: abort.signal } : {})
             });
             const latencyMs = Number(process.hrtime.bigint() - startTime) / 1e6;
             if (!upstream.ok) {
@@ -63,8 +121,36 @@ export const createRouter = (options) => {
                     });
                 }
                 res.status(upstream.status).json({
-                    error: { message: `LLM provider error: ${upstream.status}`, upstream: text }
+                    error: { message: upstreamErrorMessage(provider, upstream.status, text), upstream: text }
+                });
+                return;
+            }
+            if (streaming) {
+                const streamUsage = await relayEventStream(upstream, res);
+                const streamLatencyMs = Number(process.hrtime.bigint() - startTime) / 1e6;
+                log.info('inference complete', {
+                    databaseId,
+                    provider: provider.type,
+                    model: req.body?.model,
+                    promptTokens: streamUsage?.prompt_tokens,
+                    completionTokens: streamUsage?.completion_tokens,
+                    streamed: true
                 });
+                if (sink) {
+                    sink.logInference({
+                        databaseId, entityId, actorId,
+                        model: String(req.body?.model || body.model || ''),
+                        provider: provider.type,
+                        service: 'chat',
+                        operation: 'chat/completions',
+                        inputTokens: streamUsage?.prompt_tokens || 0,
+                        outputTokens: streamUsage?.completion_tokens || 0,
+                        totalTokens: streamUsage?.total_tokens || 0,
+                        latencyMs: streamLatencyMs,
+                        status: 'ok',
+                        ...(streamUsage ? { rawUsage: streamUsage } : {})
+                    });
+                }
                 return;
             }
             const data = await upstream.json();
@@ -109,6 +195,12 @@ export const createRouter = (options) => {
                     errorType: err.message
                 });
             }
+            // A stream that failed mid-relay has already sent its status and frames;
+            // the client sees the truncated stream rather than a JSON error.
+            if (res.headersSent) {
+                res.end();
+                return;
+            }
             res.status(502).json({
                 error: { message: 'Failed to reach LLM provider', details: err.message }
             });
@@ -154,7 +246,7 @@ export const createRouter = (options) => {
                     });
                 }
                 res.status(upstream.status).json({
-                    error: { message: `LLM provider error: ${upstream.status}`, upstream: text }
+                    error: { message: upstreamErrorMessage(provider, upstream.status, text), upstream: text }
                 });
                 return;
             }

package/esm/streaming.js

@@ -0,0 +1,85 @@
+/**
+ * Server-sent-event passthrough for streaming chat completions.
+ *
+ * The gateway relays an OpenAI-compatible `text/event-stream` body verbatim so
+ * clients receive tokens as the provider emits them, while scanning the frames
+ * for the terminal usage object that metering needs.
+ */
+/** Accumulates SSE frames, exposing the last usage object the stream carried. */
+export class UsageScanner {
+    buffer = '';
+    usage;
+    /** Feed one decoded chunk of the event stream. */
+    push(chunk) {
+        this.buffer += chunk;
+        const frames = this.buffer.split('\n');
+        this.buffer = frames.pop() ?? '';
+        for (const frame of frames) {
+            const line = frame.trim();
+            if (!line.startsWith('data:'))
+                continue;
+            const payload = line.slice('data:'.length).trim();
+            if (payload === '' || payload === '[DONE]')
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(payload);
+            }
+            catch {
+                // A provider frame the gateway cannot parse carries no usage it could
+                // report; relaying is the router's job and happens regardless.
+                continue;
+            }
+            const usage = parsed.usage;
+            if (!usage)
+                continue;
+            this.usage = {
+                prompt_tokens: usage.prompt_tokens ?? 0,
+                completion_tokens: usage.completion_tokens ?? 0,
+                total_tokens: usage.total_tokens ?? (usage.prompt_tokens ?? 0) + (usage.completion_tokens ?? 0)
+            };
+        }
+    }
+    /** The last usage object seen, or undefined when the provider sent none. */
+    result() {
+        return this.usage;
+    }
+}
+/**
+ * Relay an upstream event-stream response to the client byte for byte and
+ * answer the usage its final frame carried, or undefined when it carried none.
+ *
+ * @param upstream - the provider response whose body is being relayed.
+ * @param res - the client response the frames are written to.
+ * @returns the usage the stream reported, if any.
+ */
+export async function relayEventStream(upstream, res) {
+    res.setHeader('Content-Type', upstream.headers.get('content-type') ?? 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders?.();
+    const scanner = new UsageScanner();
+    if (upstream.body) {
+        const decoder = new TextDecoder();
+        const reader = upstream.body.getReader();
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const text = decoder.decode(value, { stream: true });
+            scanner.push(text);
+            res.write(text);
+        }
+    }
+    res.end();
+    return scanner.result();
+}
+/**
+ * Ask an OpenAI-compatible provider to include usage in its final frame.
+ * Callers that already set `stream_options` keep their own choice.
+ */
+export function withUsageStreamOptions(body) {
+    if (body.stream_options !== undefined)
+        return body;
+    return { ...body, stream_options: { include_usage: true } };
+}

package/esm/transforms.js

@@ -1,3 +1,47 @@
+/**
+ * Flatten OpenAI content parts into the single string Ollama's chat api takes.
+ *
+ * Harnesses send `content` as an array of parts — pi always does — and Ollama
+ * answers that with `json: cannot unmarshal array into Go struct field
+ * ChatRequest.messages.content of type string`, which reaches the harness as a
+ * bare `400` and reads as a broken model rather than a dialect mismatch. Image
+ * parts move to Ollama's own `images` field; a part this cannot express fails
+ * loudly rather than being dropped into a prompt the model never sees.
+ */
+function flattenContentParts(messages) {
+    if (!Array.isArray(messages))
+        return messages;
+    return messages.map((message) => {
+        if (!Array.isArray(message.content))
+            return message;
+        const text = [];
+        const images = [];
+        for (const part of message.content) {
+            if (part.type === 'text' || part.type === 'input_text') {
+                text.push(part.text ?? '');
+                continue;
+            }
+            if (part.type === 'image_url') {
+                const url = part.image_url?.url;
+                if (!url)
+                    throw new Error('ollama: an image_url content part carries no url');
+                // Ollama takes base64 bytes, never a fetchable url.
+                const base64 = /^data:[^;]*;base64,(.*)$/.exec(url)?.[1];
+                if (!base64) {
+                    throw new Error('ollama: an image content part must be a base64 data url');
+                }
+                images.push(base64);
+                continue;
+            }
+            throw new Error(`ollama: unsupported content part type '${part.type}'`);
+        }
+        return {
+            ...message,
+            content: text.join('\n'),
+            ...(images.length ? { images: [...(message.images ?? []), ...images] } : {})
+        };
+    });
+}
 export function transformChatRequest(provider, body) {
     let model = body.model || provider.defaultModel;
     if (typeof model === 'string' && model.includes('/')) {
@@ -9,7 +53,7 @@ export function transformChatRequest(provider, body) {
     if (provider.type === 'ollama') {
         return {
             model: model || 'llama3',
-            messages: body.messages,
+            messages: flattenContentParts(body.messages),
             stream: false,
             ...(body.temperature !== undefined && {
                 options: { temperature: body.temperature }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-server",
-  "version": "0.24.0",
+  "version": "0.25.1",
   "description": "Standalone OpenAI-compatible LLM gateway — multi-provider proxy with pluggable inference metering",
   "main": "index.js",
   "module": "esm/index.js",
@@ -51,5 +51,5 @@
     "metering",
     "constructive"
   ],
-  "gitHead": "b5b6b9f05276b7e9cbd3d1f4acd31dd315c353ea"
+  "gitHead": "f9611d3a1ba8bdb50a39b5bca7c9a7115df96e34"
 }

package/router.d.ts

@@ -6,6 +6,7 @@
  *   - Model-based routing: "anthropic/claude-3.5-sonnet" → anthropic provider
  *   - Header-based routing: X-LLM-Provider: ollama → ollama provider
  *   - Fire-and-forget inference metering via an injected InferenceSink
+ *   - Streaming chat completions relayed as server-sent events
  *   - /v1/usage reporting endpoint for external usage submission
  */
 import { Router } from 'express';

package/router.js

@@ -7,6 +7,7 @@
  *   - Model-based routing: "anthropic/claude-3.5-sonnet" → anthropic provider
  *   - Header-based routing: X-LLM-Provider: ollama → ollama provider
  *   - Fire-and-forget inference metering via an injected InferenceSink
+ *   - Streaming chat completions relayed as server-sent events
  *   - /v1/usage reporting endpoint for external usage submission
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -14,8 +15,40 @@ exports.createRouter = void 0;
 const logger_1 = require("@pgpmjs/logger");
 const express_1 = require("express");
 const providers_1 = require("./providers");
+const streaming_1 = require("./streaming");
 const transforms_1 = require("./transforms");
 const log = new logger_1.Logger('agentic-server');
+/** How long an upstream reason may be before it stops being a message. */
+const UPSTREAM_REASON_LIMIT = 300;
+/**
+ * Name the upstream reason in the message itself.
+ *
+ * Harnesses surface `error.message` and nothing else, so a bare
+ * `LLM provider error: 400` reached a run as an unattributable failure while the
+ * reason — a rejected request shape, a missing key, an unknown model — sat
+ * unread in `error.upstream`.
+ */
+function upstreamErrorMessage(provider, status, body) {
+    const parsed = (() => {
+        try {
+            const error = JSON.parse(body).error;
+            if (typeof error === 'string')
+                return error;
+            const message = error?.message;
+            return typeof message === 'string' ? message : body;
+        }
+        catch {
+            // Not every provider answers an error with JSON; the raw body is the reason.
+            return body;
+        }
+    })().trim().replace(/\s+/g, ' ');
+    const reason = parsed.length > UPSTREAM_REASON_LIMIT
+        ? `${parsed.slice(0, UPSTREAM_REASON_LIMIT)}…`
+        : parsed;
+    return reason
+        ? `${provider.type} provider error ${status}: ${reason}`
+        : `${provider.type} provider error ${status}`;
+}
 const createRouter = (options) => {
     const router = (0, express_1.Router)();
     // Metering is backend-agnostic: the caller injects an InferenceSink. When
@@ -39,14 +72,39 @@ const createRouter = (options) => {
             provider: provider.type,
             model: req.body?.model
         });
+        // Only the OpenAI-compatible wire carries stream frames the gateway can
+        // relay; translating Ollama's or Anthropic's stream formats is separate
+        // work, and answering a stream request with a whole JSON body would break
+        // the client silently.
+        const streaming = req.body?.stream === true;
+        if (streaming && provider.type !== 'openai') {
+            res.status(501).json({
+                error: {
+                    message: `streaming is not supported for provider type '${provider.type}'`
+                }
+            });
+            return;
+        }
         try {
             const upstreamUrl = (0, providers_1.resolveUpstreamUrl)(provider, '/v1/chat/completions');
-            const body = (0, transforms_1.transformChatRequest)(provider, req.body || {});
+            const transformed = (0, transforms_1.transformChatRequest)(provider, req.body || {});
+            const body = streaming ? (0, streaming_1.withUsageStreamOptions)(transformed) : transformed;
             const headers = (0, providers_1.buildProviderHeaders)(provider);
+            const abort = new AbortController();
+            // A client that hangs up mid-stream stops the upstream read; the request
+            // stream's own 'close' fires as soon as the body is consumed, so the
+            // response is what reports the disconnect.
+            if (streaming) {
+                res.on('close', () => {
+                    if (!res.writableEnded)
+                        abort.abort();
+                });
+            }
             const upstream = await fetch(upstreamUrl, {
                 method: 'POST',
                 headers,
-                body: JSON.stringify(body)
+                body: JSON.stringify(body),
+                ...(streaming ? { signal: abort.signal } : {})
             });
             const latencyMs = Number(process.hrtime.bigint() - startTime) / 1e6;
             if (!upstream.ok) {
@@ -66,8 +124,36 @@ const createRouter = (options) => {
                     });
                 }
                 res.status(upstream.status).json({
-                    error: { message: `LLM provider error: ${upstream.status}`, upstream: text }
+                    error: { message: upstreamErrorMessage(provider, upstream.status, text), upstream: text }
+                });
+                return;
+            }
+            if (streaming) {
+                const streamUsage = await (0, streaming_1.relayEventStream)(upstream, res);
+                const streamLatencyMs = Number(process.hrtime.bigint() - startTime) / 1e6;
+                log.info('inference complete', {
+                    databaseId,
+                    provider: provider.type,
+                    model: req.body?.model,
+                    promptTokens: streamUsage?.prompt_tokens,
+                    completionTokens: streamUsage?.completion_tokens,
+                    streamed: true
                 });
+                if (sink) {
+                    sink.logInference({
+                        databaseId, entityId, actorId,
+                        model: String(req.body?.model || body.model || ''),
+                        provider: provider.type,
+                        service: 'chat',
+                        operation: 'chat/completions',
+                        inputTokens: streamUsage?.prompt_tokens || 0,
+                        outputTokens: streamUsage?.completion_tokens || 0,
+                        totalTokens: streamUsage?.total_tokens || 0,
+                        latencyMs: streamLatencyMs,
+                        status: 'ok',
+                        ...(streamUsage ? { rawUsage: streamUsage } : {})
+                    });
+                }
                 return;
             }
             const data = await upstream.json();
@@ -112,6 +198,12 @@ const createRouter = (options) => {
                     errorType: err.message
                 });
             }
+            // A stream that failed mid-relay has already sent its status and frames;
+            // the client sees the truncated stream rather than a JSON error.
+            if (res.headersSent) {
+                res.end();
+                return;
+            }
             res.status(502).json({
                 error: { message: 'Failed to reach LLM provider', details: err.message }
             });
@@ -157,7 +249,7 @@ const createRouter = (options) => {
                     });
                 }
                 res.status(upstream.status).json({
-                    error: { message: `LLM provider error: ${upstream.status}`, upstream: text }
+                    error: { message: upstreamErrorMessage(provider, upstream.status, text), upstream: text }
                 });
                 return;
             }

package/streaming.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Server-sent-event passthrough for streaming chat completions.
+ *
+ * The gateway relays an OpenAI-compatible `text/event-stream` body verbatim so
+ * clients receive tokens as the provider emits them, while scanning the frames
+ * for the terminal usage object that metering needs.
+ */
+import type { UsageResult } from './types';
+/** Accumulates SSE frames, exposing the last usage object the stream carried. */
+export declare class UsageScanner {
+    private buffer;
+    private usage;
+    /** Feed one decoded chunk of the event stream. */
+    push(chunk: string): void;
+    /** The last usage object seen, or undefined when the provider sent none. */
+    result(): UsageResult | undefined;
+}
+/**
+ * Relay an upstream event-stream response to the client byte for byte and
+ * answer the usage its final frame carried, or undefined when it carried none.
+ *
+ * @param upstream - the provider response whose body is being relayed.
+ * @param res - the client response the frames are written to.
+ * @returns the usage the stream reported, if any.
+ */
+export declare function relayEventStream(upstream: {
+    body: ReadableStream<Uint8Array> | null;
+    headers: {
+        get(name: string): string | null;
+    };
+}, res: {
+    setHeader(name: string, value: string): void;
+    flushHeaders?(): void;
+    write(chunk: string): void;
+    end(): void;
+}): Promise<UsageResult | undefined>;
+/**
+ * Ask an OpenAI-compatible provider to include usage in its final frame.
+ * Callers that already set `stream_options` keep their own choice.
+ */
+export declare function withUsageStreamOptions(body: Record<string, unknown>): Record<string, unknown>;

package/streaming.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * Server-sent-event passthrough for streaming chat completions.
+ *
+ * The gateway relays an OpenAI-compatible `text/event-stream` body verbatim so
+ * clients receive tokens as the provider emits them, while scanning the frames
+ * for the terminal usage object that metering needs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageScanner = void 0;
+exports.relayEventStream = relayEventStream;
+exports.withUsageStreamOptions = withUsageStreamOptions;
+/** Accumulates SSE frames, exposing the last usage object the stream carried. */
+class UsageScanner {
+    buffer = '';
+    usage;
+    /** Feed one decoded chunk of the event stream. */
+    push(chunk) {
+        this.buffer += chunk;
+        const frames = this.buffer.split('\n');
+        this.buffer = frames.pop() ?? '';
+        for (const frame of frames) {
+            const line = frame.trim();
+            if (!line.startsWith('data:'))
+                continue;
+            const payload = line.slice('data:'.length).trim();
+            if (payload === '' || payload === '[DONE]')
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(payload);
+            }
+            catch {
+                // A provider frame the gateway cannot parse carries no usage it could
+                // report; relaying is the router's job and happens regardless.
+                continue;
+            }
+            const usage = parsed.usage;
+            if (!usage)
+                continue;
+            this.usage = {
+                prompt_tokens: usage.prompt_tokens ?? 0,
+                completion_tokens: usage.completion_tokens ?? 0,
+                total_tokens: usage.total_tokens ?? (usage.prompt_tokens ?? 0) + (usage.completion_tokens ?? 0)
+            };
+        }
+    }
+    /** The last usage object seen, or undefined when the provider sent none. */
+    result() {
+        return this.usage;
+    }
+}
+exports.UsageScanner = UsageScanner;
+/**
+ * Relay an upstream event-stream response to the client byte for byte and
+ * answer the usage its final frame carried, or undefined when it carried none.
+ *
+ * @param upstream - the provider response whose body is being relayed.
+ * @param res - the client response the frames are written to.
+ * @returns the usage the stream reported, if any.
+ */
+async function relayEventStream(upstream, res) {
+    res.setHeader('Content-Type', upstream.headers.get('content-type') ?? 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders?.();
+    const scanner = new UsageScanner();
+    if (upstream.body) {
+        const decoder = new TextDecoder();
+        const reader = upstream.body.getReader();
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const text = decoder.decode(value, { stream: true });
+            scanner.push(text);
+            res.write(text);
+        }
+    }
+    res.end();
+    return scanner.result();
+}
+/**
+ * Ask an OpenAI-compatible provider to include usage in its final frame.
+ * Callers that already set `stream_options` keep their own choice.
+ */
+function withUsageStreamOptions(body) {
+    if (body.stream_options !== undefined)
+        return body;
+    return { ...body, stream_options: { include_usage: true } };
+}

package/transforms.js

@@ -4,6 +4,50 @@ exports.transformChatRequest = transformChatRequest;
 exports.transformEmbedRequest = transformEmbedRequest;
 exports.transformChatResponse = transformChatResponse;
 exports.transformEmbedResponse = transformEmbedResponse;
+/**
+ * Flatten OpenAI content parts into the single string Ollama's chat api takes.
+ *
+ * Harnesses send `content` as an array of parts — pi always does — and Ollama
+ * answers that with `json: cannot unmarshal array into Go struct field
+ * ChatRequest.messages.content of type string`, which reaches the harness as a
+ * bare `400` and reads as a broken model rather than a dialect mismatch. Image
+ * parts move to Ollama's own `images` field; a part this cannot express fails
+ * loudly rather than being dropped into a prompt the model never sees.
+ */
+function flattenContentParts(messages) {
+    if (!Array.isArray(messages))
+        return messages;
+    return messages.map((message) => {
+        if (!Array.isArray(message.content))
+            return message;
+        const text = [];
+        const images = [];
+        for (const part of message.content) {
+            if (part.type === 'text' || part.type === 'input_text') {
+                text.push(part.text ?? '');
+                continue;
+            }
+            if (part.type === 'image_url') {
+                const url = part.image_url?.url;
+                if (!url)
+                    throw new Error('ollama: an image_url content part carries no url');
+                // Ollama takes base64 bytes, never a fetchable url.
+                const base64 = /^data:[^;]*;base64,(.*)$/.exec(url)?.[1];
+                if (!base64) {
+                    throw new Error('ollama: an image content part must be a base64 data url');
+                }
+                images.push(base64);
+                continue;
+            }
+            throw new Error(`ollama: unsupported content part type '${part.type}'`);
+        }
+        return {
+            ...message,
+            content: text.join('\n'),
+            ...(images.length ? { images: [...(message.images ?? []), ...images] } : {})
+        };
+    });
+}
 function transformChatRequest(provider, body) {
     let model = body.model || provider.defaultModel;
     if (typeof model === 'string' && model.includes('/')) {
@@ -15,7 +59,7 @@ function transformChatRequest(provider, body) {
     if (provider.type === 'ollama') {
         return {
             model: model || 'llama3',
-            messages: body.messages,
+            messages: flattenContentParts(body.messages),
             stream: false,
             ...(body.temperature !== undefined && {
                 options: { temperature: body.temperature }