@cogitator-ai/test-utils 0.2.20 → 0.3.1

package/dist/conformance/wires/anthropic.js

@@ -0,0 +1,139 @@
+import { CONFORMANCE_FIXTURE as F, } from '../scenarios.js';
+import { sse } from './encoding.js';
+const anthropicError = (status, type, message, headers) => ({
+    type: 'json',
+    status,
+    ...(headers && { headers }),
+    body: { type: 'error', error: { type, message }, request_id: 'req_conformance' },
+});
+/** The error types of the Messages API (platform.claude.com/docs/en/api/errors). */
+const ANTHROPIC_ERRORS = {
+    'rate-limit': anthropicError(429, 'rate_limit_error', 'Number of requests has exceeded your rate limit', {
+        'retry-after': String(F.retryAfterSeconds),
+    }),
+    quota: anthropicError(400, 'invalid_request_error', 'Your credit balance is too low to access the Anthropic API.'),
+    auth: anthropicError(401, 'authentication_error', 'invalid x-api-key'),
+    overloaded: anthropicError(529, 'overloaded_error', 'Overloaded'),
+    'server-error': anthropicError(500, 'api_error', 'Internal server error'),
+    'context-overflow': anthropicError(400, 'invalid_request_error', 'prompt is too long: 210000 tokens > 200000 maximum'),
+};
+const TURNS = {
+    text: { text: F.text, stopReason: 'end_turn' },
+    'tool-call': { toolInput: JSON.stringify(F.toolCall.arguments), stopReason: 'tool_use' },
+    'tool-call-with-stop': {
+        toolInput: JSON.stringify(F.toolCall.arguments),
+        stopReason: 'end_turn',
+    },
+    'truncated-tool-call': { toolInput: F.truncatedArguments, stopReason: 'max_tokens' },
+    'content-filter': { stopReason: 'refusal' },
+};
+const MESSAGE = {
+    id: 'msg_conformance',
+    type: 'message',
+    role: 'assistant',
+    model: 'conformance',
+    stop_sequence: null,
+};
+function message(turn) {
+    const content = [];
+    if (turn.text)
+        content.push({ type: 'text', text: turn.text });
+    if (turn.toolInput !== undefined) {
+        content.push({
+            type: 'tool_use',
+            id: F.toolCall.id,
+            name: F.toolCall.name,
+            input: safeJson(turn.toolInput),
+        });
+    }
+    return {
+        ...MESSAGE,
+        content,
+        stop_reason: turn.stopReason,
+        usage: { input_tokens: F.usage.inputTokens, output_tokens: F.usage.outputTokens },
+    };
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return {};
+    }
+}
+const event = (type, data) => sse({ type, ...data }, type);
+const messageStart = event('message_start', {
+    message: {
+        ...MESSAGE,
+        content: [],
+        stop_reason: null,
+        usage: { input_tokens: F.usage.inputTokens, output_tokens: 1 },
+    },
+});
+const textStart = (text) => [
+    event('content_block_start', { index: 0, content_block: { type: 'text', text: '' } }),
+    event('content_block_delta', { index: 0, delta: { type: 'text_delta', text } }),
+];
+function stream(turn) {
+    const events = [messageStart];
+    let index = 0;
+    if (turn.text) {
+        events.push(event('content_block_start', { index, content_block: { type: 'text', text: '' } }), ...F.textChunks.map((text) => event('content_block_delta', { index, delta: { type: 'text_delta', text } })), event('content_block_stop', { index }));
+        index++;
+    }
+    if (turn.toolInput !== undefined) {
+        const half = Math.ceil(turn.toolInput.length / 2);
+        events.push(event('content_block_start', {
+            index,
+            content_block: { type: 'tool_use', id: F.toolCall.id, name: F.toolCall.name, input: {} },
+        }), event('content_block_delta', {
+            index,
+            delta: { type: 'input_json_delta', partial_json: turn.toolInput.slice(0, half) },
+        }), event('content_block_delta', {
+            index,
+            delta: { type: 'input_json_delta', partial_json: turn.toolInput.slice(half) },
+        }), event('content_block_stop', { index }));
+    }
+    events.push(event('message_delta', {
+        delta: { stop_reason: turn.stopReason, stop_sequence: null },
+        usage: { output_tokens: F.usage.outputTokens },
+    }), event('message_stop', {}));
+    return events;
+}
+/**
+ * The Anthropic Messages API at `/v1/messages`. An error inside a stream that began is an
+ * `error` event, as the API sends an overload after the response started.
+ */
+export const anthropicWire = {
+    name: 'Anthropic Messages',
+    path: () => /\/v1\/messages$/,
+    reply(scenario, mode) {
+        const error = ANTHROPIC_ERRORS[scenario];
+        if (error)
+            return error;
+        const streamed = (chunks, hang = false) => ({
+            type: 'stream',
+            contentType: 'text/event-stream',
+            chunks,
+            hang,
+        });
+        switch (scenario) {
+            case 'stream-error':
+                return streamed([
+                    messageStart,
+                    ...textStart(F.partialText),
+                    event('error', { error: { type: 'overloaded_error', message: 'Overloaded' } }),
+                ]);
+            case 'abort':
+                return mode === 'chat'
+                    ? { type: 'hang' }
+                    : streamed([messageStart, ...textStart(F.partialText)], true);
+            default: {
+                const turn = TURNS[scenario];
+                if (!turn)
+                    return undefined;
+                return mode === 'chat' ? { type: 'json', body: message(turn) } : streamed(stream(turn));
+            }
+        }
+    },
+};

