zengate 1.0.0

package/src/config.js

@@ -0,0 +1,193 @@
+import fs from 'node:fs';
+
+/**
+ * Every setting can come from the environment or config.json (same key).
+ * Environment wins. Values are validated up front so a typo fails at startup
+ * with a clear message instead of silently falling back to a default.
+ */
+const SPEC = Object.freeze({
+    PORT: { type: 'int', default: 8083, min: 1, max: 65535 },
+    HOST: { type: 'string', default: '127.0.0.1' },
+    API_KEY: { type: 'string', default: '', secret: true },
+    API_KEYS: { type: 'list', default: [], secret: true },
+    ALLOW_NO_AUTH: { type: 'bool', default: false },
+    OPENCODE_PATH: { type: 'string', default: '' },
+    OPENCODE_SERVER_URL: { type: 'string', default: '' },
+    OPENCODE_SERVER_USERNAME: { type: 'string', default: 'opencode' },
+    OPENCODE_SERVER_PASSWORD: { type: 'string', default: '', secret: true },
+    ALLOW_INSECURE_BACKEND_HTTP: { type: 'bool', default: false },
+    OPENCODE_AGENT: { type: 'string', default: 'plan' },
+    MAX_CONCURRENT: { type: 'int', default: 8, min: 1, max: 64 },
+    MAX_QUEUE: { type: 'int', default: 32, min: 0, max: 1000 },
+    RATE_LIMIT_PER_MINUTE: { type: 'int', default: 120, min: 0, max: 100000 },
+    REQUEST_TIMEOUT_MS: { type: 'int', default: 300000, min: 10000, max: 3600000 },
+    MAX_BODY_MB: { type: 'int', default: 25, min: 1, max: 200 },
+    MAX_MEDIA_MB: { type: 'int', default: 20, min: 1, max: 100 },
+    RESPONSES_STORE_MAX: { type: 'int', default: 500, min: 0, max: 100000 },
+    CORS_ORIGINS: { type: 'list', default: [] },
+    TRUST_PROXY: { type: 'hops', default: 0 },
+    LOG_LEVEL: { type: 'enum', default: 'info', values: ['debug', 'info', 'warn', 'error'] },
+    LOG_JSON: { type: 'bool', default: false },
+});
+
+export const CONFIG_KEYS = Object.freeze(Object.keys(SPEC));
+
+/** Keys that are too short or too well known to protect anything. */
+const MIN_KEY_LENGTH = 16;
+const PLACEHOLDER_KEYS = new Set(['change-me', 'changeme', 'your-secret-api-key', 'your-api-key', 'sk-xxxx']);
+
+export class ConfigError extends Error {
+    constructor(problems) {
+        super(`Invalid configuration:\n  - ${problems.join('\n  - ')}`);
+        this.name = 'ConfigError';
+        this.problems = problems;
+    }
+}
+
+export function parseBool(value) {
+    if (typeof value === 'boolean') return value;
+    if (typeof value === 'number' && (value === 0 || value === 1)) return value === 1;
+    if (typeof value !== 'string') return undefined;
+    const v = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(v)) return true;
+    if (['0', 'false', 'no', 'off'].includes(v)) return false;
+    return undefined;
+}
+
+function parseValue(key, spec, raw) {
+    switch (spec.type) {
+        case 'string':
+            return { value: String(raw).trim() };
+        case 'bool': {
+            const value = parseBool(raw);
+            return value === undefined ? { error: `${key} must be true or false (got "${raw}")` } : { value };
+        }
+        case 'int': {
+            const text = String(raw).trim();
+            if (!/^-?\d+$/.test(text)) return { error: `${key} must be an integer (got "${raw}")` };
+            const value = Number(text);
+            if (value < spec.min || value > spec.max) {
+                return { error: `${key} must be between ${spec.min} and ${spec.max} (got ${value})` };
+            }
+            return { value };
+        }
+        case 'list': {
+            const items = Array.isArray(raw) ? raw : String(raw).split(',');
+            return { value: [...new Set(items.map((item) => String(item).trim()).filter(Boolean))] };
+        }
+        case 'hops': {
+            const bool = parseBool(raw);
+            if (bool !== undefined) return { value: bool ? 1 : 0 };
+            return parseValue(key, { type: 'int', min: 0, max: 10 }, raw);
+        }
+        case 'enum': {
+            const value = String(raw).trim().toLowerCase();
+            return spec.values.includes(value) ? { value } : { error: `${key} must be one of: ${spec.values.join(', ')}` };
+        }
+        default:
+            return { error: `${key} has an unknown type` };
+    }
+}
+
+/** Reads config.json. A missing file is fine; a malformed one is fatal. */
+export function readConfigFile(filePath) {
+    if (!filePath || !fs.existsSync(filePath)) return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    } catch (error) {
+        throw new ConfigError([`${filePath} is not valid JSON: ${error.message}`]);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new ConfigError([`${filePath} must contain a JSON object`]);
+    }
+    return parsed;
+}
+
+function validateKeys(keys, problems) {
+    for (const key of keys) {
+        if (PLACEHOLDER_KEYS.has(key.toLowerCase())) {
+            problems.push('API_KEY is a placeholder value; run `npm run setup` or set a unique random key');
+        } else if (key.length < MIN_KEY_LENGTH) {
+            problems.push(`API_KEY must be at least ${MIN_KEY_LENGTH} characters (run \`npm run setup\` to generate one)`);
+        }
+    }
+}
+
+function validateServerUrl(config, problems) {
+    if (!config.OPENCODE_SERVER_URL) return;
+    let url;
+    try {
+        url = new URL(config.OPENCODE_SERVER_URL);
+    } catch {
+        problems.push('OPENCODE_SERVER_URL must be an absolute http(s) URL');
+        return;
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        problems.push('OPENCODE_SERVER_URL must use http or https');
+    } else if (url.protocol === 'http:' && !isLoopbackHost(url.hostname) && !config.ALLOW_INSECURE_BACKEND_HTTP) {
+        problems.push('a remote OPENCODE_SERVER_URL must use https (or set ALLOW_INSECURE_BACKEND_HTTP=true on a trusted private network)');
+    }
+}
+
+/**
+ * Merge config.json and the environment into one validated, frozen config.
+ * @param {Record<string, unknown>} fileConfig parsed config.json (may be empty)
+ * @param {Record<string, string|undefined>} env usually process.env
+ */
+export function loadConfig(fileConfig = {}, env = process.env) {
+    const problems = [];
+    const unknown = Object.keys(fileConfig).filter((key) => !(key in SPEC) && key !== '$schema');
+    if (unknown.length) problems.push(`unknown config.json keys: ${unknown.join(', ')}`);
+
+    const parsed = {};
+    for (const [key, spec] of Object.entries(SPEC)) {
+        const raw = env[key] !== undefined && env[key] !== '' ? env[key] : fileConfig[key];
+        if (raw === undefined || raw === null || raw === '') {
+            parsed[key] = spec.default;
+            continue;
+        }
+        const result = parseValue(key, spec, raw);
+        if (result.error) problems.push(result.error);
+        else parsed[key] = result.value;
+    }
+
+    const { API_KEY: primaryKey, ...rest } = parsed;
+    const config = {
+        ...rest,
+        API_KEYS: [...new Set([primaryKey, ...(rest.API_KEYS || [])].filter(Boolean))],
+        OPENCODE_SERVER_URL: String(rest.OPENCODE_SERVER_URL || '').replace(/\/+$/, ''),
+    };
+    if (config.CORS_ORIGINS?.includes('*')) {
+        problems.push('CORS_ORIGINS must list explicit origins; "*" would let any website use the gateway');
+    }
+    if (!/^[\w.-]{1,64}$/.test(config.OPENCODE_AGENT || '')) {
+        problems.push('OPENCODE_AGENT must be a simple agent name');
+    }
+    validateKeys(config.API_KEYS, problems);
+    validateServerUrl(config, problems);
+    if (problems.length) throw new ConfigError(problems);
+    return Object.freeze(config);
+}
+
+/** True when the gateway must refuse to start: no key and no explicit opt-out. */
+export function needsApiKey(config) {
+    return config.API_KEYS.length === 0 && !config.ALLOW_NO_AUTH;
+}
+
+export function isLoopbackHost(host) {
+    const raw = String(host || '').trim().toLowerCase().replace(/^\[|\]$/g, '');
+    return raw === 'localhost' || raw === '::1' || /^127(\.\d{1,3}){3}$/.test(raw);
+}
+
+/** Config safe to print: secrets are reduced to a count or "set"/"unset". */
+export function describeConfig(config) {
+    const out = {};
+    for (const [key, spec] of Object.entries(SPEC)) {
+        if (key === 'API_KEY') continue;
+        const value = config[key];
+        if (!spec.secret) out[key] = value;
+        else out[key] = Array.isArray(value) ? `${value.length} configured` : (value ? 'set' : 'unset');
+    }
+    return out;
+}

