@theoremjs/agents 0.0.0-stage → 0.3.0

package/esm/src/providers/openrouter/chat.js

@@ -0,0 +1,490 @@
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { AISDKError, APICallError, generateText, jsonSchema, RetryError, StreamProviderError, streamText, tool, } from 'ai';
+import { isAbortError, kindOfHttpStatus, TheoremError, toErrorEvent, } from '../../guardrails/error.js';
+import { asRecord } from '../../kernel/engine/record.js';
+import { reportedTokens, usageCount } from '../../kernel/engine/usage.js';
+import { turnStopFromOpenAiFinishReason } from '../../kernel/stop.js';
+import { builtinWire } from '../shared/builtin-wire.js';
+import { foldResponse } from '../shared/response-identity.js';
+import { structuredEvent } from '../shared/structured-output.js';
+import { malformedToolCall, toolCallEvents } from '../shared/tool-args.js';
+import { networkError } from '../shared/upstream-tap.js';
+import { bearerFetch } from '../shared/vault.js';
+import { cacheControlJson } from './cache-control.js';
+import { openAiGatewayHeaders, resolveResponseFormat } from './openai/compat.js';
+import { buildAiSdkMessages } from './openai/sdk-messages.js';
+import { openAiResponse, openAiUsageTokens } from './openai/usage.js';
+import { resolveOpenAiGatewayApiKey } from './resolve-api-key.js';
+export function trimApiKey(explicitKey) {
+    if (explicitKey?.trim()) {
+        return explicitKey.trim();
+    }
+    return undefined;
+}
+export function createAccumulator() {
+    return {
+        text: '',
+        citedUris: new Set(),
+        reportedAnnotations: new Set(),
+        emittedTokens: false,
+        errored: false,
+    };
+}
+function webSource(uri, title) {
+    return { title: title || uri, uri, type: 'web' };
+}
+function citationEvent(sources, acc) {
+    const fresh = [];
+    for (const source of sources) {
+        if (acc.citedUris.has(source.uri))
+            continue;
+        acc.citedUris.add(source.uri);
+        fresh.push(source);
+    }
+    return fresh.length > 0 ? { type: 'citation', sources: fresh } : undefined;
+}
+export function sourceEvent(part, acc) {
+    if (part.sourceType === 'url') {
+        return citationEvent([webSource(part.url, part.title)], acc);
+    }
+    return {
+        type: 'evidence',
+        evidence: { provider: 'openrouter', kind: 'provider_step', step: 'source', raw: { ...part } },
+    };
+}
+export function schemaForTool(decl) {
+    return decl.parameters ?? { type: 'object', properties: {}, additionalProperties: true };
+}
+export function buildTools(wireTools) {
+    if (!wireTools || wireTools.length === 0) {
+        return undefined;
+    }
+    const tools = {};
+    for (const decl of wireTools) {
+        tools[decl.name] = tool({
+            description: decl.description,
+            inputSchema: jsonSchema(schemaForTool(decl)),
+        });
+    }
+    return tools;
+}
+/** `web` wires as `web_search_options`; every other builtin is a plugin. */
+function openRouterSettings(req) {
+    let webSearch = false;
+    const plugins = [];
+    for (const builtin of req.builtins) {
+        const pluginId = builtinWire(builtin, 'openRouter');
+        if (pluginId === 'web')
+            webSearch = true;
+        else
+            plugins.push({ id: pluginId });
+    }
+    if (plugins.length === 0 && !webSearch) {
+        return undefined;
+    }
+    const settings = {};
+    if (plugins.length > 0) {
+        settings.plugins = plugins;
+    }
+    if (webSearch)
+        settings.web_search_options = {};
+    return settings;
+}
+/** Only when the raw stream carried no `usage` row; `rawEvents` reads that one first, with cost. */
+export function tokensFromUsage(usage) {
+    return reportedTokens({
+        input: usageCount(usage.inputTokens),
+        output: usageCount(usage.outputTokens),
+        thinking: usageCount(usage.outputTokenDetails?.reasoningTokens),
+        cached: usageCount(usage.inputTokenDetails?.cacheReadTokens),
+        cacheWrite: usageCount(usage.inputTokenDetails?.cacheWriteTokens),
+    });
+}
+export function stringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const out = value.filter((item) => typeof item === 'string');
+    return out.length > 0 ? out : undefined;
+}
+export function metadataRecord(raw, key) {
+    return asRecord(raw[key]);
+}
+export function citationCandidates(raw) {
+    const openrouter = metadataRecord(raw, 'openrouter') ?? {};
+    return [
+        raw.citations,
+        metadataRecord(raw, 'providerMetadata')?.citations,
+        metadataRecord(raw, 'provider_metadata')?.citations,
+        openrouter.citations,
+        metadataRecord(openrouter, 'providerMetadata')?.citations,
+        metadataRecord(openrouter, 'provider_metadata')?.citations,
+    ];
+}
+export function nestedCitations(raw) {
+    for (const candidate of citationCandidates(raw)) {
+        const citations = stringArray(candidate);
+        if (citations) {
+            return citations;
+        }
+    }
+    return undefined;
+}
+export function metadataAnnotations(raw) {
+    const openrouter = metadataRecord(raw, 'openrouter');
+    if (Array.isArray(raw.annotations)) {
+        return raw.annotations;
+    }
+    if (Array.isArray(openrouter?.annotations)) {
+        return openrouter.annotations;
+    }
+    return undefined;
+}
+function annotationSource(annotation) {
+    const record = asRecord(annotation);
+    const cited = asRecord(record?.url_citation);
+    if (record?.type !== 'url_citation' || typeof cited?.url !== 'string') {
+        return undefined;
+    }
+    return webSource(cited.url, typeof cited.title === 'string' ? cited.title : undefined);
+}
+/** Each citation or annotation reports once per call, however many rows repeat it. */
+export function eventsFromMetadata(metadata, acc) {
+    const raw = asRecord(metadata);
+    if (!raw) {
+        return [];
+    }
+    const annotations = metadataAnnotations(raw) ?? [];
+    const sources = (nestedCitations(raw) ?? []).map((uri) => webSource(uri));
+    const other = [];
+    for (const annotation of annotations) {
+        const source = annotationSource(annotation);
+        if (source) {
+            sources.push(source);
+            continue;
+        }
+        const key = String(JSON.stringify(annotation));
+        if (acc.reportedAnnotations.has(key))
+            continue;
+        acc.reportedAnnotations.add(key);
+        other.push(annotation);
+    }
+    const events = [];
+    const citation = citationEvent(sources, acc);
+    if (citation) {
+        events.push(citation);
+    }
+    if (other.length > 0) {
+        events.push({
+            type: 'evidence',
+            evidence: {
+                provider: 'openrouter',
+                kind: 'provider_step',
+                step: 'annotations',
+                raw: { annotations: other },
+            },
+        });
+    }
+    return events;
+}
+export function rawThoughtEvent(raw) {
+    const choices = raw.choices;
+    if (!Array.isArray(choices)) {
+        return undefined;
+    }
+    for (const choice of choices) {
+        const delta = asRecord(asRecord(choice)?.delta);
+        if (typeof delta?.thinking === 'string') {
+            return { type: 'thought', text: delta.thinking };
+        }
+    }
+    return undefined;
+}
+export function rawChoiceMessageEvents(raw, acc) {
+    const choices = Array.isArray(raw.choices) ? raw.choices : [];
+    return choices.flatMap((choice) => eventsFromMetadata(asRecord(choice)?.message, acc));
+}
+export function rawEvents(raw, acc) {
+    const record = asRecord(raw);
+    if (!record) {
+        return [];
+    }
+    const identity = foldResponse(acc.response, openAiResponse(record));
+    acc.response = identity.known;
+    const events = identity.event ? [identity.event] : [];
+    const thought = rawThoughtEvent(record);
+    if (thought) {
+        events.push(thought);
+    }
+    events.push(...eventsFromMetadata(record, acc), ...rawChoiceMessageEvents(record, acc));
+    if (!acc.emittedTokens) {
+        const usage = openAiUsageTokens(record.usage);
+        if (usage) {
+            acc.emittedTokens = true;
+            events.push({ type: 'tokens', tokens: usage });
+        }
+    }
+    const choices = Array.isArray(record.choices) ? record.choices : [];
+    for (const choice of choices) {
+        const row = asRecord(choice);
+        if (!row)
+            continue;
+        if (typeof row.finish_reason === 'string' || row.finish_reason === null) {
+            acc.finishReason = row.finish_reason;
+        }
+        if (typeof row.native_finish_reason === 'string' || row.native_finish_reason === null) {
+            acc.nativeFinishReason = row.native_finish_reason;
+        }
+    }
+    return events;
+}
+/** A call the SDK could not parse or match is the call with no arguments, then its failure. */
+export function toolCallPartEvents(part) {
+    if (part.invalid) {
+        const message = part.error instanceof Error ? part.error.message : 'tool call was not valid';
+        return malformedToolCall({ name: part.toolName, callId: part.toolCallId }, message, part.input);
+    }
+    return toolCallEvents({ id: part.toolCallId, name: part.toolName }, part.input);
+}
+export function tokenEvent(part) {
+    const tokens = tokensFromUsage(part.totalUsage);
+    return tokens ? { type: 'tokens', tokens } : undefined;
+}
+export function providerMetadataEvents(part, acc) {
+    return 'providerMetadata' in part ? eventsFromMetadata(part.providerMetadata, acc) : [];
+}
+export function eventFromPart(part, acc) {
+    return [...primaryEventsFromPart(part, acc), ...providerMetadataEvents(part, acc)];
+}
+export function primaryEventsFromPart(part, acc) {
+    switch (part.type) {
+        case 'text-delta':
+            acc.text += part.text;
+            return [{ type: 'text', text: part.text }];
+        case 'reasoning-delta':
+            return [{ type: 'thought', text: part.text }];
+        case 'tool-call':
+            return toolCallPartEvents(part);
+        case 'source': {
+            const event = sourceEvent(part, acc);
+            return event ? [event] : [];
+        }
+        case 'finish': {
+            const event = finishEvent(part, acc);
+            return event ? [event] : [];
+        }
+        case 'error':
+            acc.errored = true;
+            return [toErrorEvent(streamPartError(part.error))];
+        default:
+            return [];
+    }
+}
+export function finishEvent(part, acc) {
+    if (part.finishReason != null) {
+        acc.finishReason = String(part.finishReason);
+    }
+    if (acc.emittedTokens) {
+        return undefined;
+    }
+    if (!part.totalUsage) {
+        return undefined;
+    }
+    const event = tokenEvent({ totalUsage: part.totalUsage });
+    if (event) {
+        acc.emittedTokens = true;
+    }
+    return event;
+}
+export function* finalEvents(req, acc) {
+    if (acc.errored) {
+        return;
+    }
+    if (req.structured && acc.text) {
+        const event = structuredEvent(acc.text);
+        yield event;
+        if (event.type === 'error')
+            return;
+    }
+    yield {
+        type: 'done',
+        stop: turnStopFromOpenAiFinishReason(acc.finishReason, acc.nativeFinishReason),
+    };
+}
+function createStreamContext(req, config, apiKey) {
+    const openrouter = createOpenRouter({
+        apiKey,
+        baseURL: config.baseUrl,
+        headers: openAiGatewayHeaders(config),
+        // The AI SDK retries internally; tapping its fetch tapes every try.
+        fetch: bearerFetch(req, config.fetch ?? fetch, config.vault, apiKey),
+        compatibility: 'strict',
+    });
+    return {
+        openrouter,
+        modelName: req.apiId,
+    };
+}
+/** System via instructions XOR a cache-marked system message — never both. */
+export function systemDelivery(req) {
+    if (!req.system) {
+        return {};
+    }
+    if (req.cache?.mode === 'system') {
+        return {
+            systemMessage: {
+                role: 'system',
+                content: req.system,
+                providerOptions: {
+                    openrouter: { cacheControl: cacheControlJson(req.cache) },
+                },
+            },
+        };
+    }
+    return { instructions: req.system };
+}
+function streamTextOptions(req, context) {
+    const delivery = systemDelivery(req);
+    const messages = buildAiSdkMessages(req);
+    if (delivery.systemMessage) {
+        messages.unshift(delivery.systemMessage);
+    }
+    return {
+        model: context.openrouter.chat(context.modelName, openRouterSettings(req)),
+        instructions: delivery.instructions,
+        messages,
+        allowSystemInMessages: true,
+        temperature: req.temperature,
+        maxOutputTokens: req.maxOutputTokens,
+        tools: buildTools(req.wireTools),
+        providerOptions: providerOptionsFor(req),
+        include: { rawChunks: true },
+        abortSignal: req.signal,
+        onError: () => undefined,
+    };
+}
+function shouldEmitProviderEvent(req, event) {
+    return event.type !== 'thought' || req.summaries !== 'none';
+}
+async function* yieldAiSdkStream(req, acc, context) {
+    const result = streamText(streamTextOptions(req, context));
+    for await (const part of result.stream) {
+        if (part.type === 'raw') {
+            req.tapUpstream?.(asRecord(part.rawValue) ?? { rawValue: part.rawValue });
+            for (const event of rawEvents(part.rawValue, acc)) {
+                if (shouldEmitProviderEvent(req, event)) {
+                    yield event;
+                }
+            }
+            continue;
+        }
+        for (const event of eventFromPart(part, acc)) {
+            if (shouldEmitProviderEvent(req, event)) {
+                yield event;
+            }
+        }
+    }
+}
+async function* yieldAiSdkBuffered(req, acc, context) {
+    const { include: _, onError: __, ...options } = streamTextOptions(req, context);
+    const result = await generateText({ ...options, include: { responseBody: true } });
+    const body = asRecord(result.response.body);
+    if (body) {
+        req.tapUpstream?.(body);
+        yield* rawEvents(body, acc).filter((event) => shouldEmitProviderEvent(req, event));
+    }
+    for (const part of result.content) {
+        const events = part.type === 'text'
+            ? [{ type: 'text', text: part.text }]
+            : part.type === 'reasoning'
+                ? [{ type: 'thought', text: part.text }]
+                : part.type === 'tool-call' || part.type === 'source'
+                    ? primaryEventsFromPart(part, acc)
+                    : [];
+        if (part.type === 'text')
+            acc.text += part.text;
+        yield* events.filter((event) => shouldEmitProviderEvent(req, event));
+    }
+    yield* eventsFromMetadata(result.providerMetadata, acc).filter((event) => shouldEmitProviderEvent(req, event));
+    const tokens = finishEvent(result, acc);
+    if (tokens)
+        yield tokens;
+}
+async function* streamOpenRouter(req, config) {
+    let apiKey;
+    try {
+        apiKey = resolveOpenAiGatewayApiKey(config, req.keySlot);
+    }
+    catch (err) {
+        yield toErrorEvent(err);
+        return;
+    }
+    const acc = createAccumulator();
+    const context = createStreamContext(req, config, apiKey);
+    try {
+        yield* req.stream === false
+            ? yieldAiSdkBuffered(req, acc, context)
+            : yieldAiSdkStream(req, acc, context);
+        yield* finalEvents(req, acc);
+    }
+    catch (err) {
+        if (isAbortError(err)) {
+            throw err;
+        }
+        yield toErrorEvent(sdkError(err));
+    }
+}
+/**
+ * An HTTP status wins; a call with no response could not reach OpenRouter; a
+ * mid-stream error without a status is OpenRouter's own; any other SDK error is
+ * a reply the SDK could not read.
+ */
+function sdkError(err) {
+    if (RetryError.isInstance(err)) {
+        return sdkError(err.lastError);
+    }
+    if (!AISDKError.isInstance(err)) {
+        return err;
+    }
+    const status = asRecord(err)?.statusCode;
+    const kind = typeof status === 'number'
+        ? kindOfHttpStatus(status)
+        : APICallError.isInstance(err)
+            ? 'network'
+            : StreamProviderError.isInstance(err)
+                ? 'unavailable'
+                : 'bad_response';
+    return new TheoremError(kind, err.message, { cause: err });
+}
+/** A body that breaks mid-read arrives as a plain error, not an SDK one. */
+function streamPartError(error) {
+    return AISDKError.isInstance(error) || RetryError.isInstance(error)
+        ? sdkError(error)
+        : networkError(error);
+}
+export function providerOptionsFor(req) {
+    const openrouter = {};
+    if (req.thinking) {
+        openrouter.reasoning = { effort: req.thinking };
+    }
+    const responseFormat = resolveResponseFormat(req.structured);
+    if (responseFormat) {
+        openrouter.response_format = responseFormat;
+        // Route only to endpoints that honour the schema; one that ignores it answers in prose.
+        openrouter.provider = { require_parameters: true };
+    }
+    if (req.cache?.mode === 'automatic') {
+        openrouter.cacheControl = cacheControlJson(req.cache);
+    }
+    if (req.sessionId) {
+        openrouter.session_id = req.sessionId;
+    }
+    if (Object.keys(openrouter).length === 0)
+        return undefined;
+    return { openrouter };
+}
+export function createOpenRouterProvider(config = {}) {
+    return {
+        complete: (req) => streamOpenRouter(req, config),
+    };
+}