package/dist/conformance/wires/bedrock.d.ts

@@ -0,0 +1,8 @@
+import { type ProviderWire } from '../scenarios.js';
+/**
+ * Bedrock Runtime's Converse and ConverseStream (`/model/{id}/converse`, `/converse-stream`),
+ * streaming in the AWS event stream encoding. An error inside a stream that began is an
+ * exception message, such as `serviceUnavailableException`.
+ */
+export declare const bedrockConverseWire: ProviderWire;
+//# sourceMappingURL=bedrock.d.ts.map

package/dist/conformance/wires/bedrock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bedrock.d.ts","sourceRoot":"","sources":["../../../src/conformance/wires/bedrock.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AA6ItB;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,YA+BjC,CAAC"}

package/dist/conformance/wires/bedrock.js

@@ -0,0 +1,129 @@
+import { CONFORMANCE_FIXTURE as F, } from '../scenarios.js';
+import { awsEventStreamMessage } from './encoding.js';
+const bedrockError = (status, exception, message, headers) => ({
+    type: 'json',
+    status,
+    headers: {
+        'x-amzn-errortype': `${exception}:http://internal.amazon.com/coral/com.amazon.bedrock/`,
+        ...headers,
+    },
+    body: { __type: exception, message },
+});
+/** The exceptions of the Bedrock Runtime API, with the statuses it sends them with. */
+const BEDROCK_ERRORS = {
+    'rate-limit': bedrockError(429, 'ThrottlingException', 'Too many requests, please wait.', {
+        'retry-after': String(F.retryAfterSeconds),
+    }),
+    quota: bedrockError(400, 'ServiceQuotaExceededException', 'Your request exceeds the service quota for your account.'),
+    auth: bedrockError(403, 'UnrecognizedClientException', 'The security token included in the request is invalid.'),
+    overloaded: bedrockError(503, 'ServiceUnavailableException', 'Service unavailable. Try again later.'),
+    'server-error': bedrockError(500, 'InternalServerException', 'Internal server error.'),
+    'context-overflow': bedrockError(400, 'ValidationException', 'Input is too long for requested model.'),
+};
+const TURNS = {
+    text: { text: F.text, stopReason: 'end_turn' },
+    'tool-call': { toolInput: JSON.stringify(F.toolCall.arguments), stopReason: 'tool_use' },
+    'tool-call-with-stop': {
+        toolInput: JSON.stringify(F.toolCall.arguments),
+        stopReason: 'end_turn',
+    },
+    'truncated-tool-call': { toolInput: F.truncatedArguments, stopReason: 'max_tokens' },
+    'content-filter': { stopReason: 'content_filtered' },
+};
+const USAGE = {
+    inputTokens: F.usage.inputTokens,
+    outputTokens: F.usage.outputTokens,
+    totalTokens: F.usage.inputTokens + F.usage.outputTokens,
+};
+const event = (type, payload) => awsEventStreamMessage({ ':event-type': type, ':content-type': 'application/json', ':message-type': 'event' }, payload);
+const exception = (type, message) => awsEventStreamMessage({ ':exception-type': type, ':content-type': 'application/json', ':message-type': 'exception' }, { message });
+function converse(turn) {
+    const content = [];
+    if (turn.text)
+        content.push({ text: turn.text });
+    if (turn.toolInput !== undefined) {
+        content.push({
+            toolUse: { toolUseId: F.toolCall.id, name: F.toolCall.name, input: parsed(turn.toolInput) },
+        });
+    }
+    return {
+        output: { message: { role: 'assistant', content } },
+        stopReason: turn.stopReason,
+        usage: USAGE,
+        metrics: { latencyMs: 1 },
+    };
+}
+/** The JSON of a tool input, or an empty input for JSON cut off at the token limit. */
+function parsed(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return {};
+    }
+}
+function stream(turn) {
+    const events = [event('messageStart', { role: 'assistant' })];
+    let index = 0;
+    if (turn.text) {
+        for (const text of F.textChunks) {
+            events.push(event('contentBlockDelta', { contentBlockIndex: index, delta: { text } }));
+        }
+        events.push(event('contentBlockStop', { contentBlockIndex: index }));
+        index++;
+    }
+    if (turn.toolInput !== undefined) {
+        const half = Math.ceil(turn.toolInput.length / 2);
+        events.push(event('contentBlockStart', {
+            contentBlockIndex: index,
+            start: { toolUse: { toolUseId: F.toolCall.id, name: F.toolCall.name } },
+        }), event('contentBlockDelta', {
+            contentBlockIndex: index,
+            delta: { toolUse: { input: turn.toolInput.slice(0, half) } },
+        }), event('contentBlockDelta', {
+            contentBlockIndex: index,
+            delta: { toolUse: { input: turn.toolInput.slice(half) } },
+        }), event('contentBlockStop', { contentBlockIndex: index }));
+    }
+    events.push(event('messageStop', { stopReason: turn.stopReason }), event('metadata', { usage: USAGE, metrics: { latencyMs: 1 } }));
+    return events;
+}
+/**
+ * Bedrock Runtime's Converse and ConverseStream (`/model/{id}/converse`, `/converse-stream`),
+ * streaming in the AWS event stream encoding. An error inside a stream that began is an
+ * exception message, such as `serviceUnavailableException`.
+ */
+export const bedrockConverseWire = {
+    name: 'Bedrock Converse',
+    path: (mode) => (mode === 'chat' ? /\/model\/[^/]+\/converse$/ : /\/converse-stream$/),
+    reply(scenario, mode) {
+        const error = BEDROCK_ERRORS[scenario];
+        if (error)
+            return error;
+        const streamed = (chunks, hang = false) => ({
+            type: 'stream',
+            contentType: 'application/vnd.amazon.eventstream',
+            chunks,
+            hang,
+        });
+        const started = [
+            event('messageStart', { role: 'assistant' }),
+            event('contentBlockDelta', { contentBlockIndex: 0, delta: { text: F.partialText } }),
+        ];
+        switch (scenario) {
+            case 'stream-error':
+                return streamed([
+                    ...started,
+                    exception('serviceUnavailableException', 'Service unavailable. Try again later.'),
+                ]);
+            case 'abort':
+                return mode === 'chat' ? { type: 'hang' } : streamed(started, true);
+            default: {
+                const turn = TURNS[scenario];
+                if (!turn)
+                    return undefined;
+                return mode === 'chat' ? { type: 'json', body: converse(turn) } : streamed(stream(turn));
+            }
+        }
+    },
+};

