dsh-coding-subscription-oauth 0.5.0

package/src/gateway-backend.ts

@@ -0,0 +1,274 @@
+/**
+ * Session-backed model listing and event streaming for the local gateway.
+ * @module dsh-coding-subscription-oauth/gateway-backend
+ */
+
+import type { Api, Context, Message, Model, ThinkingLevel, Tool } from "@earendil-works/pi-ai";
+import {
+	type GatewayChatMessage,
+	type GatewayCompletionRequest,
+	type GatewayStreamPart,
+	type GatewayTool,
+	isThinkingLevel,
+} from "./gateway-protocol.ts";
+import type { OAuthProviderSession } from "./oauth-session.ts";
+import { safeMessage } from "./redact.ts";
+import type { GrokBuildSession } from "./session.ts";
+
+export interface GatewayListedModel {
+	id: string;
+	owned_by: string;
+}
+
+export interface GatewayBackend {
+	listModels(): Promise<readonly GatewayListedModel[]>;
+	stream(request: GatewayCompletionRequest): AsyncIterable<GatewayStreamPart>;
+	streamText(modelId: string, messages: readonly GatewayChatMessage[]): AsyncIterable<string>;
+}
+
+export class GatewayRequestError extends Error {
+	constructor(
+		readonly status: number,
+		readonly code: string,
+		message: string,
+	) {
+		super(message);
+	}
+}
+
+interface OwnedModel {
+	owned_by: string;
+	model: Model<Api>;
+	stream: (
+		model: Model<Api>,
+		context: Context,
+		options?: { reasoning?: ThinkingLevel },
+	) => AsyncIterable<{
+		type: string;
+		delta?: string;
+		errorMessage?: string;
+		reason?: string;
+		toolCall?: { id: string; name: string; arguments?: unknown };
+		partial?: { content?: readonly { type?: string; id?: string; name?: string }[] };
+	}>;
+}
+
+const EMPTY_USAGE = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+export function createSessionGatewayBackend(
+	grok: GrokBuildSession,
+	subscriptions: readonly OAuthProviderSession[],
+): GatewayBackend {
+	return {
+		async listModels() {
+			const listed: GatewayListedModel[] = [];
+			const seen = new Map<string, string>();
+			for (const owned of await collectOwnedModels(grok, subscriptions)) {
+				const previous = seen.get(owned.model.id);
+				if (previous !== undefined && previous !== owned.owned_by) continue;
+				seen.set(owned.model.id, owned.owned_by);
+				listed.push({ id: owned.model.id, owned_by: owned.owned_by });
+			}
+			return listed;
+		},
+		async *stream(request) {
+			const owned = selectOwnedModel(await collectOwnedModels(grok, subscriptions), request.model);
+			const context = buildGatewayContext(request.messages, request.tools);
+			const reasoning = resolveReasoning(request.reasoning, owned.owned_by);
+			let usedTools = false;
+			for await (const event of owned.stream(
+				owned.model,
+				context,
+				reasoning === undefined ? undefined : { reasoning },
+			)) {
+				if (event.type === "text_delta" && typeof event.delta === "string" && event.delta.length > 0) {
+					yield { type: "text", text: event.delta };
+				}
+				if (event.type === "thinking_delta" && typeof event.delta === "string" && event.delta.length > 0) {
+					yield { type: "thinking", text: event.delta };
+				}
+				if (event.type === "toolcall_end" && event.toolCall !== undefined) {
+					usedTools = true;
+					yield {
+						type: "tool_call",
+						index: 0,
+						id: event.toolCall.id,
+						name: event.toolCall.name,
+						arguments: stringifyToolArguments(event.toolCall.arguments),
+					};
+				}
+				if (event.type === "error") {
+					throw new GatewayRequestError(502, "upstream_error", event.errorMessage ?? "upstream stream error");
+				}
+				if (event.type === "done") {
+					const finish =
+						event.reason === "length" ? "length" : usedTools || event.reason === "toolUse" ? "tool_calls" : "stop";
+					yield { type: "done", finish };
+				}
+			}
+		},
+		async *streamText(modelId, messages) {
+			for await (const part of this.stream({ model: modelId, messages })) {
+				if (part.type === "text") yield part.text;
+			}
+		},
+	};
+}
+
+export function selectOwnedModel(owned: readonly OwnedModel[], modelId: string): OwnedModel {
+	const matches = owned.filter((item) => item.model.id === modelId);
+	if (matches.length === 0) throw new GatewayRequestError(404, "model_not_found", `Unknown model ${modelId}`);
+	const owners = new Set(matches.map((item) => item.owned_by));
+	if (owners.size > 1) {
+		throw new GatewayRequestError(404, "model_not_found", `Model ${modelId} is owned by multiple signed-in providers`);
+	}
+	return matches[0]!;
+}
+
+export function buildGatewayContext(messages: readonly GatewayChatMessage[], tools?: readonly GatewayTool[]): Context {
+	let systemPrompt: string | undefined;
+	const mapped: Message[] = [];
+	for (const message of messages) {
+		if (message.role === "system") {
+			systemPrompt = `${systemPrompt === undefined ? "" : `${systemPrompt}\n`}${message.content}`;
+			continue;
+		}
+		if (message.role === "assistant") {
+			mapped.push(assistantReplay(message));
+			continue;
+		}
+		if (message.role === "tool") {
+			mapped.push({
+				role: "toolResult",
+				toolCallId: message.tool_call_id ?? "",
+				toolName: message.tool_name ?? "tool",
+				content: [{ type: "text", text: message.content }],
+				isError: false,
+				timestamp: Date.now(),
+			});
+			continue;
+		}
+		mapped.push({ role: "user", content: message.content, timestamp: Date.now() });
+	}
+	const context: Context = systemPrompt === undefined ? { messages: mapped } : { systemPrompt, messages: mapped };
+	if (tools !== undefined && tools.length > 0) context.tools = tools.map(toPiTool);
+	return context;
+}
+
+export function assistantReplay(message: GatewayChatMessage): Message {
+	const content: Array<
+		| { type: "text"; text: string }
+		| { type: "thinking"; thinking: string }
+		| { type: "toolCall"; id: string; name: string; arguments: Record<string, unknown> }
+	> = [];
+	const needsPlaceholder = message.tool_calls !== undefined && message.tool_calls.length > 0;
+	const reasoning = message.reasoning_content ?? (needsPlaceholder ? "" : undefined);
+	if (reasoning !== undefined) content.push({ type: "thinking", thinking: reasoning });
+	if (message.content.length > 0) content.push({ type: "text", text: message.content });
+	if (message.tool_calls !== undefined) {
+		for (const call of message.tool_calls) {
+			content.push({
+				type: "toolCall",
+				id: call.id,
+				name: call.name,
+				arguments: parseToolArguments(call.arguments),
+			});
+		}
+	}
+	return {
+		role: "assistant",
+		content: content.length === 0 ? [{ type: "text", text: "" }] : content,
+		api: "openai-responses",
+		provider: "gateway",
+		model: "gateway",
+		usage: EMPTY_USAGE,
+		stopReason: needsPlaceholder ? "toolUse" : "stop",
+		timestamp: Date.now(),
+	};
+}
+
+function toPiTool(tool: GatewayTool): Tool {
+	return {
+		name: tool.name,
+		description: tool.description,
+		parameters: tool.parameters as Tool["parameters"],
+	};
+}
+
+function parseToolArguments(raw: string): Record<string, unknown> {
+	try {
+		const value = JSON.parse(raw) as unknown;
+		return typeof value === "object" && value !== null && !Array.isArray(value)
+			? (value as Record<string, unknown>)
+			: { value };
+	} catch {
+		return { value: raw };
+	}
+}
+
+function stringifyToolArguments(value: unknown): string {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value ?? {});
+	} catch {
+		return "{}";
+	}
+}
+
+function resolveReasoning(value: string | undefined, ownedBy: string): ThinkingLevel | undefined {
+	if (value === undefined || !isThinkingLevel(value)) return undefined;
+	if (ownedBy === "kimi-code-oauth" || ownedBy === "claude-code-oauth") return undefined;
+	return value as ThinkingLevel;
+}
+
+async function collectOwnedModels(
+	grok: GrokBuildSession,
+	subscriptions: readonly OAuthProviderSession[],
+): Promise<OwnedModel[]> {
+	const owned: OwnedModel[] = [];
+	const grokAuth = await grok.models.getAuth("xai");
+	if (grokAuth?.auth.apiKey) {
+		for (const model of grok.visibleModels()) {
+			owned.push({
+				owned_by: "grok-build",
+				model,
+				stream: (item, context, options) => grok.models.streamSimple(item, context, options),
+			});
+		}
+	}
+	for (const session of subscriptions) {
+		const status = await session.status();
+		if (!status.authenticated) continue;
+		for (const model of session.visibleModels()) {
+			owned.push({
+				owned_by: session.definition.route,
+				model,
+				stream: (item, context, options) => session.models.streamSimple(item, context, options),
+			});
+		}
+	}
+	return owned;
+}
+
+export function gatewayErrorEnvelope(error: unknown): {
+	status: number;
+	body: { error: { message: string; type: string; code: string } };
+} {
+	if (error instanceof GatewayRequestError) {
+		return {
+			status: error.status,
+			body: { error: { message: error.message.slice(0, 1000), type: "invalid_request_error", code: error.code } },
+		};
+	}
+	return {
+		status: 500,
+		body: { error: { message: safeMessage(error).slice(0, 1000), type: "server_error", code: "internal" } },
+	};
+}

