dsh-coding-subscription-oauth 0.6.3 → 0.6.5

package/src/gateway-backend.ts

@@ -1,274 +0,0 @@
-/**
- * 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

@@ -1,49 +0,0 @@
-/**
- * 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

@@ -1,76 +0,0 @@
-/**
- * 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

@@ -1,104 +0,0 @@
-/**
- * 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

@@ -1,124 +0,0 @@
-/**
- * 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

@@ -1,53 +0,0 @@
-/**
- * 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();
-	}
-}