package/dist/conformance/wires/encoding.d.ts

@@ -0,0 +1,11 @@
+/** One server-sent event: `data:` lines, with an `event:` line when `event` is given. */
+export declare function sse(data: unknown, event?: string): string;
+/** One line of newline-delimited JSON. */
+export declare function ndjson(data: unknown): string;
+/**
+ * One message of the AWS event stream encoding (`application/vnd.amazon.eventstream`), as Bedrock
+ * streams `ConverseStream` events: a prelude with the lengths and its CRC32, string headers, the
+ * JSON payload, and the CRC32 of the whole message.
+ */
+export declare function awsEventStreamMessage(headers: Record<string, string>, payload: unknown): Uint8Array;
+//# sourceMappingURL=encoding.d.ts.map

package/dist/conformance/wires/encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../../../src/conformance/wires/encoding.ts"],"names":[],"mappings":"AAEA,yFAAyF;AACzF,wBAAgB,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED,0CAA0C;AAC1C,wBAAgB,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAE5C;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,OAAO,EAAE,OAAO,GACf,UAAU,CAyBZ"}

package/dist/conformance/wires/encoding.js

@@ -0,0 +1,38 @@
+import { crc32 } from 'node:zlib';
+/** One server-sent event: `data:` lines, with an `event:` line when `event` is given. */
+export function sse(data, event) {
+    const body = typeof data === 'string' ? data : JSON.stringify(data);
+    return `${event ? `event: ${event}\n` : ''}data: ${body}\n\n`;
+}
+/** One line of newline-delimited JSON. */
+export function ndjson(data) {
+    return `${JSON.stringify(data)}\n`;
+}
+/**
+ * One message of the AWS event stream encoding (`application/vnd.amazon.eventstream`), as Bedrock
+ * streams `ConverseStream` events: a prelude with the lengths and its CRC32, string headers, the
+ * JSON payload, and the CRC32 of the whole message.
+ */
+export function awsEventStreamMessage(headers, payload) {
+    const headerBytes = Buffer.concat(Object.entries(headers).map(([name, value]) => {
+        const nameBytes = Buffer.from(name, 'utf8');
+        const valueBytes = Buffer.from(value, 'utf8');
+        const header = Buffer.alloc(1 + nameBytes.length + 1 + 2 + valueBytes.length);
+        let offset = header.writeUInt8(nameBytes.length, 0);
+        offset += nameBytes.copy(header, offset);
+        offset = header.writeUInt8(7, offset);
+        offset = header.writeUInt16BE(valueBytes.length, offset);
+        valueBytes.copy(header, offset);
+        return header;
+    }));
+    const payloadBytes = Buffer.from(JSON.stringify(payload), 'utf8');
+    const total = 12 + headerBytes.length + payloadBytes.length + 4;
+    const message = Buffer.alloc(total);
+    message.writeUInt32BE(total, 0);
+    message.writeUInt32BE(headerBytes.length, 4);
+    message.writeUInt32BE(crc32(message.subarray(0, 8)), 8);
+    headerBytes.copy(message, 12);
+    payloadBytes.copy(message, 12 + headerBytes.length);
+    message.writeUInt32BE(crc32(message.subarray(0, total - 4)), total - 4);
+    return new Uint8Array(message);
+}