package/src/gateway-body.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared JSON body reader for isolated gateway endpoints.
+ * @module dsh-coding-subscription-oauth/gateway-body
+ */
+
+import type { IncomingMessage } from "node:http";
+import { GatewayRequestError } from "./gateway-backend.ts";
+
+const BODY_LIMIT = 1024 * 1024;
+
+export async function readGatewayJsonBody(req: IncomingMessage): Promise<Record<string, unknown>> {
+	const chunks: Buffer[] = [];
+	let size = 0;
+	for await (const chunk of req) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		size += buffer.byteLength;
+		if (size > BODY_LIMIT) throw new GatewayRequestError(413, "payload_too_large", "request body exceeds 1 MiB");
+		chunks.push(buffer);
+	}
+	if (chunks.length === 0) return {};
+	try {
+		const value = JSON.parse(Buffer.concat(chunks).toString("utf8")) as unknown;
+		if (typeof value !== "object" || value === null || Array.isArray(value)) {
+			throw new GatewayRequestError(400, "invalid_request", "body must be a JSON object");
+		}
+		return value as Record<string, unknown>;
+	} catch (error) {
+		if (error instanceof GatewayRequestError) throw error;
+		throw new GatewayRequestError(400, "invalid_request", "body is not valid JSON");
+	}
+}
+
+export function writeGatewayJson(res: import("node:http").ServerResponse, status: number, value: unknown): void {
+	const body = Buffer.from(`${JSON.stringify(value)}\n`);
+	res.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"content-length": body.byteLength,
+		"cache-control": "no-store",
+	});
+	res.end(body);
+}
+
+export function beginGatewaySse(res: import("node:http").ServerResponse): void {
+	res.writeHead(200, {
+		"content-type": "text/event-stream; charset=utf-8",
+		"cache-control": "no-store",
+		connection: "close",
+	});
+}