package/src/gateway.js

@@ -0,0 +1,90 @@
+import { createAttachedBackend, createManagedBackend } from './opencode/backend.js';
+import { createCatalog } from './opencode/catalog.js';
+import { createEventHub } from './opencode/events.js';
+import { createRunner } from './opencode/runner.js';
+import { createResponsesStore } from './openai/responses-store.js';
+import { createApp } from './server/app.js';
+
+const HUB_CONNECT_TIMEOUT_MS = 10000;
+const DRAIN_TIMEOUT_MS = 10000;
+
+export function createBackend(config, logger) {
+    return config.OPENCODE_SERVER_URL
+        ? createAttachedBackend({
+            url: config.OPENCODE_SERVER_URL,
+            username: config.OPENCODE_SERVER_USERNAME,
+            password: config.OPENCODE_SERVER_PASSWORD,
+            logger,
+        })
+        : createManagedBackend({ opencodePath: config.OPENCODE_PATH, logger });
+}
+
+function listen(app, { PORT, HOST }) {
+    return new Promise((resolve, reject) => {
+        const server = app.listen(PORT, HOST);
+        server.once('listening', () => resolve(server));
+        server.once('error', (error) => reject(error.code === 'EADDRINUSE'
+            ? new Error(`Port ${PORT} on ${HOST} is already in use. Stop the other process or set PORT.`)
+            : error));
+    });
+}
+
+function drain(server) {
+    return new Promise((resolve) => {
+        const force = setTimeout(() => server.closeAllConnections(), DRAIN_TIMEOUT_MS);
+        force.unref();
+        server.close(() => { clearTimeout(force); resolve(); });
+        server.closeIdleConnections();
+    });
+}
+
+/**
+ * Wires the OpenCode backend, event hub, catalog and HTTP app together and
+ * starts listening.
+ * @param {object} config validated config from loadConfig
+ * @param {{ logger: object, backend?: object }} deps backend is injectable for tests
+ */
+export async function startGateway(config, { logger, backend = createBackend(config, logger) }) {
+    const getClient = () => backend.getClient();
+    const hub = createEventHub({ getClient, logger, ownsAllSessions: backend.ownsAllSessions });
+    const catalog = createCatalog({ getClient, logger });
+    const runner = createRunner({ getClient, hub, logger, agent: config.OPENCODE_AGENT });
+    const store = createResponsesStore({ maxEntries: config.RESPONSES_STORE_MAX });
+    const { app, close: closeApp } = createApp({ config, logger, backend, hub, catalog, runner, store });
+
+    await backend.start();
+    let server;
+    try {
+        hub.start();
+        if (!(await hub.waitConnected(HUB_CONNECT_TIMEOUT_MS))) {
+            logger.warn('OpenCode event stream is not connected yet; streaming falls back to final output until it is');
+        }
+        catalog.list().then(
+            (models) => logger.info(`${models.length} models: ${models.map((m) => m.id).join(', ')}`),
+            (error) => logger.warn('Could not load the model list yet', { error: error.message }),
+        );
+        server = await listen(app, config);
+    } catch (error) {
+        await hub.stop();
+        closeApp();
+        await backend.stop();
+        throw error;
+    }
+    // Generations can legitimately run for minutes; REQUEST_TIMEOUT_MS bounds them instead.
+    server.requestTimeout = 0;
+    server.headersTimeout = 30000;
+    server.keepAliveTimeout = 65000;
+
+    let stopping = null;
+    const stop = () => {
+        stopping ??= (async () => {
+            await drain(server);
+            closeApp();
+            await hub.stop();
+            await backend.stop();
+        })();
+        return stopping;
+    };
+
+    return Object.freeze({ server, stop, address: server.address(), backend });
+}