package/dist/conformance/wires/gemini.d.ts

@@ -0,0 +1,7 @@
+import { type ProviderWire } from '../scenarios.js';
+/**
+ * The Gemini API's `generateContent` and `streamGenerateContent?alt=sse`. An error inside a
+ * stream that began is a chunk holding `{ error }`, as Google's own SDK expects it.
+ */
+export declare const geminiWire: ProviderWire;
+//# sourceMappingURL=gemini.d.ts.map

package/dist/conformance/wires/gemini.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemini.d.ts","sourceRoot":"","sources":["../../../src/conformance/wires/gemini.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAwGtB;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,YAqCxB,CAAC"}

package/dist/conformance/wires/gemini.js

@@ -0,0 +1,121 @@
+import { CONFORMANCE_FIXTURE as F, } from '../scenarios.js';
+import { sse } from './encoding.js';
+const geminiError = (code, status, message, details) => ({
+    type: 'json',
+    status: code,
+    body: { error: { code, message, status, ...(details && { details }) } },
+});
+const quotaFailure = (quotaId) => ({
+    '@type': 'type.googleapis.com/google.rpc.QuotaFailure',
+    violations: [
+        {
+            quotaMetric: 'generativelanguage.googleapis.com/generate_content_free_tier_requests',
+            quotaId,
+            quotaDimensions: { location: 'global', model: 'gemini-conformance' },
+        },
+    ],
+});
+/** The errors of the Gemini API (ai.google.dev/gemini-api/docs/generate-content/api-errors). */
+const GEMINI_ERRORS = {
+    'rate-limit': geminiError(429, 'RESOURCE_EXHAUSTED', 'You exceeded your current quota.', [
+        quotaFailure('GenerateRequestsPerMinutePerProjectPerModel-FreeTier'),
+        {
+            '@type': 'type.googleapis.com/google.rpc.RetryInfo',
+            retryDelay: `${F.retryAfterSeconds}s`,
+        },
+    ]),
+    quota: geminiError(429, 'RESOURCE_EXHAUSTED', 'You exceeded your current quota.', [
+        quotaFailure('GenerateRequestsPerDayPerProjectPerModel-FreeTier'),
+        { '@type': 'type.googleapis.com/google.rpc.RetryInfo', retryDelay: '44s' },
+    ]),
+    auth: geminiError(400, 'INVALID_ARGUMENT', 'API key not valid. Please pass a valid API key.', [
+        {
+            '@type': 'type.googleapis.com/google.rpc.ErrorInfo',
+            reason: 'API_KEY_INVALID',
+            domain: 'googleapis.com',
+        },
+    ]),
+    overloaded: geminiError(503, 'UNAVAILABLE', 'The model is overloaded. Please try again later.'),
+    'server-error': geminiError(500, 'INTERNAL', 'An internal error has occurred.'),
+    'context-overflow': geminiError(400, 'INVALID_ARGUMENT', 'The input token count (1200000) exceeds the maximum number of tokens allowed (1048576).'),
+};
+const TURNS = {
+    text: { text: F.text, finishReason: 'STOP' },
+    'tool-call': { call: true, finishReason: 'STOP' },
+    'tool-call-with-stop': { call: true, finishReason: 'STOP' },
+    'truncated-tool-call': { call: true, finishReason: 'MAX_TOKENS' },
+    'content-filter': { finishReason: 'SAFETY' },
+};
+const USAGE = {
+    promptTokenCount: F.usage.inputTokens,
+    candidatesTokenCount: F.usage.outputTokens,
+    totalTokenCount: F.usage.inputTokens + F.usage.outputTokens,
+};
+const FUNCTION_CALL = {
+    functionCall: { id: F.toolCall.id, name: F.toolCall.name, args: F.toolCall.arguments },
+};
+function candidate(parts, finishReason) {
+    return {
+        ...(parts.length > 0 && { content: { role: 'model', parts } }),
+        ...(finishReason && { finishReason }),
+        index: 0,
+    };
+}
+function partsOf(turn) {
+    return [...(turn.text ? [{ text: turn.text }] : []), ...(turn.call ? [FUNCTION_CALL] : [])];
+}
+function stream(turn) {
+    const chunks = [];
+    if (turn.text) {
+        for (const text of F.textChunks)
+            chunks.push(sse({ candidates: [candidate([{ text }])] }));
+    }
+    chunks.push(sse({
+        candidates: [candidate(turn.call ? [FUNCTION_CALL] : [], turn.finishReason)],
+        usageMetadata: USAGE,
+    }));
+    return chunks;
+}
+/**
+ * The Gemini API's `generateContent` and `streamGenerateContent?alt=sse`. An error inside a
+ * stream that began is a chunk holding `{ error }`, as Google's own SDK expects it.
+ */
+export const geminiWire = {
+    name: 'Gemini',
+    path: (mode) => mode === 'chat' ? /\/models\/[^/]+:generateContent$/ : /:streamGenerateContent\?alt=sse$/,
+    reply(scenario, mode) {
+        const error = GEMINI_ERRORS[scenario];
+        if (error)
+            return error;
+        const streamed = (chunks, hang = false) => ({
+            type: 'stream',
+            contentType: 'text/event-stream',
+            chunks,
+            hang,
+        });
+        const started = sse({ candidates: [candidate([{ text: F.partialText }])] });
+        switch (scenario) {
+            case 'stream-error':
+                return streamed([
+                    started,
+                    sse({ error: { code: 503, message: 'The model is overloaded.', status: 'UNAVAILABLE' } }),
+                ]);
+            case 'abort':
+                return mode === 'chat' ? { type: 'hang' } : streamed([started], true);
+            default: {
+                const turn = TURNS[scenario];
+                if (!turn)
+                    return undefined;
+                return mode === 'chat'
+                    ? {
+                        type: 'json',
+                        body: {
+                            candidates: [candidate(partsOf(turn), turn.finishReason)],
+                            usageMetadata: USAGE,
+                        },
+                    }
+                    : streamed(stream(turn));
+            }
+        }
+    },
+};