package/src/gateway-config.ts

@@ -0,0 +1,76 @@
+/**
+ * Opt-in local API gateway configuration.
+ * @module dsh-coding-subscription-oauth/gateway-config
+ */
+
+import z from "@deepseek-ai/schemastery";
+
+export const GATEWAY_DEFAULT_BIND = "127.0.0.1";
+export const GATEWAY_DEFAULT_PORT = 18_080;
+export const GATEWAY_MIN_PORT = 1024;
+export const GATEWAY_MAX_PORT = 65_535;
+export const GATEWAY_RANDOM_PORT_MIN = 18_100;
+export const GATEWAY_RANDOM_PORT_MAX = 18_999;
+const GATEWAY_RANDOM_RESERVED = new Set([22, 53, 3080, 7890, 9090, GATEWAY_DEFAULT_PORT]);
+
+export interface GatewayConfig {
+	readonly enabled: boolean;
+	readonly bind: string;
+	readonly port: number;
+	readonly apiKey?: string;
+	readonly rateLimit: number;
+}
+
+export const GatewayConfigSchema: z<Partial<GatewayConfig>> = z.object({
+	enabled: z.boolean().default(false),
+	bind: z.string().default(GATEWAY_DEFAULT_BIND),
+	port: z.number().default(GATEWAY_DEFAULT_PORT),
+	apiKey: z.string(),
+	rateLimit: z.number().default(0),
+});
+
+export function resolveGatewayConfig(raw?: Partial<GatewayConfig>): GatewayConfig {
+	const bind = raw?.bind ?? GATEWAY_DEFAULT_BIND;
+	const port = raw?.port ?? GATEWAY_DEFAULT_PORT;
+	if (typeof bind !== "string" || bind.trim() === "") throw new Error("gateway.bind must be a non-empty host");
+	assertGatewayPort(port);
+	const rateLimit = raw?.rateLimit ?? 0;
+	if (!Number.isSafeInteger(rateLimit) || rateLimit < 0)
+		throw new Error("gateway.rateLimit must be a non-negative integer");
+	const apiKey = raw?.apiKey;
+	if (apiKey !== undefined && (typeof apiKey !== "string" || apiKey.length === 0)) {
+		throw new Error("gateway.apiKey must be a non-empty string when set");
+	}
+	return {
+		enabled: raw?.enabled === true,
+		bind: bind.trim(),
+		port,
+		...(apiKey === undefined ? {} : { apiKey }),
+		rateLimit,
+	};
+}
+
+export function isLoopbackBind(bind: string): boolean {
+	return bind === "127.0.0.1" || bind === "::1" || bind === "localhost";
+}
+
+export function assertGatewayPort(port: number): number {
+	if (!Number.isSafeInteger(port) || port < GATEWAY_MIN_PORT || port > GATEWAY_MAX_PORT) {
+		throw new Error(
+			`gateway.port must be an integer between ${String(GATEWAY_MIN_PORT)} and ${String(GATEWAY_MAX_PORT)}`,
+		);
+	}
+	return port;
+}
+
+export function randomGatewayPort(exclude: number | readonly number[] = []): number {
+	const blocked = new Set(GATEWAY_RANDOM_RESERVED);
+	if (typeof exclude === "number") blocked.add(exclude);
+	else for (const value of exclude) blocked.add(value);
+	for (let attempt = 0; attempt < 32; attempt += 1) {
+		const span = GATEWAY_RANDOM_PORT_MAX - GATEWAY_RANDOM_PORT_MIN + 1;
+		const candidate = GATEWAY_RANDOM_PORT_MIN + Math.floor(Math.random() * span);
+		if (!blocked.has(candidate)) return candidate;
+	}
+	return GATEWAY_RANDOM_PORT_MIN === exclude ? GATEWAY_RANDOM_PORT_MIN + 1 : GATEWAY_RANDOM_PORT_MIN;
+}