package/src/logger.js

@@ -0,0 +1,35 @@
+const LEVELS = Object.freeze({ debug: 10, info: 20, warn: 30, error: 40 });
+
+/**
+ * Small leveled logger. Human-readable by default, JSON lines when json=true.
+ * Callers pass structured fields; request bodies and secrets are never logged.
+ * @param {{ level?: keyof LEVELS, json?: boolean, sink?: { out: Function, err: Function } }} [options]
+ */
+export function createLogger({ level = 'info', json = false, sink } = {}) {
+    const threshold = LEVELS[level] ?? LEVELS.info;
+    const out = sink?.out ?? ((line) => process.stdout.write(`${line}\n`));
+    const err = sink?.err ?? ((line) => process.stderr.write(`${line}\n`));
+
+    const write = (name, message, fields) => {
+        if (LEVELS[name] < threshold) return;
+        const target = LEVELS[name] >= LEVELS.warn ? err : out;
+        if (json) {
+            target(JSON.stringify({ ts: new Date().toISOString(), level: name, msg: message, ...fields }));
+            return;
+        }
+        const extra = fields && Object.keys(fields).length ? ` ${JSON.stringify(fields)}` : '';
+        const tag = name === 'info' ? '' : `[${name}] `;
+        target(`${tag}${message}${extra}`);
+    };
+
+    return Object.freeze({
+        debug: (message, fields) => write('debug', message, fields),
+        info: (message, fields) => write('info', message, fields),
+        warn: (message, fields) => write('warn', message, fields),
+        error: (message, fields) => write('error', message, fields),
+        isDebug: threshold <= LEVELS.debug,
+    });
+}
+
+/** Logger that discards everything; handy for tests and embedding. */
+export const silentLogger = createLogger({ level: 'error', sink: { out: () => {}, err: () => {} } });