package/dist/conformance/wires/ollama.d.ts

@@ -0,0 +1,8 @@
+import { type ProviderWire } from '../scenarios.js';
+/**
+ * Ollama's native `/api/chat`, streaming newline-delimited JSON. Ollama has no content filter,
+ * and it hands out tool calls only once they are whole, so a cut-off call never reaches the
+ * client.
+ */
+export declare const ollamaWire: ProviderWire;
+//# sourceMappingURL=ollama.d.ts.map

package/dist/conformance/wires/ollama.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ollama.d.ts","sourceRoot":"","sources":["../../../src/conformance/wires/ollama.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAwDtB;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,YAoCxB,CAAC"}

package/dist/conformance/wires/ollama.js

@@ -0,0 +1,83 @@
+import { CONFORMANCE_FIXTURE as F, } from '../scenarios.js';
+import { ndjson } from './encoding.js';
+const ollamaError = (status, error, headers) => ({ type: 'json', status, body: { error }, ...(headers && { headers }) });
+/** What Ollama and Ollama Cloud answer when a request fails: a status and `{ error }`. */
+const OLLAMA_ERRORS = {
+    'rate-limit': ollamaError(429, 'too many requests', {
+        'retry-after': String(F.retryAfterSeconds),
+    }),
+    quota: ollamaError(429, "you've reached your weekly usage limit, upgrade for higher limits"),
+    auth: ollamaError(401, 'unauthorized'),
+    overloaded: ollamaError(503, 'server busy, please try again.  maximum pending requests exceeded'),
+    'server-error': ollamaError(500, 'llama runner process has terminated: exit status 2'),
+    'context-overflow': ollamaError(400, 'input length exceeds the context length'),
+};
+const TURNS = {
+    text: { text: F.text, doneReason: 'stop' },
+    'tool-call': { call: true, doneReason: 'stop' },
+    'tool-call-with-stop': { call: true, doneReason: 'stop' },
+    'truncated-tool-call': { doneReason: 'length' },
+};
+const TOOL_CALL = { function: { name: F.toolCall.name, arguments: F.toolCall.arguments } };
+const line = (message, done = false, doneReason) => ({
+    model: 'conformance',
+    created_at: '2026-10-20T00:00:00Z',
+    message: { role: 'assistant', content: '', ...message },
+    done,
+    ...(done && {
+        done_reason: doneReason,
+        prompt_eval_count: F.usage.inputTokens,
+        eval_count: F.usage.outputTokens,
+    }),
+});
+function stream(turn) {
+    const lines = [];
+    if (turn.text)
+        for (const content of F.textChunks)
+            lines.push(ndjson(line({ content })));
+    if (turn.call)
+        lines.push(ndjson(line({ tool_calls: [TOOL_CALL] })));
+    lines.push(ndjson(line({}, true, turn.doneReason)));
+    return lines;
+}
+/**
+ * Ollama's native `/api/chat`, streaming newline-delimited JSON. Ollama has no content filter,
+ * and it hands out tool calls only once they are whole, so a cut-off call never reaches the
+ * client.
+ */
+export const ollamaWire = {
+    name: 'Ollama',
+    path: () => /^\/api\/chat$/,
+    reply(scenario, mode) {
+        const error = OLLAMA_ERRORS[scenario];
+        if (error)
+            return error;
+        const streamed = (chunks, hang = false) => ({
+            type: 'stream',
+            contentType: 'application/x-ndjson',
+            chunks,
+            hang,
+        });
+        const started = ndjson(line({ content: F.partialText }));
+        switch (scenario) {
+            case 'stream-error':
+                return streamed([
+                    started,
+                    ndjson({ error: 'server busy, please try again.  maximum pending requests exceeded' }),
+                ]);
+            case 'abort':
+                return mode === 'chat' ? { type: 'hang' } : streamed([started], true);
+            default: {
+                const turn = TURNS[scenario];
+                if (!turn)
+                    return undefined;
+                if (mode === 'stream')
+                    return streamed(stream(turn));
+                return {
+                    type: 'json',
+                    body: line({ content: turn.text ?? '', ...(turn.call && { tool_calls: [TOOL_CALL] }) }, true, turn.doneReason),
+                };
+            }
+        }
+    },
+};

package/dist/conformance/wires/openai.d.ts

@@ -0,0 +1,11 @@
+import { type ProviderWire } from '../scenarios.js';
+/**
+ * The Chat Completions API of OpenAI and of the servers compatible with it, at any path ending
+ * in `/chat/completions`. Errors inside a stream come as a `data: {"error": ...}` chunk.
+ */
+export declare const openAIChatWire: ProviderWire;
+/**
+ * The OpenAI Responses API at `/responses`. An error inside a stream is an `error` event.
+ */
+export declare const openAIResponsesWire: ProviderWire;
+//# sourceMappingURL=openai.d.ts.map

package/dist/conformance/wires/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/conformance/wires/openai.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AA2LtB;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,YA+B5B,CAAC;AA8GF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,YA2DjC,CAAC"}