package/src/gateway-http.ts

@@ -0,0 +1,104 @@
+/**
+ * Isolated node:http server for the opt-in local gateway.
+ * @module dsh-coding-subscription-oauth/gateway-http
+ */
+
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { handleAnthropicMessages } from "./gateway-anthropic-messages.ts";
+import { gatewayKeysEqual } from "./gateway-auth.ts";
+import { type GatewayBackend, gatewayErrorEnvelope } from "./gateway-backend.ts";
+import { type GatewayConfig, isLoopbackBind } from "./gateway-config.ts";
+import { handleOpenAiChatCompletions } from "./gateway-openai-chat.ts";
+import { handleOpenAiResponses } from "./gateway-openai-responses.ts";
+
+export interface GatewayHttpOptions {
+	config: GatewayConfig;
+	apiKey: string;
+	backend: GatewayBackend;
+}
+
+export function createGatewayHttpServer(options: GatewayHttpOptions): Server {
+	if (!isLoopbackBind(options.config.bind) && options.apiKey.length === 0) {
+		throw new Error("gateway bind outside loopback requires a Bearer API key");
+	}
+	return createServer((req, res) => {
+		void route(req, res, options).catch((error) => {
+			if (res.headersSent) {
+				res.end();
+				return;
+			}
+			const envelope = gatewayErrorEnvelope(error);
+			writeJson(res, envelope.status, envelope.body);
+		});
+	});
+}
+
+export function listenGateway(server: Server, config: GatewayConfig): Promise<void> {
+	return new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(config.port, config.bind, () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+}
+
+export function closeGateway(server: Server): Promise<void> {
+	return new Promise((resolve, reject) => {
+		server.close((error) => {
+			if (error) reject(error);
+			else resolve();
+		});
+	});
+}
+
+async function route(req: IncomingMessage, res: ServerResponse, options: GatewayHttpOptions): Promise<void> {
+	const url = new URL(req.url ?? "/", "http://gateway.invalid");
+	if (req.method === "GET" && url.pathname === "/healthz") {
+		writeJson(res, 200, { ok: true, bind: options.config.bind, port: options.config.port });
+		return;
+	}
+	if (!authorize(req, options.apiKey)) {
+		writeJson(res, 401, {
+			error: { message: "missing or invalid bearer token", type: "invalid_request_error", code: "unauthorized" },
+		});
+		return;
+	}
+	if (req.method === "GET" && url.pathname === "/v1/models") {
+		const models = await options.backend.listModels();
+		writeJson(res, 200, {
+			object: "list",
+			data: models.map((model) => ({ id: model.id, object: "model", owned_by: model.owned_by })),
+		});
+		return;
+	}
+	if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
+		await handleOpenAiChatCompletions(req, res, options.backend);
+		return;
+	}
+	if (req.method === "POST" && url.pathname === "/v1/responses") {
+		await handleOpenAiResponses(req, res, options.backend);
+		return;
+	}
+	if (req.method === "POST" && url.pathname === "/v1/messages") {
+		await handleAnthropicMessages(req, res, options.backend);
+		return;
+	}
+	writeJson(res, 404, { error: { message: "not found", type: "invalid_request_error", code: "not_found" } });
+}
+
+function authorize(req: IncomingMessage, apiKey: string): boolean {
+	const header = req.headers.authorization;
+	if (typeof header !== "string" || !header.toLowerCase().startsWith("bearer ")) return false;
+	return gatewayKeysEqual(header.slice(7).trim(), apiKey);
+}
+
+function writeJson(res: ServerResponse, status: number, value: unknown): void {
+	const body = Buffer.from(`${JSON.stringify(value)}\n`);
+	res.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"content-length": body.byteLength,
+		"cache-control": "no-store",
+	});
+	res.end(body);
+}