package/esm/src/providers/openrouter/image.d.ts

@@ -0,0 +1,24 @@
+import type { ModelProvider, ProviderCompleteRequest, ProviderEvent } from '../../kernel/types.js';
+import type { OpenAiGatewayTransport } from '../types.js';
+export declare const OPENROUTER_IMAGE_TOOL = "openrouter:image_generation";
+export type ImageProviderConfig = OpenAiGatewayTransport;
+export declare function buildImageHeaders(apiKey: string, config: ImageProviderConfig): Record<string, string>;
+/** `/images` answers `data[]` of `b64_json` + `media_type` (probe 23/09/2026, bytedance-seed/seedream-4.5). */
+export declare function imagesFromImagesBody(body: Record<string, unknown>): {
+    mimeType: string;
+    data: string;
+}[];
+/**
+ * OpenRouter returns chat images on `message.images[]` as `{ type: 'image_url', image_url: { url } }`
+ * with a base64 data url; `message.content` holds only the text (probe 23/09/2026,
+ * gemini-3.1-flash-lite with the image generation tool).
+ */
+export declare function imagesFromChatMessage(message: Record<string, unknown>): {
+    mimeType: string;
+    data: string;
+}[];
+export declare function buildInterleavedChatPayload(req: ProviderCompleteRequest): Record<string, unknown>;
+export declare function yieldInterleavedChat(req: ProviderCompleteRequest, config: ImageProviderConfig, apiKey: string): AsyncGenerator<ProviderEvent>;
+export declare function yieldImagesEndpoint(req: ProviderCompleteRequest, config: ImageProviderConfig, apiKey: string): AsyncGenerator<ProviderEvent>;
+export declare function streamImage(req: ProviderCompleteRequest, config?: ImageProviderConfig): AsyncGenerator<ProviderEvent>;
+export declare function createImageProvider(config?: ImageProviderConfig): ModelProvider;