package/src/openai/chat-request.js

@@ -0,0 +1,183 @@
+import { invalidRequest, unsupported } from '../server/errors.js';
+import { audioFromBase64, fileAttachment, imageFromUrl, videoFromUrl } from './media.js';
+import { newCallId } from './tool-calls.js';
+
+/**
+ * Parameters that are accepted for compatibility but cannot be applied
+ * through OpenCode (sampling and token limits are set by the model/agent).
+ * They are reported back in the `x-gateway-ignored-params` header.
+ */
+const IGNORED = new Set([
+    'temperature', 'top_p', 'max_tokens', 'max_completion_tokens', 'presence_penalty', 'frequency_penalty',
+    'seed', 'logit_bias', 'user', 'metadata', 'store', 'service_tier', 'prompt_cache_key', 'prompt_cache_retention',
+    'safety_identifier', 'verbosity', 'prediction', 'web_search_options', 'top_k', 'min_p', 'repetition_penalty',
+]);
+const HANDLED = new Set([
+    'model', 'messages', 'stream', 'stream_options', 'n', 'stop', 'response_format', 'reasoning_effort',
+    'tools', 'tool_choice', 'parallel_tool_calls', 'functions', 'function_call', 'logprobs', 'top_logprobs',
+    'modalities', 'audio',
+]);
+const ROLES = new Set(['system', 'developer', 'user', 'assistant', 'tool', 'function']);
+const MAX_MESSAGES = 2000;
+export const MAX_CHOICES = 4;
+
+const isObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+
+export function parseTools(tools, param = 'tools') {
+    if (tools === undefined || tools === null) return [];
+    if (!Array.isArray(tools)) throw invalidRequest('tools must be an array.', param);
+    const seen = new Set();
+    return tools.map((tool, index) => {
+        const fn = tool?.type === 'function' ? tool.function : tool?.type === undefined ? tool : null;
+        if (!isObject(fn) || typeof fn.name !== 'string' || !/^[\w.-]{1,128}$/.test(fn.name)) {
+            throw invalidRequest('Each tool must be {"type":"function","function":{"name":...}} with a name of letters, digits, _ . or -.', `${param}[${index}]`);
+        }
+        if (seen.has(fn.name)) throw invalidRequest(`Duplicate tool name '${fn.name}'.`, `${param}[${index}]`);
+        seen.add(fn.name);
+        if (fn.parameters !== undefined && !isObject(fn.parameters)) throw invalidRequest('function.parameters must be a JSON Schema object.', `${param}[${index}]`);
+        return { name: fn.name, description: typeof fn.description === 'string' ? fn.description : '', parameters: fn.parameters, kind: 'function' };
+    });
+}
+
+export function parseToolChoice(choice, tools, param = 'tool_choice') {
+    if (choice === undefined || choice === null) return 'auto';
+    if (choice === 'auto' || choice === 'none' || choice === 'required') return choice;
+    const name = choice?.function?.name ?? choice?.name;
+    if (typeof name === 'string') {
+        if (!tools.some((tool) => tool.name === name)) throw invalidRequest(`tool_choice names '${name}', which is not in tools.`, param);
+        return { name };
+    }
+    if (choice?.type === 'allowed_tools') return choice.mode === 'required' ? 'required' : 'auto';
+    throw invalidRequest('tool_choice must be "auto", "none", "required" or a named function.', param);
+}
+
+function textOf(parts, param) {
+    return parts.map((part, index) => {
+        if (typeof part === 'string') return part;
+        if (part?.type === 'text' || part?.type === 'refusal') return String(part.text ?? part.refusal ?? '');
+        throw invalidRequest('Only text parts are allowed here.', `${param}[${index}]`);
+    }).join('');
+}
+
+function parseUserContent(content, param, media) {
+    if (typeof content === 'string') return { text: content, media: [] };
+    if (content === null || content === undefined) return { text: '', media: [] };
+    if (!Array.isArray(content)) throw invalidRequest('content must be a string or an array of content parts.', param);
+    const texts = [];
+    const attachments = [];
+    content.forEach((part, index) => {
+        const where = `${param}[${index}]`;
+        const options = { ...media, param: where };
+        switch (part?.type) {
+            case 'text': texts.push(String(part.text ?? '')); break;
+            case 'image_url': attachments.push(imageFromUrl(typeof part.image_url === 'string' ? part.image_url : part.image_url?.url, options)); break;
+            case 'input_audio': attachments.push(audioFromBase64(part.input_audio?.data, part.input_audio?.format, options)); break;
+            case 'file': attachments.push(fileAttachment(part.file || {}, options)); break;
+            case 'video_url': attachments.push(videoFromUrl(typeof part.video_url === 'string' ? part.video_url : part.video_url?.url, options)); break;
+            case 'refusal': texts.push(String(part.refusal ?? '')); break;
+            default:
+                throw unsupported(`Unsupported content part type '${part?.type}'. Use text, image_url, input_audio, file or video_url.`, where);
+        }
+    });
+    const inlined = attachments.filter((a) => a.kind === 'text');
+    for (const file of inlined) texts.push(`\n<file name="${file.filename || 'attachment'}">\n${file.text}\n</file>\n`);
+    return { text: texts.join(''), media: attachments.filter((a) => a.kind !== 'text') };
+}
+
+function parseAssistantCalls(message, param) {
+    const calls = [];
+    if (Array.isArray(message.tool_calls)) {
+        message.tool_calls.forEach((call, index) => {
+            const name = call?.function?.name;
+            if (typeof name !== 'string') throw invalidRequest('tool_calls[].function.name is required.', `${param}.tool_calls[${index}]`);
+            const args = call.function.arguments;
+            calls.push({ id: String(call.id || newCallId()), name, arguments: typeof args === 'string' ? args : JSON.stringify(args ?? {}) });
+        });
+    }
+    if (isObject(message.function_call) && typeof message.function_call.name === 'string') {
+        calls.push({ id: `call_${message.function_call.name}`, name: message.function_call.name, arguments: String(message.function_call.arguments || '{}') });
+    }
+    return calls;
+}
+
+export function parseChatMessages(messages, media) {
+    if (!Array.isArray(messages) || messages.length === 0) throw invalidRequest('messages must be a non-empty array.', 'messages');
+    if (messages.length > MAX_MESSAGES) throw invalidRequest(`messages may contain at most ${MAX_MESSAGES} entries.`, 'messages');
+    return messages.map((message, index) => {
+        const param = `messages[${index}]`;
+        if (!isObject(message) || !ROLES.has(message.role)) {
+            throw invalidRequest(`${param}.role must be one of: system, developer, user, assistant, tool.`, `${param}.role`);
+        }
+        const { role } = message;
+        if (role === 'system' || role === 'developer') {
+            const text = Array.isArray(message.content) ? textOf(message.content, `${param}.content`) : String(message.content ?? '');
+            return { role: 'system', content: text, media: [] };
+        }
+        if (role === 'tool' || role === 'function') {
+            const text = Array.isArray(message.content) ? textOf(message.content, `${param}.content`) : String(message.content ?? '');
+            const toolCallId = role === 'function' ? `call_${message.name}` : message.tool_call_id;
+            if (typeof toolCallId !== 'string' || !toolCallId) throw invalidRequest('Tool messages need tool_call_id.', `${param}.tool_call_id`);
+            return { role: 'tool', content: text, media: [], toolCallId, name: typeof message.name === 'string' ? message.name : undefined };
+        }
+        if (role === 'assistant') {
+            const text = Array.isArray(message.content) ? textOf(message.content, `${param}.content`) : String(message.content ?? '');
+            return { role: 'assistant', content: text, media: [], toolCalls: parseAssistantCalls(message, param) };
+        }
+        const { text, media: attachments } = parseUserContent(message.content, `${param}.content`, media);
+        return { role: 'user', content: text, media: attachments };
+    });
+}
+
+export function parseResponseFormat(format, param = 'response_format') {
+    if (format === undefined || format === null || format?.type === 'text') return null;
+    if (format?.type === 'json_object') return { type: 'json_object' };
+    if (format?.type === 'json_schema') {
+        const spec = format.json_schema ?? format;
+        if (!isObject(spec?.schema)) throw invalidRequest('json_schema.schema must be a JSON Schema object.', param);
+        return { type: 'json_schema', name: spec.name || 'response', schema: spec.schema };
+    }
+    throw invalidRequest('response_format.type must be text, json_object or json_schema.', param);
+}
+
+function parseStop(stop) {
+    if (stop === undefined || stop === null) return [];
+    const list = Array.isArray(stop) ? stop : [stop];
+    if (list.length > 4 || list.some((s) => typeof s !== 'string')) throw invalidRequest('stop must be a string or up to 4 strings.', 'stop');
+    return list.filter(Boolean);
+}
+
+/**
+ * Validate a Chat Completions request into the gateway's canonical form.
+ * @param {unknown} body parsed JSON body
+ * @param {{ maxBytes: number }} media per-attachment limits
+ */
+export function parseChatRequest(body, media) {
+    if (!isObject(body)) throw invalidRequest('Request body must be a JSON object.');
+    if (typeof body.model !== 'string' || !body.model.trim()) throw invalidRequest('model is required (see GET /v1/models).', 'model');
+    if (body.logprobs === true) throw unsupported('logprobs are not available through OpenCode.', 'logprobs');
+    if (body.audio || (Array.isArray(body.modalities) && body.modalities.some((m) => m !== 'text'))) {
+        throw unsupported('Only text output is supported (modalities: ["text"]).', 'modalities');
+    }
+    const n = body.n ?? 1;
+    if (!Number.isInteger(n) || n < 1 || n > MAX_CHOICES) throw invalidRequest(`n must be an integer from 1 to ${MAX_CHOICES}.`, 'n');
+    const legacyTools = Array.isArray(body.functions) ? body.functions.map((fn) => ({ type: 'function', function: fn })) : undefined;
+    const tools = parseTools(body.tools ?? legacyTools, body.tools ? 'tools' : 'functions');
+    const legacyChoice = typeof body.function_call === 'string' ? body.function_call : body.function_call?.name ? { name: body.function_call.name } : undefined;
+    const ignored = Object.keys(body).filter((key) => IGNORED.has(key) || !HANDLED.has(key));
+    return {
+        model: body.model.trim(),
+        messages: parseChatMessages(body.messages, media),
+        tools,
+        toolChoice: parseToolChoice(body.tool_choice ?? legacyChoice, tools),
+        // Legacy `functions` clients expect a single `function_call` back.
+        legacyFunctions: !body.tools && Boolean(legacyTools),
+        parallelToolCalls: body.parallel_tool_calls !== false && !(!body.tools && legacyTools),
+        format: parseResponseFormat(body.response_format),
+        reasoningEffort: typeof body.reasoning_effort === 'string' ? body.reasoning_effort : null,
+        stop: parseStop(body.stop),
+        n,
+        stream: body.stream === true,
+        includeUsage: body.stream_options?.include_usage === true,
+        ignored,
+    };
+}