package/src/gateway-openai-chat.ts

@@ -0,0 +1,124 @@
+/**
+ * OpenAI-compatible chat completions for the local gateway.
+ * @module dsh-coding-subscription-oauth/gateway-openai-chat
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type GatewayBackend, gatewayErrorEnvelope } from "./gateway-backend.ts";
+import { beginGatewaySse, readGatewayJsonBody, writeGatewayJson } from "./gateway-body.ts";
+import { parseOpenAiChatRequest } from "./gateway-parse.ts";
+import type { GatewayStreamPart } from "./gateway-protocol.ts";
+
+export async function handleOpenAiChatCompletions(
+	req: IncomingMessage,
+	res: ServerResponse,
+	backend: GatewayBackend,
+): Promise<void> {
+	const payload = await readGatewayJsonBody(req);
+	const request = parseOpenAiChatRequest(payload);
+	const stream = payload["stream"] !== false;
+	const id = `chatcmpl_gateway_${Date.now().toString(36)}`;
+	if (!stream) {
+		const aggregated = await aggregate(backend, request);
+		writeGatewayJson(res, 200, {
+			id,
+			object: "chat.completion",
+			model: request.model,
+			choices: [
+				{
+					index: 0,
+					message: aggregated.message,
+					finish_reason: aggregated.finish,
+				},
+			],
+		});
+		return;
+	}
+	beginGatewaySse(res);
+	try {
+		let toolIndex = 0;
+		for await (const part of backend.stream(request)) {
+			const chunk = sseChunk(id, request.model, part, toolIndex);
+			if (chunk === undefined) continue;
+			if (part.type === "tool_call") toolIndex += 1;
+			res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+		}
+		res.write("data: [DONE]\n\n");
+		res.end();
+	} catch (error) {
+		res.write(`data: ${JSON.stringify(gatewayErrorEnvelope(error).body)}\n\n`);
+		res.end();
+	}
+}
+
+async function aggregate(backend: GatewayBackend, request: ReturnType<typeof parseOpenAiChatRequest>) {
+	let content = "";
+	let reasoning = "";
+	const toolCalls: Array<{ id: string; type: "function"; function: { name: string; arguments: string } }> = [];
+	let finish: "stop" | "tool_calls" | "length" = "stop";
+	for await (const part of backend.stream(request)) {
+		if (part.type === "text") content += part.text;
+		if (part.type === "thinking") reasoning += part.text;
+		if (part.type === "tool_call") {
+			toolCalls.push({ id: part.id, type: "function", function: { name: part.name, arguments: part.arguments } });
+		}
+		if (part.type === "done") finish = part.finish;
+	}
+	return {
+		finish,
+		message: {
+			role: "assistant",
+			content,
+			...(reasoning.length === 0 ? {} : { reasoning_content: reasoning }),
+			...(toolCalls.length === 0 ? {} : { tool_calls: toolCalls }),
+		},
+	};
+}
+
+function sseChunk(id: string, model: string, part: GatewayStreamPart, toolIndex: number): unknown {
+	if (part.type === "text") {
+		return {
+			id,
+			object: "chat.completion.chunk",
+			model,
+			choices: [{ index: 0, delta: { content: part.text }, finish_reason: null }],
+		};
+	}
+	if (part.type === "thinking") {
+		return {
+			id,
+			object: "chat.completion.chunk",
+			model,
+			choices: [{ index: 0, delta: { reasoning_content: part.text }, finish_reason: null }],
+		};
+	}
+	if (part.type === "tool_call") {
+		return {
+			id,
+			object: "chat.completion.chunk",
+			model,
+			choices: [
+				{
+					index: 0,
+					delta: {
+						tool_calls: [
+							{
+								index: toolIndex,
+								id: part.id,
+								type: "function",
+								function: { name: part.name, arguments: part.arguments },
+							},
+						],
+					},
+					finish_reason: null,
+				},
+			],
+		};
+	}
+	return {
+		id,
+		object: "chat.completion.chunk",
+		model,
+		choices: [{ index: 0, delta: {}, finish_reason: part.finish }],
+	};
+}

package/src/gateway-openai-responses.ts

@@ -0,0 +1,53 @@
+/**
+ * OpenAI Responses API subset for the local gateway.
+ * @module dsh-coding-subscription-oauth/gateway-openai-responses
+ */
+
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type GatewayBackend, gatewayErrorEnvelope } from "./gateway-backend.ts";
+import { beginGatewaySse, readGatewayJsonBody, writeGatewayJson } from "./gateway-body.ts";
+import { parseOpenAiResponsesRequest } from "./gateway-parse.ts";
+
+export async function handleOpenAiResponses(
+	req: IncomingMessage,
+	res: ServerResponse,
+	backend: GatewayBackend,
+): Promise<void> {
+	const payload = await readGatewayJsonBody(req);
+	const request = parseOpenAiResponsesRequest(payload);
+	const stream = payload["stream"] !== false;
+	const id = `resp_gateway_${Date.now().toString(36)}`;
+	if (!stream) {
+		let text = "";
+		for await (const part of backend.stream(request)) {
+			if (part.type === "text") text += part.text;
+		}
+		writeGatewayJson(res, 200, {
+			id,
+			object: "response",
+			model: request.model,
+			status: "completed",
+			output: [{ type: "message", role: "assistant", content: [{ type: "output_text", text }] }],
+		});
+		return;
+	}
+	beginGatewaySse(res);
+	try {
+		res.write(
+			`event: response.created\ndata: ${JSON.stringify({ id, object: "response", model: request.model, status: "in_progress" })}\n\n`,
+		);
+		for await (const part of backend.stream(request)) {
+			if (part.type === "text") {
+				res.write(`event: response.output_text.delta\ndata: ${JSON.stringify({ id, delta: part.text })}\n\n`);
+			}
+		}
+		res.write(
+			`event: response.completed\ndata: ${JSON.stringify({ id, object: "response", status: "completed" })}\n\n`,
+		);
+		res.write("data: [DONE]\n\n");
+		res.end();
+	} catch (error) {
+		res.write(`event: error\ndata: ${JSON.stringify(gatewayErrorEnvelope(error).body)}\n\n`);
+		res.end();
+	}
+}