package/esm/src/providers/openrouter/image.js

@@ -0,0 +1,187 @@
+import { TheoremError, toErrorEvent } from '../../guardrails/error.js';
+import { asRecord, nonEmptyString } from '../../kernel/engine/record.js';
+import { turnStopFromOpenAiFinishReason } from '../../kernel/stop.js';
+import { networkFetch } from '../shared/upstream-tap.js';
+import { bearerFetch } from '../shared/vault.js';
+import { buildChatMessages, httpErrorEvent, openAiGatewayHeaders } from './openai/compat.js';
+import { buildImagesPayload, extractPromptText, imageToolParameters, } from './openai/image-payload.js';
+import { openAiUsageTokens } from './openai/usage.js';
+import { resolveOpenAiGatewayApiKey } from './resolve-api-key.js';
+const HTTP_OK = 200;
+export const OPENROUTER_IMAGE_TOOL = 'openrouter:image_generation';
+export function buildImageHeaders(apiKey, config) {
+    const headers = {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+    };
+    const gateway = openAiGatewayHeaders(config);
+    if (gateway) {
+        Object.assign(headers, gateway);
+    }
+    return headers;
+}
+function baseUrl(config) {
+    return config.baseUrl?.replace(/\/+$/, '') ?? 'https://openrouter.ai/api/v1';
+}
+function* yieldUsage(raw) {
+    const tokens = openAiUsageTokens(raw);
+    if (!tokens) {
+        return;
+    }
+    yield { type: 'tokens', tokens };
+}
+/** `/images` answers `data[]` of `b64_json` + `media_type` (probe 23/09/2026, bytedance-seed/seedream-4.5). */
+export function imagesFromImagesBody(body) {
+    const entries = Array.isArray(body.data) ? body.data : [];
+    return entries.flatMap((value) => {
+        const entry = asRecord(value);
+        const data = nonEmptyString(entry?.b64_json);
+        const mimeType = nonEmptyString(entry?.media_type);
+        return data && mimeType ? [{ mimeType, data }] : [];
+    });
+}
+function mediaFromDataUrl(url) {
+    if (typeof url !== 'string') {
+        return undefined;
+    }
+    const match = /^data:([^;,]+);base64,(.+)$/s.exec(url);
+    if (!match?.[1] || !match[2]) {
+        return undefined;
+    }
+    return { mimeType: match[1], data: match[2] };
+}
+/**
+ * OpenRouter returns chat images on `message.images[]` as `{ type: 'image_url', image_url: { url } }`
+ * with a base64 data url; `message.content` holds only the text (probe 23/09/2026,
+ * gemini-3.1-flash-lite with the image generation tool).
+ */
+export function imagesFromChatMessage(message) {
+    const images = Array.isArray(message.images) ? message.images : [];
+    return images.flatMap((entry) => {
+        const media = mediaFromDataUrl(asRecord(asRecord(entry)?.image_url)?.url);
+        return media ? [media] : [];
+    });
+}
+async function postJson(req, config, apiKey, path, body) {
+    const fetchFn = bearerFetch(req, networkFetch(config.fetch ?? fetch), config.vault, apiKey);
+    return await fetchFn(`${baseUrl(config)}${path}`, {
+        method: 'POST',
+        headers: buildImageHeaders(apiKey, config),
+        body: JSON.stringify(body),
+        signal: req.signal,
+    });
+}
+async function readTapedJson(req, res) {
+    const body = (await res.json());
+    req.tapUpstream?.(body);
+    return body;
+}
+async function requestImages(req, config, apiKey) {
+    return await postJson(req, config, apiKey, '/images', buildImagesPayload(req));
+}
+export function buildInterleavedChatPayload(req) {
+    if (!req.image) {
+        throw new Error('buildInterleavedChatPayload requires req.image');
+    }
+    return {
+        model: req.apiId,
+        stream: false,
+        messages: buildChatMessages(req),
+        temperature: req.temperature,
+        max_tokens: req.maxOutputTokens,
+        ...(req.thinking ? { reasoning: { effort: req.thinking } } : {}),
+        tools: [
+            {
+                type: OPENROUTER_IMAGE_TOOL,
+                parameters: imageToolParameters(req.image),
+            },
+        ],
+    };
+}
+async function requestInterleavedChat(req, config, apiKey) {
+    return await postJson(req, config, apiKey, '/chat/completions', buildInterleavedChatPayload(req));
+}
+export async function* yieldInterleavedChat(req, config, apiKey) {
+    const res = await requestInterleavedChat(req, config, apiKey);
+    if (res.status !== HTTP_OK) {
+        yield await httpErrorEvent(res, 'Image chat');
+        return;
+    }
+    const body = await readTapedJson(req, res);
+    const choices = body.choices;
+    if (!Array.isArray(choices) || choices.length === 0) {
+        yield toErrorEvent(new TheoremError('bad_response', 'no chat choices returned for image generation'));
+        return;
+    }
+    const choice = asRecord(choices[0]);
+    const message = asRecord(choice?.message);
+    if (!message) {
+        yield toErrorEvent(new TheoremError('bad_response', 'no assistant message returned for image generation'));
+        return;
+    }
+    const text = nonEmptyString(message.content);
+    if (text) {
+        yield { type: 'text', text };
+    }
+    const images = imagesFromChatMessage(message);
+    if (images.length === 0) {
+        yield toErrorEvent(new TheoremError('bad_response', 'no image returned from chat image generation'));
+        return;
+    }
+    for (const media of images) {
+        yield { type: 'media', media };
+    }
+    yield* yieldUsage(body.usage);
+    yield {
+        type: 'done',
+        stop: turnStopFromOpenAiFinishReason(typeof choice?.finish_reason === 'string' ? choice.finish_reason : undefined, typeof choice?.native_finish_reason === 'string' ? choice.native_finish_reason : undefined),
+    };
+}
+export async function* yieldImagesEndpoint(req, config, apiKey) {
+    const res = await requestImages(req, config, apiKey);
+    if (res.status !== HTTP_OK) {
+        yield await httpErrorEvent(res, 'Image');
+        return;
+    }
+    const body = await readTapedJson(req, res);
+    const images = imagesFromImagesBody(body);
+    if (images.length === 0) {
+        yield toErrorEvent(new TheoremError('bad_response', 'no image returned from image generation'));
+        return;
+    }
+    for (const media of images) {
+        yield { type: 'media', media };
+    }
+    yield* yieldUsage(body.usage);
+    // The endpoint answers whole or not at all: a body with images completed.
+    yield { type: 'done', stop: { kind: 'completed' } };
+}
+export async function* streamImage(req, config = {}) {
+    let apiKey;
+    try {
+        apiKey = resolveOpenAiGatewayApiKey(config, req.keySlot);
+    }
+    catch (err) {
+        yield toErrorEvent(err);
+        return;
+    }
+    if (!req.image) {
+        yield toErrorEvent(new TheoremError('request', 'missing image response format'));
+        return;
+    }
+    const prompt = extractPromptText(req.input);
+    if (!prompt) {
+        yield toErrorEvent(new TheoremError('request', 'empty text for image generation'));
+        return;
+    }
+    if (req.image.includeText) {
+        yield* yieldInterleavedChat(req, config, apiKey);
+        return;
+    }
+    yield* yieldImagesEndpoint(req, config, apiKey);
+}
+export function createImageProvider(config = {}) {
+    return {
+        complete: (req) => streamImage(req, config),
+    };
+}