package/src/openai/chat.js

@@ -0,0 +1,100 @@
+import crypto from 'node:crypto';
+import { toApiError } from '../server/errors.js';
+import { parseChatRequest } from './chat-request.js';
+import { chatUsage, generate } from './generate.js';
+import { buildPrompt } from './prompt.js';
+import { openSse } from './sse-writer.js';
+import { assertPublicUrls } from './url-guard.js';
+
+const completionId = () => `chatcmpl-${crypto.randomBytes(12).toString('hex')}`;
+const now = () => Math.floor(Date.now() / 1000);
+
+function toolCallsJson(calls) {
+    return calls.map((call) => ({ id: call.id, type: 'function', function: { name: call.name, arguments: call.arguments } }));
+}
+
+function chatMessage(result, legacy) {
+    const calls = result.toolCalls.length ? toolCallsJson(result.toolCalls) : null;
+    return {
+        role: 'assistant',
+        content: result.content || (calls ? null : ''),
+        refusal: null,
+        annotations: [],
+        ...(calls && legacy ? { function_call: calls[0].function } : {}),
+        ...(calls && !legacy ? { tool_calls: calls } : {}),
+        ...(result.reasoning ? { reasoning_content: result.reasoning } : {}),
+    };
+}
+
+const finishReason = (result, legacy) => (legacy && result.finish === 'tool_calls' ? 'function_call' : result.finish);
+
+/**
+ * POST /v1/chat/completions
+ * @param {{ runner: object, catalog: object, limits: { maxBytes: number } }} deps
+ */
+export function chatCompletionsHandler({ runner, catalog, limits }) {
+    return async (req, res) => {
+        const request = parseChatRequest(req.body, limits);
+        const model = await catalog.resolve(request.model);
+        const prompt = buildPrompt(request, model);
+        await assertPublicUrls(prompt.parts);
+        if (request.ignored.length) res.set('x-gateway-ignored-params', request.ignored.join(','));
+        await req.withSlot((signal) => (request.stream
+            ? streamChat({ req, res, runner, request, prompt, model, signal })
+            : jsonChat({ res, runner, request, prompt, model, signal })), request.n);
+    };
+}
+
+async function jsonChat({ res, runner, request, prompt, model, signal }) {
+    const results = await Promise.all(Array.from({ length: request.n }, () => generate({ runner, prompt, request, signal })));
+    res.json({
+        id: completionId(),
+        object: 'chat.completion',
+        created: now(),
+        model: model.id,
+        system_fingerprint: null,
+        choices: results.map((result, index) => ({
+            index, message: chatMessage(result, request.legacyFunctions), logprobs: null, finish_reason: finishReason(result, request.legacyFunctions),
+        })),
+        usage: chatUsage(results.map((r) => r.usage)),
+    });
+}
+
+async function streamChat({ req, res, runner, request, prompt, model, signal }) {
+    const id = completionId();
+    const created = now();
+    const sse = openSse(res);
+    const chunk = (index, delta, finishReason = null) => sse.send({
+        id, object: 'chat.completion.chunk', created, model: model.id, system_fingerprint: null,
+        choices: [{ index, delta, logprobs: null, finish_reason: finishReason }],
+        ...(request.includeUsage ? { usage: null } : {}),
+    });
+
+    for (let index = 0; index < request.n; index += 1) chunk(index, { role: 'assistant', content: '', refusal: null });
+    try {
+        const results = await Promise.all(Array.from({ length: request.n }, (_, index) => generate({
+            runner, prompt, request, signal,
+            onText: (text) => chunk(index, { content: text }),
+            onReasoning: (text) => chunk(index, { reasoning_content: text }),
+        }).then((result) => {
+            const calls = toolCallsJson(result.toolCalls);
+            if (calls.length && request.legacyFunctions) chunk(index, { function_call: calls[0].function });
+            else if (calls.length) chunk(index, { tool_calls: calls.map((call, position) => ({ index: position, ...call })) });
+            chunk(index, {}, finishReason(result, request.legacyFunctions));
+            return result;
+        })));
+        if (request.includeUsage) {
+            sse.send({ id, object: 'chat.completion.chunk', created, model: model.id, system_fingerprint: null, choices: [], usage: chatUsage(results.map((r) => r.usage)) });
+        }
+        sse.raw('data: [DONE]\n\n');
+    } catch (error) {
+        if (!signal.aborted || error?.status) {
+            const apiError = toApiError(error);
+            req.log.warn('Chat stream failed', { status: apiError.status, code: apiError.code, error: apiError.message });
+            sse.send(apiError.toJSON());
+            sse.raw('data: [DONE]\n\n');
+        }
+    } finally {
+        sse.end();
+    }
+}