@skydiveai/pi-server 0.1.0-beta.6

package/dist/index.mjs

@@ -0,0 +1,2854 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { pino } from "pino";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { getModel } from "@earendil-works/pi-ai";
+import { z } from "zod";
+import { homedir } from "node:os";
+import { join } from "node:path";
+//#region src/session-registry.ts
+function createMapSessionRegistry() {
+	const sessions = /* @__PURE__ */ new Map();
+	return {
+		get(id) {
+			return sessions.get(id) ?? null;
+		},
+		set(id, session) {
+			sessions.set(id, session);
+		},
+		delete(id) {
+			sessions.delete(id);
+		}
+	};
+}
+//#endregion
+//#region src/trace-context.ts
+/**
+* Per-request trace context. Protocol entry points wrap their handlers
+* in `runInTraceContext` and `requestLogger` records the request's
+* traceparent here, so anything downstream (the self-trace extension,
+* response headers) can read it without threading it through every
+* call. Lives in its own module so both `logger.ts` and `tracing.ts`
+* can import it without a cycle.
+*/
+const traceStorage = new AsyncLocalStorage();
+function runInTraceContext(fn) {
+	return traceStorage.run({ traceparent: null }, fn);
+}
+/** No-op when called outside `runInTraceContext`. */
+function setCurrentTraceparent(tp) {
+	const store = traceStorage.getStore();
+	if (store) store.traceparent = tp;
+}
+function getCurrentTraceparent() {
+	return traceStorage.getStore()?.traceparent ?? null;
+}
+/** Extract the trace id (second segment) from a `traceparent` value. */
+function parseTraceId(traceparent) {
+	if (!traceparent) return null;
+	const parts = traceparent.split("-");
+	return parts.length >= 2 ? parts[1] ?? null : null;
+}
+//#endregion
+//#region src/logger.ts
+/**
+* Base logger for the harness. Defaults to JSON line output (one event per
+* line, machine-greppable) so logs from inside the e2b sandbox can be
+* tailed and joined with api/proxy logs by `trace_id`. Set
+* `HARNESS_LOG_FORMAT=pretty` for human-readable output during local dev.
+*/
+const isPretty = process.env.HARNESS_LOG_FORMAT === "pretty";
+const logger = pino({
+	level: process.env.HARNESS_LOG_LEVEL ?? "info",
+	base: { service: process.env.HARNESS_LOG_SERVICE ?? "pi-server" },
+	...isPretty ? { transport: {
+		target: "pino-pretty",
+		options: {
+			colorize: true,
+			translateTime: "HH:MM:ss.l"
+		}
+	} } : {}
+});
+/**
+* W3C Trace Context: `traceparent: 00-<32 hex>-<16 hex>-<2 hex>`.
+* https://www.w3.org/TR/trace-context/#traceparent-header
+*
+* We only support version 00. Anything malformed → mint a fresh root.
+*/
+const TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/i;
+function hex(bytes) {
+	return randomBytes(bytes).toString("hex");
+}
+function newSpanId() {
+	return hex(8);
+}
+function newTraceContext() {
+	const traceId = hex(16);
+	const spanId = newSpanId();
+	return {
+		traceId,
+		spanId,
+		parentSpanId: null,
+		flags: "01",
+		traceparent: `00-${traceId}-${spanId}-01`
+	};
+}
+/**
+* Parse an incoming `traceparent` and mint a child span id under the same
+* trace id. The parent span id is preserved so logs can stitch caller and
+* callee. Returns a fresh root context if the header is missing or malformed.
+*/
+function deriveTraceContext(headerValue) {
+	if (typeof headerValue !== "string") return newTraceContext();
+	const m = headerValue.match(TRACEPARENT_RE);
+	if (!m) return newTraceContext();
+	const [, , traceId, parentSpanId, flags] = m;
+	const spanId = newSpanId();
+	return {
+		traceId,
+		spanId,
+		parentSpanId,
+		flags,
+		traceparent: `00-${traceId}-${spanId}-${flags}`
+	};
+}
+/**
+* Build a per-request child logger pre-bound with trace context. Every event
+* emitted from `req` should go through this logger so it auto-inherits
+* `trace_id`/`span_id`/`parent_span_id`.
+*/
+function requestLogger(request) {
+	const trace = deriveTraceContext(request.headers.get("traceparent"));
+	setCurrentTraceparent(trace.traceparent);
+	return {
+		log: logger.child({
+			trace_id: trace.traceId,
+			span_id: trace.spanId,
+			parent_span_id: trace.parentSpanId
+		}),
+		trace
+	};
+}
+//#endregion
+//#region src/protocols/prewarm.ts
+/**
+* Prewarm endpoint — POST to a configured path runs a 1-token chat
+* completion so the first real request doesn't pay session/model
+* cold-start. Invokes the chat-completions handler in-process (no HTTP
+* loopback).
+*/
+function createPrewarm({ paths, chatCompletions }) {
+	const prewarmPaths = new Set(paths);
+	return async (request) => {
+		if (prewarmPaths.size === 0) return null;
+		const url = new URL(request.url);
+		if (request.method !== "POST" || !prewarmPaths.has(url.pathname)) return null;
+		const start = performance.now();
+		try {
+			const warmHeaders = { "content-type": "application/json" };
+			const envdToken = request.headers.get("x-e2b-envd-token");
+			if (envdToken) warmHeaders["x-e2b-envd-token"] = envdToken;
+			await (await chatCompletions(new Request(new URL("/v1/chat/completions", url.origin), {
+				method: "POST",
+				headers: warmHeaders,
+				body: JSON.stringify({
+					max_tokens: 1,
+					stream: false,
+					messages: [{
+						role: "user",
+						content: "hi"
+					}]
+				})
+			})))?.text();
+			const ms = Math.round(performance.now() - start);
+			logger.info({
+				event: "prewarm_done",
+				ms
+			}, "harness prewarm complete");
+			return Response.json({
+				ok: true,
+				ms
+			});
+		} catch (err) {
+			logger.error({
+				err,
+				event: "prewarm_failed"
+			}, "harness prewarm failed");
+			return Response.json({ error: err instanceof Error ? err.message : "prewarm failed" }, { status: 500 });
+		}
+	};
+}
+//#endregion
+//#region src/constants.ts
+const DEFAULT_PROVIDER = "anthropic";
+const DEFAULT_MODEL = "claude-opus-4-7";
+const DEFAULT_THINKING_LEVEL = "medium";
+const VALID_THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
+const PI_AGENT_DIR = join(homedir(), ".pi", "agent");
+//#endregion
+//#region src/protocols/shared.ts
+/**
+* Provider usage off an `agent_end` event, from the last assistant message that
+* actually carries it — the final billed call saw the full accumulated context,
+* so its counts are the turn's context size. A trailing assistant message
+* without usage (e.g. a tool-only turn) isn't a report, so skip past it rather
+* than give up. Null when no assistant message reported usage, or the report
+* lacks the core counts: we don't fabricate zeros, so sizing falls back to the
+* estimate instead of trusting a fake 0.
+*/
+function extractAgentEndUsage(event) {
+	const u = [...event.messages ?? []].reverse().find((m) => m?.role === "assistant" && m?.usage)?.usage;
+	if (!u || u.input == null || u.output == null) return null;
+	return {
+		input: u.input,
+		output: u.output,
+		cacheRead: u.cacheRead ?? 0,
+		cacheWrite: u.cacheWrite ?? 0,
+		totalTokens: u.totalTokens ?? 0
+	};
+}
+const PER_REQUEST_API_KEY_HEADERS = [{
+	header: "x-anthropic-api-key",
+	provider: "anthropic"
+}, {
+	header: "x-openai-api-key",
+	provider: "openai"
+}];
+function resolvePerRequestApiKeys(request) {
+	const out = {};
+	for (const { header, provider } of PER_REQUEST_API_KEY_HEADERS) {
+		const v = request.headers.get(header);
+		if (v) out[provider] = v;
+	}
+	if (!out.anthropic) {
+		const auth = request.headers.get("authorization");
+		if (auth && /^Bearer\s+/i.test(auth)) out.anthropic = auth.replace(/^Bearer\s+/i, "");
+	}
+	return out;
+}
+function parseSessionId(request) {
+	const raw = request.headers.get("x-session-id");
+	if (!raw) return {
+		sessionId: randomUUID(),
+		source: "generated",
+		invalid: false
+	};
+	if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(raw)) return {
+		sessionId: raw,
+		source: "header",
+		invalid: false
+	};
+	return {
+		sessionId: randomUUID(),
+		source: "generated",
+		invalid: true
+	};
+}
+function parseShellEnv(request) {
+	const raw = request.headers.get("x-shell-env");
+	if (!raw) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+		const env = {};
+		for (const [k, v] of Object.entries(parsed)) if (typeof v === "string") env[k] = v;
+		return Object.keys(env).length > 0 ? env : null;
+	} catch {
+		return null;
+	}
+}
+function jsonResponse(body, status = 200) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+function jsonError(status, message) {
+	return jsonResponse({ error: { message } }, status);
+}
+const SSE_KEEPALIVE_INTERVAL_MS = 15e3;
+function createSSEResponse(handler) {
+	const encoder = new TextEncoder();
+	let controller;
+	const stream = new ReadableStream({ start(ctrl) {
+		controller = ctrl;
+	} });
+	const writer = {
+		write(chunk) {
+			try {
+				controller.enqueue(encoder.encode(chunk));
+			} catch {}
+		},
+		close() {
+			try {
+				controller.close();
+			} catch {}
+		}
+	};
+	const keepalive = setInterval(() => {
+		writer.write(": keepalive\n\n");
+	}, SSE_KEEPALIVE_INTERVAL_MS);
+	handler(writer).then(() => {
+		clearInterval(keepalive);
+		try {
+			controller.close();
+		} catch {}
+	}, (err) => {
+		logger.error({ err }, "SSE handler crashed — stream closed without response");
+		clearInterval(keepalive);
+		try {
+			controller.close();
+		} catch {}
+	});
+	return new Response(stream, {
+		status: 200,
+		headers: {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache, no-transform",
+			Connection: "keep-alive",
+			"X-Accel-Buffering": "no"
+		}
+	});
+}
+function resolveModel(modelString, log) {
+	const raw = typeof modelString === "string" && modelString.trim() ? modelString.trim() : DEFAULT_MODEL;
+	let provider = DEFAULT_PROVIDER;
+	let name = raw;
+	const sep = raw.match(/[:/]/);
+	if (sep) [provider, name] = raw.split(sep[0], 2);
+	const found = getModel(provider, name);
+	if (found) return found;
+	log.warn({
+		event: "model_unknown",
+		requested_provider: provider,
+		requested_model: name,
+		fallback_provider: DEFAULT_PROVIDER,
+		fallback_model: DEFAULT_MODEL
+	}, "unknown model, falling back to default");
+	return getModel(DEFAULT_PROVIDER, DEFAULT_MODEL);
+}
+const contextWindowSchema = z.number().int().positive();
+function applyContextWindowOverride(model, contextWindow) {
+	const parsed = contextWindowSchema.safeParse(contextWindow);
+	if (!parsed.success) return model;
+	return {
+		...model,
+		contextWindow: parsed.data
+	};
+}
+function resolveThinkingLevel(input) {
+	if (typeof input === "string" && VALID_THINKING_LEVELS.includes(input)) return input;
+	return DEFAULT_THINKING_LEVEL;
+}
+async function fetchImageAsBase64({ url, userAgent }) {
+	const ctrl = new AbortController();
+	const timeout = setTimeout(() => ctrl.abort(), 15e3);
+	try {
+		const r = await fetch(url, {
+			headers: { "user-agent": userAgent || "pi-server/0.1" },
+			redirect: "follow",
+			signal: ctrl.signal
+		});
+		if (!r.ok) throw new Error(`HTTP ${r.status}`);
+		return {
+			type: "image",
+			mimeType: r.headers.get("content-type")?.split(";")[0]?.trim() || "image/png",
+			data: Buffer.from(await r.arrayBuffer()).toString("base64")
+		};
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+async function runConversation({ session, prompt, images, log, postPrompt }) {
+	await session.prompt(prompt, images.length ? { images } : void 0);
+	if (postPrompt) await postPrompt({
+		session,
+		log
+	});
+}
+/**
+* Hard-stop the in-flight turn for a session. Shared by every protocol's
+* `/:id/abort` route: a cancel signals the stop explicitly instead of relying
+* on a dropped connection. `session.abort()` interrupts the turn and resolves
+* once the agent is idle, so a 200 means the agent has actually stopped (404 =
+* nothing running to stop).
+*/
+async function handleAbort({ request, sessionId, registry }) {
+	const { log } = requestLogger(request);
+	const session = registry.get(sessionId);
+	if (!session) return jsonError(404, "session not found or already completed");
+	await session.abort();
+	log.info({
+		event: "abort_accepted",
+		session_id: sessionId
+	}, "session aborted");
+	return jsonResponse({ ok: true });
+}
+//#endregion
+//#region src/protocols/a2a.ts
+/**
+* A2A (Agent-to-Agent) protocol handler.
+*
+* Exports an AgentExecutor + agent card builder for use with the
+* @a2a-js/sdk server. The SDK's Express restHandler handles all
+* routing and proto-JSON serialization.
+*
+* @see https://google.github.io/A2A/specification/
+*/
+async function extractParts(parts, log) {
+	let text = "";
+	const images = [];
+	for (const part of parts) {
+		if (part.text != null) {
+			text += part.text;
+			continue;
+		}
+		if (part.raw != null && part.mediaType?.startsWith("image/")) {
+			images.push({
+				type: "image",
+				mimeType: part.mediaType,
+				data: part.raw
+			});
+			continue;
+		}
+		if (part.url != null && part.mediaType?.startsWith("image/")) {
+			try {
+				images.push(await fetchImageAsBase64({ url: part.url }));
+			} catch (err) {
+				log.warn({
+					event: "a2a_image_fetch_failed",
+					url: part.url,
+					err
+				}, "image fetch failed");
+				text += `\n[image fetch failed: ${part.url}]\n`;
+			}
+			continue;
+		}
+		if (part.data != null) text += `\n${JSON.stringify(part.data)}\n`;
+	}
+	return {
+		text: text.trim(),
+		images
+	};
+}
+function createAgentExecutor(options) {
+	const onSessionSetup = options.onSessionSetup ?? (() => {});
+	const postPrompt = options.postPrompt;
+	const sessions = /* @__PURE__ */ new Map();
+	const taskSessions = /* @__PURE__ */ new Map();
+	const executor = {
+		async execute(requestContext, eventBus) {
+			const { log } = requestLogger(new Request("http://localhost/a2a"));
+			const userMessage = requestContext.userMessage;
+			const { text: prompt, images } = await extractParts(userMessage.parts ?? userMessage.content ?? [], log);
+			const taskId = requestContext.taskId;
+			const contextId = requestContext.contextId;
+			eventBus.publish({
+				kind: "task",
+				id: taskId,
+				contextId,
+				status: { state: "working" }
+			});
+			if (!prompt && images.length === 0) {
+				eventBus.publish({
+					kind: "status-update",
+					taskId,
+					contextId,
+					status: {
+						state: "failed",
+						message: {
+							kind: "message",
+							messageId: randomUUID(),
+							role: "agent",
+							parts: [{
+								kind: "text",
+								text: "No extractable content"
+							}]
+						}
+					}
+				});
+				eventBus.finished();
+				return;
+			}
+			const existing = sessions.get(contextId);
+			if (existing) {
+				log.info({
+					event: "a2a_steer",
+					contextId,
+					taskId
+				}, "steering existing session");
+				await existing.session.steer(prompt, images.length > 0 ? images : void 0);
+				eventBus.finished();
+				return;
+			}
+			const cwd = options.cwd ?? process.cwd();
+			const sessionResult = await options.createSession({
+				cwd,
+				sessionId: randomUUID(),
+				perRequestApiKeys: {},
+				systemPromptOverride: null,
+				shellEnv: null,
+				model: resolveModel(void 0, log),
+				thinkingLevel: null,
+				log,
+				onSessionSetup,
+				prepare: null
+			});
+			const { session } = sessionResult;
+			sessions.set(contextId, sessionResult);
+			taskSessions.set(taskId, sessionResult);
+			let responseText = "";
+			session.subscribe((event) => {
+				const ev = event;
+				if (ev.type === "message_update" && ev.assistantMessageEvent?.type === "text_delta") {
+					responseText += ev.assistantMessageEvent.delta ?? "";
+					eventBus.publish({
+						kind: "status-update",
+						taskId,
+						contextId,
+						status: {
+							state: "working",
+							message: {
+								kind: "message",
+								messageId: randomUUID(),
+								role: "agent",
+								parts: [{
+									kind: "text",
+									text: responseText
+								}]
+							}
+						}
+					});
+				}
+				if (ev.type === "tool_execution_end") {
+					const resultText = Array.isArray(ev.result?.content) ? ev.result.content.filter((p) => p?.type === "text").map((p) => p.text ?? "").join("") : typeof ev.result === "string" ? ev.result : "";
+					eventBus.publish({
+						kind: "artifact-update",
+						taskId,
+						contextId,
+						artifact: {
+							artifactId: randomUUID(),
+							name: String(ev.toolName ?? "tool_result"),
+							parts: [{
+								kind: "data",
+								data: {
+									toolCallId: ev.toolCallId,
+									toolName: ev.toolName,
+									result: resultText,
+									isError: ev.isError ?? false
+								}
+							}]
+						},
+						lastChunk: true
+					});
+				}
+			});
+			try {
+				await runConversation({
+					session,
+					prompt,
+					images,
+					log,
+					postPrompt
+				});
+			} catch (err) {
+				log.error({
+					event: "a2a_executor_error",
+					err
+				}, "agent execution error");
+			} finally {
+				sessions.delete(contextId);
+				taskSessions.delete(taskId);
+			}
+			eventBus.publish({
+				kind: "status-update",
+				taskId,
+				contextId,
+				status: {
+					state: "completed",
+					message: {
+						kind: "message",
+						messageId: randomUUID(),
+						role: "agent",
+						parts: [{
+							kind: "text",
+							text: responseText || "(no text output)"
+						}]
+					}
+				}
+			});
+			eventBus.finished();
+		},
+		async cancelTask(taskId, eventBus) {
+			await taskSessions.get(taskId)?.session.abort();
+			eventBus.finished();
+		}
+	};
+	return {
+		...executor,
+		execute: (requestContext, eventBus) => runInTraceContext(() => executor.execute(requestContext, eventBus))
+	};
+}
+function buildAgentCard(baseUrl, overrides) {
+	const o = overrides ?? {};
+	return {
+		name: o.name ?? "Pi Agent",
+		description: o.description ?? "A pi coding agent.",
+		url: baseUrl,
+		version: o.version ?? "0.1.0",
+		protocolVersion: "1.0",
+		preferredTransport: "HTTP+JSON",
+		additionalInterfaces: [{
+			url: baseUrl,
+			transport: "HTTP+JSON"
+		}],
+		capabilities: {
+			streaming: true,
+			pushNotifications: false
+		},
+		defaultInputModes: ["text/plain"],
+		defaultOutputModes: ["text/plain"],
+		skills: o.skills ?? [{
+			id: "code-generation",
+			name: "Code Generation",
+			description: "Generate, edit, and refactor code."
+		}, {
+			id: "tool-use",
+			name: "Tool Use",
+			description: "Execute shell commands, read/write files, and use MCP tools."
+		}]
+	};
+}
+//#endregion
+//#region src/model-spec.ts
+/**
+* Runtime mirror of pi-ai's `KnownProvider` union (which is type-only). The
+* `satisfies` keeps every member valid against the type; new pi-ai providers
+* are admitted by adding them here.
+*/
+const KNOWN_PI_PROVIDERS = [
+	"amazon-bedrock",
+	"anthropic",
+	"google",
+	"google-vertex",
+	"openai",
+	"azure-openai-responses",
+	"openai-codex",
+	"deepseek",
+	"github-copilot",
+	"xai",
+	"groq",
+	"cerebras",
+	"openrouter",
+	"vercel-ai-gateway",
+	"zai",
+	"mistral",
+	"minimax",
+	"minimax-cn",
+	"moonshotai",
+	"moonshotai-cn",
+	"huggingface",
+	"fireworks",
+	"opencode",
+	"opencode-go",
+	"kimi-coding",
+	"cloudflare-workers-ai",
+	"cloudflare-ai-gateway",
+	"xiaomi",
+	"xiaomi-token-plan-cn",
+	"xiaomi-token-plan-ams",
+	"xiaomi-token-plan-sgp"
+];
+/**
+* Mirrors pi-ai's `ThinkingLevelMap`. Each key is genuinely tri-state:
+* absent = provider default, `null` = level unsupported, string = the
+* provider-specific value for that level.
+*/
+const thinkingLevelMapSchema = z.object({
+	off: z.string().nullable().optional(),
+	minimal: z.string().nullable().optional(),
+	low: z.string().nullable().optional(),
+	medium: z.string().nullable().optional(),
+	high: z.string().nullable().optional(),
+	xhigh: z.string().nullable().optional()
+});
+/**
+* Per-API compat overrides, mirroring pi-ai's compat interfaces. Every field
+* is genuinely tri-state: absent defers to pi-ai's baseUrl auto-detection
+* (`detectCompat`), present pins the knob. Unknown keys are stripped rather
+* than rejected so an already-shipped server tolerates knobs added for newer
+* models instead of kicking the whole spec back to registry resolution.
+*/
+const openaiCompletionsCompatSchema = z.object({
+	supportsReasoningEffort: z.boolean().optional(),
+	requiresThinkingAsText: z.boolean().optional(),
+	thinkingFormat: z.enum([
+		"openai",
+		"openrouter",
+		"deepseek",
+		"zai",
+		"qwen",
+		"qwen-chat-template"
+	]).optional(),
+	supportsStrictMode: z.boolean().optional(),
+	maxTokensField: z.enum(["max_completion_tokens", "max_tokens"]).optional(),
+	cacheControlFormat: z.literal("anthropic").optional()
+}).strip();
+const anthropicMessagesCompatSchema = z.object({
+	supportsEagerToolInputStreaming: z.boolean().optional(),
+	supportsLongCacheRetention: z.boolean().optional()
+}).strip();
+const baseSpecShape = {
+	/** Exact model id the serving endpoint expects. */
+	id: z.string().min(1),
+	/** Display name shown in pi surfaces and session logs. */
+	name: z.string().min(1),
+	/** pi-ai provider key — also the auth-storage key for `apiKey`. */
+	provider: z.enum(KNOWN_PI_PROVIDERS),
+	/** Provider API root, e.g. "https://openrouter.ai/api/v1". */
+	baseUrl: z.string().url(),
+	reasoning: z.boolean(),
+	thinkingLevelMap: thinkingLevelMapSchema.optional(),
+	input: z.array(z.enum(["text", "image"])).nonempty(),
+	contextWindow: z.number().int().positive(),
+	maxTokens: z.number().int().positive(),
+	/**
+	* Optional runtime API key for `provider`, installed as a per-request key
+	* so the model registry's auth lookup succeeds. Deployments that resolve
+	* real credentials elsewhere (e.g. at an egress proxy) can pass whatever
+	* placeholder that layer recognizes — the value is opaque to this server.
+	*/
+	apiKey: z.string().min(1).optional()
+};
+const modelSpecSchema = z.discriminatedUnion("api", [z.object({
+	...baseSpecShape,
+	api: z.literal("openai-completions"),
+	compat: openaiCompletionsCompatSchema.optional()
+}), z.object({
+	...baseSpecShape,
+	api: z.literal("anthropic-messages"),
+	compat: anthropicMessagesCompatSchema.optional()
+})]);
+/**
+* Parse a request-body `x_model`. Null when absent or invalid — never a
+* request rejection, so a malformed spec degrades to the legacy body-model
+* resolution instead of failing the turn.
+*/
+function parseModelSpec(input, log) {
+	if (input == null) return null;
+	const parsed = modelSpecSchema.safeParse(input);
+	if (!parsed.success) {
+		log.warn({
+			event: "x_model_invalid",
+			issues: parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+		}, "ignoring invalid x_model, falling back to body model");
+		return null;
+	}
+	return parsed.data;
+}
+function buildModelFromSpec(spec) {
+	const base = {
+		id: spec.id,
+		name: spec.name,
+		provider: spec.provider,
+		baseUrl: spec.baseUrl,
+		reasoning: spec.reasoning,
+		...spec.thinkingLevelMap ? { thinkingLevelMap: spec.thinkingLevelMap } : {},
+		input: spec.input,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: spec.contextWindow,
+		maxTokens: spec.maxTokens
+	};
+	switch (spec.api) {
+		case "openai-completions": return {
+			...base,
+			api: spec.api,
+			...spec.compat ? { compat: spec.compat } : {}
+		};
+		case "anthropic-messages": return {
+			...base,
+			api: spec.api,
+			...spec.compat ? { compat: spec.compat } : {}
+		};
+		default: throw new Error(`Unhandled x_model api: ${String(spec)}`);
+	}
+}
+/**
+* Resolve the model a request should run on: a valid `x_model` wins,
+* anything else falls back to registry resolution of the body model. Shared
+* by every transport so they honor the spec identically.
+*/
+function resolveRequestModel({ modelInput, modelSpecInput, defaultModel, log }) {
+	const modelSpec = parseModelSpec(modelSpecInput, log);
+	return {
+		modelSpec,
+		model: modelSpec ? buildModelFromSpec(modelSpec) : resolveModel(modelInput ?? defaultModel, log)
+	};
+}
+/**
+* Install the spec's runtime API key as the per-request key for its
+* provider. A caller-supplied key for the same provider (request headers)
+* always wins.
+*/
+function withSpecApiKey(keys, modelSpec) {
+	if (!modelSpec?.apiKey || keys[modelSpec.provider]) return keys;
+	return {
+		...keys,
+		[modelSpec.provider]: modelSpec.apiKey
+	};
+}
+//#endregion
+//#region src/protocols/model-provider-error.ts
+function numericStatus(err) {
+	const s = err.status ?? err.statusCode;
+	return typeof s === "number" ? s : null;
+}
+function messageText(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	const m = err?.message;
+	return typeof m === "string" ? m : String(err);
+}
+function providerErrorType(err) {
+	const e = err.error;
+	if (e && typeof e === "object" && "type" in e) {
+		const t = e.type;
+		if (typeof t === "string") return t;
+	}
+	return null;
+}
+/**
+* A stable, machine-readable code when the provider supplies one — preferred
+* over message text since wording drifts. Covers OpenAI / Vercel AI Gateway
+* (`error.code`, e.g. `context_length_exceeded`, `rate_limit_exceeded`) and
+* OpenRouter (`error.metadata.error_type`, its canonical vocabulary). Anthropic
+* and Gemini have no per-overflow code, so they fall through to the message
+* regex; Gemini's `error.status` (e.g. `INVALID_ARGUMENT`) is too generic to map
+* on its own.
+*/
+function machineCode(err) {
+	const e = err.error;
+	if (!e || typeof e !== "object") return null;
+	const code = e.code;
+	if (typeof code === "string") return code;
+	const meta = e.metadata;
+	if (meta && typeof meta === "object") {
+		const errorType = meta.error_type;
+		if (typeof errorType === "string") return errorType;
+	}
+	return null;
+}
+function providerId(err, message) {
+	if (typeof err.provider === "string") return err.provider;
+	if (/anthropic|claude/i.test(message)) return "anthropic";
+	if (/openai|gpt-/i.test(message)) return "openai";
+	return null;
+}
+/**
+* A context-overflow message from any provider. Verified shapes (see research):
+*   - Anthropic:  "prompt is too long: 1001955 tokens > 1000000 maximum"
+*   - Anthropic (1M beta): "Prompt exceeds maximum token limit (191989 > 180000)"
+*   - OpenAI / Vercel AI Gateway: "This model's maximum context length is N tokens..."
+*   - OpenRouter: "This endpoint's maximum context length is N tokens..."
+*   - Gemini: "The input token count (N) exceeds the maximum number of tokens allowed (M)"
+*/
+const CONTEXT_OVERFLOW_MESSAGE = /prompt is too long|context[_ ]length[_ ]exceeded|maximum context length|exceeds maximum token limit|input token count|too many tokens|exceeds the maximum/i;
+/**
+* Map a provider error to a stable code. Prefers the provider's machine code
+* (OpenAI `error.code`, OpenRouter `error.metadata.error_type`) over message
+* text, then falls back to status + message regex for providers that don't
+* carry one (Anthropic, Gemini). Context overflow drives reactive compaction,
+* so it's matched first and most specifically.
+*/
+function classifyCode(status, message, code) {
+	if (code === "context_length_exceeded" || CONTEXT_OVERFLOW_MESSAGE.test(message)) return "context_length_exceeded";
+	if (status === 402 || code === "insufficient_credits" || code === "insufficient_quota" || /insufficient credits|requires more credits|credit balance is too low|payment required|purchase more credits/i.test(message)) return "provider_out_of_credits";
+	if (status === 429 || code === "rate_limit_exceeded" || /rate[_ ]limit|too many requests|resource[_ ]exhausted/i.test(message)) return "rate_limited";
+	if (status === 529 || code === "provider_overloaded" || /overloaded/i.test(message)) return "provider_overloaded";
+	if (status === 503 || status === 504 || code === "provider_unavailable" || /no healthy upstream|upstream request timeout|stream timeout|service unavailable|unavailable|gateway/i.test(message)) return "provider_unavailable";
+	return "provider_error";
+}
+/**
+* True when the thrown error looks like it originated from a model-provider
+* call (it carries an HTTP status or a provider-shaped error body) rather than
+* an arbitrary harness-internal throw. Conservative: when unsure, returns false
+* so the caller keeps the existing generic handling.
+*/
+function isModelProviderError(err) {
+	if (err === null || typeof err !== "object") return false;
+	const e = err;
+	if (numericStatus(e) !== null) return true;
+	if (e.error && typeof e.error === "object") return true;
+	const msg = messageText(err);
+	return /prompt is too long|context[_ ]length[_ ]exceeded|exceeds maximum token limit|input token count|rate[_ ]limit|overloaded|no healthy upstream|upstream request timeout|insufficient credits|requires more credits|credit balance is too low|payment required|purchase more credits/i.test(msg);
+}
+/** Build the structured, forwardable error from a thrown model-provider error. */
+function toModelProviderError(err) {
+	const e = err ?? {};
+	const status = numericStatus(e);
+	const message = messageText(err);
+	return {
+		code: classifyCode(status, message, machineCode(e)),
+		message,
+		provider: providerId(e, message),
+		type: providerErrorType(e),
+		upstreamStatus: status
+	};
+}
+//#endregion
+//#region src/protocols/anthropic-messages.ts
+/**
+* Anthropic Messages API–compatible protocol handler.
+*
+* Catch-all: returns Response on match, null on no match.
+* Zero server-framework deps — just Web Standard Request/Response.
+*
+* Routes:
+*   POST /v1/messages
+*   POST /v1/messages/:id/abort
+*
+* @see https://docs.anthropic.com/en/api/messages
+*/
+function sseEvent(writer, event, data) {
+	writer.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+}
+async function extractContent$1(content, log) {
+	if (typeof content === "string") return {
+		text: content,
+		images: []
+	};
+	if (!Array.isArray(content)) return {
+		text: "",
+		images: []
+	};
+	let text = "";
+	const images = [];
+	for (const block of content) {
+		if (block?.type === "text") {
+			text += block.text ?? "";
+			continue;
+		}
+		if (block?.type === "image") {
+			const src = block.source;
+			if (src?.type === "base64" && src.media_type && src.data) images.push({
+				type: "image",
+				mimeType: src.media_type,
+				data: src.data
+			});
+			else if (src?.type === "url" && src.url) try {
+				images.push(await fetchImageAsBase64({ url: src.url }));
+			} catch (err) {
+				log.warn({
+					event: "image_fetch_failed",
+					url: src.url,
+					err
+				}, "image fetch failed");
+				text += `\n[image fetch failed: ${src.url}]\n`;
+			}
+			continue;
+		}
+	}
+	return {
+		text,
+		images
+	};
+}
+function extractSystemPrompt(system) {
+	if (typeof system === "string") return system;
+	if (!Array.isArray(system)) return "";
+	return system.filter((b) => b?.type === "text").map((b) => b.text ?? "").join("\n\n");
+}
+async function loadHistoryIntoSession$1({ sm, messages, upToIdxExclusive, modelName, log }) {
+	const toolCallNames = /* @__PURE__ */ new Map();
+	for (let i = 0; i < upToIdxExclusive; i++) {
+		const m = messages[i];
+		if (!m) continue;
+		if (m.role === "user") {
+			const { text, images } = await extractContent$1(m.content, log);
+			const content = images.length > 0 ? [...text ? [{
+				type: "text",
+				text
+			}] : [], ...images] : text;
+			if (typeof content === "string" && content.length > 0 || Array.isArray(content) && content.length > 0) sm.appendMessage({
+				role: "user",
+				content,
+				timestamp: Date.now()
+			});
+			continue;
+		}
+		if (m.role === "assistant") {
+			const contentArr = [];
+			const blocks = Array.isArray(m.content) ? m.content : [];
+			for (const b of blocks) if (b?.type === "text" && b.text) contentArr.push({
+				type: "text",
+				text: b.text
+			});
+			else if (b?.type === "tool_use") {
+				contentArr.push({
+					type: "toolCall",
+					id: b.id,
+					name: b.name,
+					arguments: b.input ?? {}
+				});
+				toolCallNames.set(b.id, b.name);
+			}
+			if (contentArr.length === 0) continue;
+			sm.appendMessage({
+				role: "assistant",
+				content: contentArr,
+				api: "anthropic-messages",
+				provider: "anthropic",
+				model: modelName,
+				usage: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					totalTokens: 0,
+					cost: {
+						input: 0,
+						output: 0,
+						cacheRead: 0,
+						cacheWrite: 0,
+						total: 0
+					}
+				},
+				stopReason: contentArr.some((c) => c.type === "toolCall") ? "toolUse" : "stop",
+				timestamp: Date.now()
+			});
+			continue;
+		}
+	}
+}
+async function handleMessages(request, ctx, registry) {
+	const { log, trace } = requestLogger(request);
+	let parsed;
+	try {
+		parsed = JSON.parse(await request.text());
+	} catch {
+		return jsonError(400, "invalid json");
+	}
+	const { messages, stream = false, model: modelInput, system, x_model: modelSpecInput } = parsed ?? {};
+	if (!Array.isArray(messages) || messages.length === 0) return jsonError(400, "messages array required");
+	let lastUserIdx = -1;
+	for (let i = messages.length - 1; i >= 0; i--) if (messages[i]?.role === "user") {
+		lastUserIdx = i;
+		break;
+	}
+	if (lastUserIdx < 0) return jsonError(400, "no user message");
+	const { text: prompt, images } = await extractContent$1(messages[lastUserIdx].content, log);
+	if (!prompt && images.length === 0) return jsonError(400, "user message has no content");
+	const { model, modelSpec } = resolveRequestModel({
+		modelInput,
+		modelSpecInput,
+		defaultModel: ctx.defaultModel,
+		log
+	});
+	const modelName = model.id ?? "claude-opus-4-7";
+	const baseSystemPrompt = extractSystemPrompt(system);
+	const { sessionId } = parseSessionId(request);
+	const shellEnv = parseShellEnv(request);
+	const { session, sessionManager: sm } = await ctx.createSession({
+		cwd: ctx.cwd,
+		sessionId,
+		perRequestApiKeys: withSpecApiKey(resolvePerRequestApiKeys(request), modelSpec),
+		systemPromptOverride: () => baseSystemPrompt.length > 0 ? baseSystemPrompt : void 0,
+		shellEnv,
+		model,
+		thinkingLevel: null,
+		log,
+		onSessionSetup: (args) => ctx.onSessionSetup?.(args),
+		prepare: ({ sessionManager }) => loadHistoryIntoSession$1({
+			sm: sessionManager,
+			messages,
+			upToIdxExclusive: lastUserIdx,
+			modelName,
+			log
+		})
+	});
+	registry.set(sessionId, session);
+	const id = `msg_${randomUUID().replace(/-/g, "").slice(0, 20)}`;
+	if (stream) {
+		const response = runStream$2({
+			session,
+			sm,
+			prompt,
+			images,
+			id,
+			sessionId,
+			modelName,
+			log,
+			postPrompt: ctx.postPrompt,
+			registry
+		});
+		const traceId = parseTraceId(trace.traceparent);
+		if (traceId) response.headers.set("x-trace-id", traceId);
+		return response;
+	}
+	const response = await runBlocking$2({
+		session,
+		sm,
+		prompt,
+		images,
+		id,
+		sessionId,
+		modelName,
+		log,
+		postPrompt: ctx.postPrompt,
+		registry
+	});
+	const traceId = parseTraceId(trace.traceparent);
+	if (traceId) response.headers.set("x-trace-id", traceId);
+	return response;
+}
+function runStream$2({ session, sm, prompt, images, id, sessionId, modelName, log, postPrompt, registry }) {
+	return createSSEResponse(async (writer) => {
+		let contentBlockIndex = 0;
+		let textBlockOpen = false;
+		const tcByContentIdx = /* @__PURE__ */ new Map();
+		sseEvent(writer, "message_start", {
+			type: "message_start",
+			message: {
+				id,
+				type: "message",
+				role: "assistant",
+				model: modelName,
+				content: [],
+				stop_reason: null,
+				stop_sequence: null,
+				usage: {
+					input_tokens: 0,
+					cache_creation_input_tokens: 0,
+					cache_read_input_tokens: 0,
+					output_tokens: 0
+				}
+			}
+		});
+		sseEvent(writer, "ping", { type: "ping" });
+		const ensureTextBlock = () => {
+			if (textBlockOpen) return;
+			sseEvent(writer, "content_block_start", {
+				type: "content_block_start",
+				index: contentBlockIndex,
+				content_block: {
+					type: "text",
+					text: ""
+				}
+			});
+			textBlockOpen = true;
+		};
+		const closeTextBlock = () => {
+			if (!textBlockOpen) return;
+			sseEvent(writer, "content_block_stop", {
+				type: "content_block_stop",
+				index: contentBlockIndex
+			});
+			contentBlockIndex++;
+			textBlockOpen = false;
+		};
+		let capturedModelError = null;
+		const emitProviderError = (providerError) => {
+			log.warn({
+				event: "model_provider_error",
+				code: providerError.code,
+				upstream_status: providerError.upstreamStatus,
+				provider: providerError.provider
+			}, "forwarding model-provider error to client");
+			sseEvent(writer, "error", {
+				type: "error",
+				error: {
+					type: providerError.type ?? "api_error",
+					message: providerError.message,
+					x_model_provider_error: {
+						code: providerError.code,
+						provider: providerError.provider,
+						upstream_status: providerError.upstreamStatus
+					}
+				}
+			});
+		};
+		session.subscribe((event) => {
+			const ev = event;
+			const endedMessage = ev.message ?? (Array.isArray(ev.messages) ? ev.messages[ev.messages.length - 1] : null);
+			if (endedMessage?.stopReason === "error" && typeof endedMessage.errorMessage === "string" && endedMessage.errorMessage.length > 0) capturedModelError = endedMessage.errorMessage;
+			if (ev.type !== "message_update") return;
+			const inner = ev.assistantMessageEvent;
+			if (!inner) return;
+			if (inner.type === "text_delta") {
+				ensureTextBlock();
+				sseEvent(writer, "content_block_delta", {
+					type: "content_block_delta",
+					index: contentBlockIndex,
+					delta: {
+						type: "text_delta",
+						text: inner.delta ?? ""
+					}
+				});
+				return;
+			}
+			if (inner.type === "toolcall_start") {
+				closeTextBlock();
+				const idx = inner.contentIndex;
+				const item = inner.partial?.content?.[idx];
+				const tc = item?.type === "toolCall" ? item : void 0;
+				const blockIdx = contentBlockIndex++;
+				tcByContentIdx.set(idx, blockIdx);
+				sseEvent(writer, "content_block_start", {
+					type: "content_block_start",
+					index: blockIdx,
+					content_block: {
+						type: "tool_use",
+						id: tc?.id ?? `toolu_${blockIdx}`,
+						name: tc?.name ?? ""
+					}
+				});
+				return;
+			}
+			if (inner.type === "toolcall_delta") {
+				const blockIdx = tcByContentIdx.get(inner.contentIndex);
+				if (blockIdx === void 0) return;
+				sseEvent(writer, "content_block_delta", {
+					type: "content_block_delta",
+					index: blockIdx,
+					delta: {
+						type: "input_json_delta",
+						partial_json: inner.delta ?? ""
+					}
+				});
+			}
+		});
+		let stopReason = "end_turn";
+		const outputTokens = 0;
+		try {
+			await runConversation({
+				session,
+				prompt,
+				images,
+				log,
+				postPrompt
+			});
+			if (capturedModelError !== null) emitProviderError(toModelProviderError(new Error(capturedModelError)));
+		} catch (err) {
+			log.error({
+				err,
+				event: "anthropic_stream_error"
+			}, "stream error");
+			stopReason = "end_turn";
+			if (isModelProviderError(err)) emitProviderError(toModelProviderError(err));
+		} finally {
+			registry.delete(sessionId);
+		}
+		closeTextBlock();
+		for (const blockIdx of tcByContentIdx.values()) sseEvent(writer, "content_block_stop", {
+			type: "content_block_stop",
+			index: blockIdx
+		});
+		if (tcByContentIdx.size > 0) stopReason = "tool_use";
+		sseEvent(writer, "message_delta", {
+			type: "message_delta",
+			delta: {
+				stop_reason: stopReason,
+				stop_sequence: null
+			},
+			usage: { output_tokens: outputTokens }
+		});
+		sseEvent(writer, "message_stop", { type: "message_stop" });
+	});
+}
+async function runBlocking$2({ session, sm, prompt, images, id, sessionId, modelName, log, postPrompt, registry }) {
+	let text = "";
+	const toolUseBlocks = [];
+	const tcByContentIdx = /* @__PURE__ */ new Map();
+	session.subscribe((event) => {
+		if (event.type === "message_update") {
+			const inner = event.assistantMessageEvent;
+			if (inner?.type === "text_delta") {
+				text += inner.delta ?? "";
+				return;
+			}
+			if (inner?.type === "toolcall_start") {
+				const idx = inner.contentIndex;
+				const item = inner.partial?.content?.[idx];
+				tcByContentIdx.set(idx, toolUseBlocks.length);
+				toolUseBlocks.push({
+					type: "tool_use",
+					id: item?.id ?? `toolu_${toolUseBlocks.length}`,
+					name: item?.name ?? "",
+					input: {}
+				});
+				return;
+			}
+			if (inner?.type === "toolcall_delta") {
+				const i = tcByContentIdx.get(inner.contentIndex);
+				if (i !== void 0) {
+					const block = toolUseBlocks[i];
+					if (block && block.type === "tool_use") block.input = (typeof block.input === "string" ? block.input : "") + (inner.delta ?? "");
+				}
+			}
+		}
+	});
+	try {
+		await runConversation({
+			session,
+			prompt,
+			images,
+			log,
+			postPrompt
+		});
+	} catch (err) {
+		log.error({
+			err,
+			event: "anthropic_blocking_error"
+		}, "blocking error");
+		return jsonError(500, err?.message ?? String(err));
+	} finally {
+		registry.delete(sessionId);
+	}
+	for (const block of toolUseBlocks) if (block.type === "tool_use" && typeof block.input === "string") try {
+		block.input = JSON.parse(block.input);
+	} catch {
+		block.input = {};
+	}
+	const content = [];
+	if (text) content.push({
+		type: "text",
+		text
+	});
+	content.push(...toolUseBlocks);
+	return jsonResponse({
+		id,
+		type: "message",
+		role: "assistant",
+		content,
+		model: modelName,
+		stop_reason: toolUseBlocks.length > 0 ? "tool_use" : "end_turn",
+		stop_sequence: null,
+		usage: {
+			input_tokens: 0,
+			output_tokens: 0
+		}
+	});
+}
+function create$2(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const registry = options.sessionRegistry ?? createMapSessionRegistry();
+	const ctx = {
+		...options,
+		cwd
+	};
+	return async (request) => {
+		const { pathname } = new URL(request.url);
+		if (request.method !== "POST") return null;
+		const abortSessionId = pathname.match(/^\/v1\/messages\/([^/]+)\/abort$/)?.[1];
+		if (abortSessionId) try {
+			return await runInTraceContext(() => handleAbort({
+				request,
+				sessionId: abortSessionId,
+				registry
+			}));
+		} catch (err) {
+			const { log } = requestLogger(request);
+			log.error({
+				err,
+				event: "anthropic_messages_abort_unhandled_error"
+			}, "unhandled error");
+			return jsonError(500, "internal error");
+		}
+		if (pathname !== "/v1/messages") return null;
+		try {
+			return await runInTraceContext(() => handleMessages(request, ctx, registry));
+		} catch (err) {
+			const { log } = requestLogger(request);
+			log.error({
+				err,
+				event: "anthropic_messages_unhandled_error"
+			}, "unhandled error");
+			return jsonError(500, "internal error");
+		}
+	};
+}
+//#endregion
+//#region src/protocols/chat-completions.ts
+/**
+* OpenAI Chat Completions–compatible protocol handler.
+*
+* Catch-all: returns Response on match, null on no match.
+* Zero framework deps — just Web Standard Request/Response.
+*
+* Routes:
+*   POST /v1/chat/completions
+*   POST /v1/chat/completions/:id/steer
+*   POST /v1/chat/completions/:id/abort
+*
+* @see https://platform.openai.com/docs/api-reference/chat/create
+* @see PROTOCOL.md for custom extensions
+*/
+const ZERO_USAGE = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		total: 0
+	}
+};
+function extractUsageFromAgentEnd(event) {
+	const u = extractAgentEndUsage(event);
+	if (!u) return null;
+	return {
+		prompt_tokens: u.input,
+		completion_tokens: u.output,
+		total_tokens: u.totalTokens,
+		cache_read_tokens: u.cacheRead,
+		cache_creation_tokens: u.cacheWrite
+	};
+}
+function isDebug(request) {
+	const h = request.headers.get("x-debug");
+	return h === "1" || h === "true";
+}
+function parseRequestStartMs(request) {
+	const h = request.headers.get("x-request-start-ms");
+	if (h == null) return null;
+	const n = Number(h);
+	return Number.isFinite(n) && n > 0 ? n : null;
+}
+function withPassthroughHeaders({ model, request, prefixes }) {
+	if (prefixes.length === 0) return model;
+	const forwarded = {};
+	request.headers.forEach((value, key) => {
+		if (prefixes.some((p) => key.startsWith(p))) forwarded[key] = value;
+	});
+	if (Object.keys(forwarded).length === 0) return model;
+	const existing = "headers" in model && model.headers != null && typeof model.headers === "object" && !Array.isArray(model.headers) ? model.headers : {};
+	return {
+		...model,
+		headers: {
+			...existing,
+			...forwarded
+		}
+	};
+}
+async function extractContent(content, { userAgent, log }) {
+	if (typeof content === "string") return {
+		text: content,
+		images: []
+	};
+	if (!Array.isArray(content)) return {
+		text: "",
+		images: []
+	};
+	let text = "";
+	const images = [];
+	for (const part of content) {
+		if (typeof part === "string") {
+			text += part;
+			continue;
+		}
+		if (part?.type === "text") {
+			text += part.text ?? "";
+			continue;
+		}
+		if (part?.type === "image_url") {
+			const url = String(part.image_url?.url ?? "");
+			const dataUrl = url.match(/^data:([^;]+);base64,(.+)$/);
+			if (dataUrl) images.push({
+				type: "image",
+				mimeType: dataUrl[1],
+				data: dataUrl[2]
+			});
+			else if (/^https?:\/\//i.test(url)) try {
+				images.push(await fetchImageAsBase64({
+					url,
+					userAgent
+				}));
+			} catch (err) {
+				log.warn({
+					event: "image_fetch_failed",
+					url,
+					err
+				}, "image fetch failed");
+				text += `\n[image fetch failed: ${url}: ${err?.message ?? err}]\n`;
+			}
+		}
+	}
+	return {
+		text,
+		images
+	};
+}
+function extractAssistantText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.filter((p) => p?.type === "text").map((p) => p.text ?? "").join("");
+}
+function countMessageStats(messages) {
+	let chars = 0;
+	let images = 0;
+	for (const m of messages || []) {
+		const c = m?.content;
+		if (typeof c === "string") chars += c.length;
+		else if (Array.isArray(c)) {
+			for (const p of c) if (typeof p === "string") chars += p.length;
+			else if (p?.type === "text" && typeof p.text === "string") chars += p.text.length;
+			else if (p?.type === "image_url") images += 1;
+		}
+		if (Array.isArray(m?.tool_calls)) for (const tc of m.tool_calls) {
+			const args = tc?.function?.arguments;
+			if (typeof args === "string") chars += args.length;
+		}
+	}
+	return {
+		chars,
+		images
+	};
+}
+async function loadHistoryIntoSession({ sm, messages, upToIdxExclusive, modelName, userAgent, log }) {
+	const toolCallNames = /* @__PURE__ */ new Map();
+	for (let i = 0; i < upToIdxExclusive; i++) {
+		const m = messages[i];
+		if (!m) continue;
+		if (m.role === "user") {
+			const { text, images } = await extractContent(m.content, {
+				userAgent,
+				log
+			});
+			const content = images.length > 0 ? [...text ? [{
+				type: "text",
+				text
+			}] : [], ...images] : text;
+			if (typeof content === "string" && content.length > 0 || Array.isArray(content) && content.length > 0) sm.appendMessage({
+				role: "user",
+				content,
+				timestamp: Date.now()
+			});
+			continue;
+		}
+		if (m.role === "assistant") {
+			const text = extractAssistantText(m.content);
+			const contentArr = [];
+			if (Array.isArray(m.x_thinking)) for (const t of m.x_thinking) {
+				const tt = String(t?.text ?? "");
+				if (!tt) continue;
+				contentArr.push({
+					type: "thinking",
+					thinking: tt,
+					...t?.signature ? { thinkingSignature: t.signature } : {},
+					...t?.redacted ? { redacted: true } : {}
+				});
+			}
+			if (text) contentArr.push({
+				type: "text",
+				text
+			});
+			if (Array.isArray(m.tool_calls)) for (const tc of m.tool_calls) {
+				const name = tc?.function?.name;
+				if (!tc?.id || !name) continue;
+				let args = {};
+				try {
+					args = tc.function.arguments ? JSON.parse(tc.function.arguments) : {};
+				} catch {
+					args = { _raw: tc.function.arguments };
+				}
+				contentArr.push({
+					type: "toolCall",
+					id: tc.id,
+					name,
+					arguments: args
+				});
+				toolCallNames.set(tc.id, name);
+			}
+			if (contentArr.length === 0) continue;
+			sm.appendMessage({
+				role: "assistant",
+				content: contentArr,
+				api: "anthropic-messages",
+				provider: "anthropic",
+				model: modelName,
+				usage: ZERO_USAGE,
+				stopReason: contentArr.some((c) => c.type === "toolCall") ? "toolUse" : "stop",
+				timestamp: Date.now()
+			});
+			continue;
+		}
+		if (m.role === "tool") {
+			const text = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.filter((p) => p?.type === "text").map((p) => p.text ?? "").join("") : "";
+			const toolCallId = String(m.tool_call_id ?? "");
+			sm.appendMessage({
+				role: "toolResult",
+				toolCallId,
+				toolName: toolCallNames.get(toolCallId) ?? "",
+				content: [{
+					type: "text",
+					text
+				}],
+				isError: Boolean(m.x_is_error),
+				timestamp: Date.now()
+			});
+			continue;
+		}
+	}
+}
+function piMessagesToOpenAI(messages) {
+	const out = [];
+	for (const m of messages) {
+		if (m?.role === "assistant") {
+			let textContent = "";
+			const toolCalls = [];
+			const thinking = [];
+			const content = Array.isArray(m.content) ? m.content : [];
+			for (const c of content) if (c?.type === "text") textContent += c.text ?? "";
+			else if (c?.type === "thinking") thinking.push({
+				text: String(c.thinking ?? ""),
+				...c.thinkingSignature ? { signature: String(c.thinkingSignature) } : {},
+				...c.redacted ? { redacted: true } : {}
+			});
+			else if (c?.type === "toolCall") toolCalls.push({
+				id: String(c.id),
+				type: "function",
+				function: {
+					name: String(c.name ?? ""),
+					arguments: JSON.stringify(c.arguments ?? {})
+				}
+			});
+			const msg = {
+				role: "assistant",
+				content: textContent || null
+			};
+			if (toolCalls.length) msg.tool_calls = toolCalls;
+			if (thinking.length) msg.x_thinking = thinking;
+			out.push(msg);
+			continue;
+		}
+		if (m?.role === "toolResult") {
+			const text = Array.isArray(m.content) ? m.content.filter((p) => p?.type === "text").map((p) => p.text ?? "").join("") : "";
+			const tm = {
+				role: "tool",
+				tool_call_id: String(m.toolCallId ?? ""),
+				content: text
+			};
+			if (m.isError) tm.x_is_error = true;
+			out.push(tm);
+			continue;
+		}
+	}
+	return out;
+}
+async function handleChatCompletions(request, ctx, registry, pendingSteerIds) {
+	const reqStart = performance.now();
+	const upstreamStartMs = parseRequestStartMs(request);
+	const { log: baseLog, trace } = requestLogger(request);
+	const log = isDebug(request) ? baseLog.child({}, { level: "debug" }) : baseLog;
+	let parsed;
+	try {
+		parsed = JSON.parse(await request.text());
+	} catch {
+		return jsonError(400, "invalid json");
+	}
+	const { messages, stream = false, model: modelInput, thinkingLevel: thinkingInput, context_window: contextWindowInput, x_model: modelSpecInput } = parsed ?? {};
+	if (!Array.isArray(messages) || messages.length === 0) return jsonError(400, "messages array required");
+	let lastUserIdx = -1;
+	for (let i = messages.length - 1; i >= 0; i--) if (messages[i]?.role === "user") {
+		lastUserIdx = i;
+		break;
+	}
+	if (lastUserIdx < 0) return jsonError(400, "no user message in history");
+	const lastUser = messages[lastUserIdx];
+	const reqUA = request.headers.get("user-agent") ?? void 0;
+	const { text: prompt, images } = await extractContent(lastUser.content, {
+		userAgent: reqUA,
+		log
+	});
+	if (!prompt && images.length === 0) return jsonError(400, "user message has no content");
+	const { model: requestModel, modelSpec } = resolveRequestModel({
+		modelInput,
+		modelSpecInput,
+		defaultModel: ctx.defaultModel,
+		log
+	});
+	const resolvedModel = applyContextWindowOverride(requestModel, contextWindowInput);
+	const model = withPassthroughHeaders({
+		model: resolvedModel,
+		request,
+		prefixes: ctx.passthroughHeaderPrefixes ?? []
+	});
+	const thinkingLevel = resolveThinkingLevel(thinkingInput);
+	const modelName = model.id ?? "claude-opus-4-7";
+	const requestSystemPrompts = [];
+	for (const m of messages) if (m?.role === "system") {
+		const text = extractAssistantText(m.content);
+		if (text) requestSystemPrompts.push(text);
+	}
+	const baseSystemPrompt = requestSystemPrompts.filter((p) => p.length > 0).join("\n\n");
+	const parsedSession = parseSessionId(request);
+	if (parsedSession.invalid) return jsonError(400, "x-session-id must be a valid UUID");
+	const sessionId = parsedSession.source === "header" ? parsedSession.sessionId : `chatcmpl-${parsedSession.sessionId}`;
+	const shellEnv = parseShellEnv(request);
+	const sessionSetupStart = performance.now();
+	const [{ session, sessionManager: sm }, customTools] = await Promise.all([ctx.createSession({
+		cwd: ctx.cwd,
+		sessionId,
+		perRequestApiKeys: withSpecApiKey(resolvePerRequestApiKeys(request), modelSpec),
+		systemPromptOverride: () => baseSystemPrompt.length > 0 ? baseSystemPrompt : void 0,
+		shellEnv,
+		model,
+		thinkingLevel,
+		log,
+		onSessionSetup: (args) => ctx.onSessionSetup?.(args),
+		prepare: ({ sessionManager }) => loadHistoryIntoSession({
+			sm: sessionManager,
+			messages,
+			upToIdxExclusive: lastUserIdx,
+			modelName,
+			userAgent: reqUA,
+			log
+		})
+	}), ctx.getTools ? ctx.getTools(request) : void 0]);
+	const sessionSetupMs = Math.round(performance.now() - sessionSetupStart);
+	const created = Math.floor(Date.now() / 1e3);
+	registry.set(sessionId, session);
+	const stats = countMessageStats(messages);
+	log.info({
+		event: "req_received",
+		chatcmpl_id: sessionId,
+		turns: messages.length,
+		chars: stats.chars,
+		images: stats.images,
+		stream,
+		model: modelName,
+		x_model: modelSpec !== null,
+		context_window: resolvedModel.contextWindow,
+		setup_ms: Math.round(performance.now() - reqStart),
+		session_setup_ms: sessionSetupMs,
+		upstream_setup_ms: upstreamStartMs !== null ? Date.now() - upstreamStartMs : null
+	}, "chat req received");
+	if (stream) {
+		const response = runStream$1({
+			session,
+			sm,
+			prompt,
+			images,
+			sessionId,
+			created,
+			reqStart,
+			upstreamStartMs,
+			log,
+			trace,
+			postPrompt: ctx.postPrompt,
+			registry,
+			pendingSteerIds
+		});
+		const traceId = parseTraceId(trace.traceparent);
+		if (traceId) response.headers.set("x-trace-id", traceId);
+		return response;
+	}
+	const response = await runBlocking$1({
+		session,
+		sm,
+		prompt,
+		images,
+		sessionId,
+		created,
+		reqStart,
+		upstreamStartMs,
+		log,
+		postPrompt: ctx.postPrompt,
+		registry,
+		pendingSteerIds
+	});
+	const traceId = parseTraceId(trace.traceparent);
+	if (traceId) response.headers.set("x-trace-id", traceId);
+	return response;
+}
+function runStream$1({ session, sm, prompt, images, sessionId, created, reqStart, upstreamStartMs, log, trace, postPrompt, registry, pendingSteerIds }) {
+	return createSSEResponse(async (writer) => {
+		writer.write(": ready\n\n");
+		const baselineMessageCount = sm.buildSessionContext().messages.length;
+		let roleEmitted = false;
+		let firstChunkAt = null;
+		const tcByContentIdx = /* @__PURE__ */ new Map();
+		let nextTcIdx = 0;
+		let lastSteeringCount = 0;
+		let usage = null;
+		let lastFollowUpCount = 0;
+		let capturedModelError = null;
+		const sendChunk = (delta, finishReason) => {
+			if (firstChunkAt === null) {
+				firstChunkAt = performance.now();
+				log.info({
+					event: "ttft",
+					chatcmpl_id: sessionId,
+					ttft_ms: Math.round(firstChunkAt - reqStart),
+					upstream_ttft_ms: upstreamStartMs !== null ? Date.now() - upstreamStartMs : null
+				}, "time to first chunk");
+			}
+			const chunk = {
+				id: sessionId,
+				object: "chat.completion.chunk",
+				created,
+				choices: [{
+					index: 0,
+					delta,
+					finish_reason: finishReason ?? null
+				}]
+			};
+			writer.write(`data: ${JSON.stringify(chunk)}\n\n`);
+		};
+		const ensureRole = () => {
+			if (roleEmitted) return;
+			sendChunk({ role: "assistant" });
+			roleEmitted = true;
+		};
+		let _evCount = 0;
+		session.subscribe((event) => {
+			const ev = event;
+			const endedMessage = ev.message ?? (Array.isArray(ev.messages) ? ev.messages[ev.messages.length - 1] : null);
+			if (endedMessage?.stopReason === "error" && typeof endedMessage.errorMessage === "string" && endedMessage.errorMessage.length > 0) capturedModelError = endedMessage.errorMessage;
+			if (ev.type === "queue_update") {
+				const steering = Array.isArray(ev.steering) ? ev.steering.length : 0;
+				const followUp = Array.isArray(ev.followUp) ? ev.followUp.length : 0;
+				const queues = pendingSteerIds.get(sessionId);
+				const consumedIds = [];
+				const consumedSteer = lastSteeringCount - steering;
+				if (consumedSteer > 0 && queues && queues.steer.length > 0) consumedIds.push(...queues.steer.splice(0, consumedSteer));
+				const consumedFollowUp = lastFollowUpCount - followUp;
+				if (consumedFollowUp > 0 && queues && queues.followUp.length > 0) consumedIds.push(...queues.followUp.splice(0, consumedFollowUp));
+				lastSteeringCount = steering;
+				lastFollowUpCount = followUp;
+				sendChunk({ x_queue_update: {
+					steering,
+					follow_up: followUp,
+					...consumedIds.length > 0 ? { consumed_steer_ids: consumedIds } : {}
+				} });
+				return;
+			}
+			_evCount++;
+			const innerType = ev.type === "message_update" ? ev.assistantMessageEvent?.type ?? null : null;
+			const messageContentSummary = ev.type === "message_update" || ev.type === "message_end" ? Array.isArray(ev.message?.content) ? ev.message.content.map((c) => ({
+				type: c?.type,
+				...c?.type === "text" ? { textLen: (c.text ?? "").length } : {},
+				...c?.type === "thinking" ? { thinkingLen: (c.thinking ?? "").length } : {},
+				...c?.type === "toolCall" ? { name: c.name } : {}
+			})) : null : null;
+			log.info({
+				chatcmpl_id: sessionId,
+				evIdx: _evCount,
+				eventType: ev.type,
+				messageRole: ev.message?.role ?? null,
+				stopReason: ev.message?.stopReason ?? null,
+				innerType,
+				...innerType === "text_delta" || innerType === "thinking_delta" ? { delta: String(ev.assistantMessageEvent?.delta ?? "").slice(0, 200) } : {},
+				...messageContentSummary ? { messageContent: messageContentSummary } : {},
+				...ev.type === "message_start" || ev.type === "message_end" ? { messageJson: JSON.stringify(ev.message).slice(0, 500) } : {}
+			}, "harness session event");
+			if (ev.type === "tool_execution_start") {
+				sendChunk({ x_tool_execution_start: { tool_call_id: String(ev.toolCallId ?? "") } });
+				return;
+			}
+			if (ev.type === "tool_execution_end") {
+				const text = Array.isArray(ev.result?.content) ? ev.result.content.filter((p) => p?.type === "text").map((p) => p.text ?? "").join("") : typeof ev.result === "string" ? ev.result : "";
+				sendChunk({ x_tool_call_result: {
+					tool_call_id: String(ev.toolCallId ?? ""),
+					content: text,
+					...ev.isError ? { is_error: true } : {}
+				} });
+				return;
+			}
+			if (ev.type === "agent_end") {
+				usage = extractUsageFromAgentEnd(ev) ?? usage;
+				return;
+			}
+			if (ev.type !== "message_update") return;
+			const inner = ev.assistantMessageEvent;
+			const t = inner?.type;
+			if (t === "text_delta") {
+				ensureRole();
+				sendChunk({ content: inner.delta ?? "" });
+				return;
+			}
+			if (t === "thinking_delta") {
+				sendChunk({ x_thinking_delta: inner.delta ?? "" });
+				return;
+			}
+			if (t === "toolcall_start") {
+				const idx = inner.contentIndex;
+				const item = inner.partial?.content?.[idx];
+				const tc = item?.type === "toolCall" ? item : void 0;
+				const openaiIdx = nextTcIdx++;
+				tcByContentIdx.set(idx, openaiIdx);
+				ensureRole();
+				sendChunk({ tool_calls: [{
+					index: openaiIdx,
+					id: tc?.id ?? `call_${openaiIdx}`,
+					type: "function",
+					function: {
+						name: tc?.name ?? "",
+						arguments: ""
+					}
+				}] });
+				return;
+			}
+			if (t === "toolcall_delta") {
+				const openaiIdx = tcByContentIdx.get(inner.contentIndex);
+				if (openaiIdx === void 0) return;
+				sendChunk({ tool_calls: [{
+					index: openaiIdx,
+					function: { arguments: inner.delta ?? "" }
+				}] });
+			}
+		});
+		try {
+			await runConversation({
+				session,
+				prompt,
+				images,
+				log,
+				postPrompt
+			});
+			if (capturedModelError !== null) {
+				const providerError = toModelProviderError(new Error(capturedModelError));
+				log.warn({
+					event: "model_provider_error",
+					chatcmpl_id: sessionId,
+					code: providerError.code,
+					upstream_status: providerError.upstreamStatus,
+					provider: providerError.provider,
+					source: "stop_reason_error"
+				}, "forwarding model-provider error to client");
+				emitModelProviderError({
+					writer,
+					sessionId,
+					created,
+					providerError
+				});
+				writer.write("data: [DONE]\n\n");
+			} else {
+				emitSessionMessagesTrailer({
+					writer,
+					sm,
+					baselineMessageCount,
+					sessionId,
+					created,
+					usage
+				});
+				sendChunk({}, "stop");
+				writer.write("data: [DONE]\n\n");
+			}
+		} catch (err) {
+			log.error({
+				event: "chat_error",
+				chatcmpl_id: sessionId,
+				err
+			}, "chat error");
+			if (isModelProviderError(err)) {
+				const providerError = toModelProviderError(err);
+				log.warn({
+					event: "model_provider_error",
+					chatcmpl_id: sessionId,
+					code: providerError.code,
+					upstream_status: providerError.upstreamStatus,
+					provider: providerError.provider
+				}, "forwarding model-provider error to client");
+				emitModelProviderError({
+					writer,
+					sessionId,
+					created,
+					providerError
+				});
+			} else sendChunk({ content: `\n[error: ${err?.message ?? err}]` }, "stop");
+			writer.write("data: [DONE]\n\n");
+		} finally {
+			registry.delete(sessionId);
+			pendingSteerIds.delete(sessionId);
+		}
+		log.info({
+			event: "stream_done",
+			chatcmpl_id: sessionId,
+			duration_ms: Math.round(performance.now() - reqStart),
+			upstream_duration_ms: upstreamStartMs !== null ? Date.now() - upstreamStartMs : null
+		}, "stream done");
+	});
+}
+function emitSessionMessagesTrailer({ writer, sm, baselineMessageCount, sessionId, created, usage }) {
+	const sessionMessages = piMessagesToOpenAI(sm.buildSessionContext().messages.slice(baselineMessageCount));
+	if (sessionMessages.length === 0 && !usage) return;
+	const chunk = {
+		id: sessionId,
+		object: "chat.completion.chunk",
+		created,
+		choices: [{
+			index: 0,
+			delta: {},
+			finish_reason: null
+		}],
+		...sessionMessages.length ? { x_session_messages: sessionMessages } : {},
+		...usage ? { usage } : {}
+	};
+	writer.write(`data: ${JSON.stringify(chunk)}\n\n`);
+}
+/**
+* Emit a terminal chunk carrying a structured model-provider error under the
+* `x_model_provider_error` extension field, so the worker can react on the
+* forwarded provider error (e.g. compact + retry on `context_length_exceeded`)
+* rather than seeing an ambiguous empty stream. `finish_reason: 'stop'`
+* cleanly closes the stream for any OpenAI-shaped reader that ignores the
+* extension field.
+*/
+function emitModelProviderError({ writer, sessionId, created, providerError }) {
+	const chunk = {
+		id: sessionId,
+		object: "chat.completion.chunk",
+		created,
+		choices: [{
+			index: 0,
+			delta: {},
+			finish_reason: "stop"
+		}],
+		x_model_provider_error: {
+			code: providerError.code,
+			message: providerError.message,
+			provider: providerError.provider,
+			type: providerError.type,
+			upstream_status: providerError.upstreamStatus
+		}
+	};
+	writer.write(`data: ${JSON.stringify(chunk)}\n\n`);
+}
+async function runBlocking$1({ session, sm, prompt, images, sessionId, created, reqStart, upstreamStartMs, log, postPrompt, registry, pendingSteerIds }) {
+	const baselineMessageCount = sm.buildSessionContext().messages.length;
+	let content = "";
+	const toolCalls = [];
+	const tcByContentIdx = /* @__PURE__ */ new Map();
+	let usage = null;
+	session.subscribe((event) => {
+		if (event.type === "message_update") {
+			const inner = event.assistantMessageEvent;
+			const t = inner?.type;
+			if (t === "text_delta") {
+				content += inner.delta ?? "";
+				return;
+			}
+			if (t === "toolcall_start") {
+				const idx = inner.contentIndex;
+				const item = inner.partial?.content?.[idx];
+				tcByContentIdx.set(idx, toolCalls.length);
+				toolCalls.push({
+					id: item?.id ?? `call_${toolCalls.length}`,
+					type: "function",
+					function: {
+						name: item?.name ?? "",
+						arguments: ""
+					}
+				});
+				return;
+			}
+			if (t === "toolcall_delta") {
+				const i = tcByContentIdx.get(inner.contentIndex);
+				if (i !== void 0 && toolCalls[i]) toolCalls[i].function.arguments += inner.delta ?? "";
+			}
+			return;
+		}
+		if (event.type === "agent_end") usage = extractUsageFromAgentEnd(event) ?? usage;
+	});
+	try {
+		await runConversation({
+			session,
+			prompt,
+			images,
+			log,
+			postPrompt
+		});
+	} catch (err) {
+		log.error({
+			event: "chat_error",
+			chatcmpl_id: sessionId,
+			err
+		}, "chat error");
+		return jsonError(500, err?.message ?? String(err));
+	} finally {
+		registry.delete(sessionId);
+		pendingSteerIds.delete(sessionId);
+	}
+	const message = {
+		role: "assistant",
+		content: content || null
+	};
+	if (toolCalls.length) message.tool_calls = toolCalls;
+	const all = sm.buildSessionContext().messages;
+	const sessionMessages = piMessagesToOpenAI(all.slice(baselineMessageCount));
+	const response = {
+		id: sessionId,
+		object: "chat.completion",
+		created,
+		choices: [{
+			index: 0,
+			message,
+			finish_reason: "stop"
+		}],
+		...usage ? { usage } : {},
+		...sessionMessages.length ? { x_session_messages: sessionMessages } : {}
+	};
+	log.info({
+		event: "blocking_done",
+		chatcmpl_id: sessionId,
+		duration_ms: Math.round(performance.now() - reqStart),
+		upstream_duration_ms: upstreamStartMs !== null ? Date.now() - upstreamStartMs : null
+	}, "blocking done");
+	return new Response(JSON.stringify(response), {
+		status: 200,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+const steerContentPartSchema = z.union([z.object({
+	type: z.literal("text"),
+	text: z.string()
+}), z.object({
+	type: z.literal("image_url"),
+	image_url: z.object({ url: z.string() })
+})]);
+const steerRequestSchema = z.object({
+	content: z.union([z.string().min(1), z.array(steerContentPartSchema).min(1)]).optional(),
+	mode: z.enum(["steer", "follow-up"]).default("steer"),
+	text: z.string().optional()
+}).refine((v) => v.content !== void 0 || v.text !== void 0, { message: "content or text is required" });
+z.string().uuid();
+async function handleSteer(request, sessionId, registry, pendingSteerIds) {
+	const { log } = requestLogger(request);
+	const session = registry.get(sessionId);
+	if (!session) return jsonError(404, "session not found or already completed");
+	let body;
+	try {
+		body = JSON.parse(await request.text());
+	} catch {
+		return jsonError(400, "invalid json");
+	}
+	const parsed = steerRequestSchema.safeParse(body);
+	if (!parsed.success) return jsonError(400, parsed.error.message);
+	const { mode } = parsed.data;
+	const { text, images } = await extractContent(parsed.data.content ?? parsed.data.text ?? "", {
+		userAgent: request.headers.get("user-agent") ?? void 0,
+		log
+	});
+	if (!text && images.length === 0) return jsonError(400, "steer has no content");
+	const steerId = randomUUID();
+	let queues = pendingSteerIds.get(sessionId);
+	if (!queues) {
+		queues = {
+			steer: [],
+			followUp: []
+		};
+		pendingSteerIds.set(sessionId, queues);
+	}
+	if (mode === "follow-up") {
+		queues.followUp.push(steerId);
+		await session.followUp(text, images.length > 0 ? images : void 0);
+	} else {
+		queues.steer.push(steerId);
+		await session.steer(text, images.length > 0 ? images : void 0);
+	}
+	log.info({
+		event: "steer_accepted",
+		session_id: sessionId,
+		steer_id: steerId,
+		mode
+	}, "steering message queued");
+	return jsonResponse({
+		ok: true,
+		id: steerId
+	});
+}
+function create$1(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const registry = options.sessionRegistry ?? createMapSessionRegistry();
+	const pendingSteerIds = /* @__PURE__ */ new Map();
+	const ctx = {
+		...options,
+		cwd
+	};
+	return async (request) => {
+		const { pathname } = new URL(request.url);
+		if (request.method === "POST") {
+			const steerSessionId = pathname.match(/^\/v1\/chat\/completions\/([^/]+)\/steer$/)?.[1];
+			if (steerSessionId) try {
+				return await runInTraceContext(() => handleSteer(request, steerSessionId, registry, pendingSteerIds));
+			} catch (err) {
+				const { log } = requestLogger(request);
+				log.error({
+					err,
+					event: "steer_unhandled_error"
+				}, "unhandled error");
+				return jsonError(500, "internal error");
+			}
+			const abortSessionId = pathname.match(/^\/v1\/chat\/completions\/([^/]+)\/abort$/)?.[1];
+			if (abortSessionId) try {
+				return await runInTraceContext(() => handleAbort({
+					request,
+					sessionId: abortSessionId,
+					registry
+				}));
+			} catch (err) {
+				const { log } = requestLogger(request);
+				log.error({
+					err,
+					event: "abort_unhandled_error"
+				}, "unhandled error");
+				return jsonError(500, "internal error");
+			}
+			if (pathname === "/v1/chat/completions") try {
+				return await runInTraceContext(() => handleChatCompletions(request, ctx, registry, pendingSteerIds));
+			} catch (err) {
+				const { log } = requestLogger(request);
+				log.error({
+					err,
+					event: "chat_completions_unhandled_error"
+				}, "unhandled error");
+				return jsonError(500, "internal error");
+			}
+		}
+		return null;
+	};
+}
+//#endregion
+//#region src/protocols/responses.ts
+/**
+* OpenAI Responses API–compatible protocol handler.
+*
+* Catch-all: returns Response on match, null on no match.
+* Zero server-framework deps — just Web Standard Request/Response.
+*
+* Routes:
+*   POST /v1/responses
+*   POST /v1/responses/:id/abort
+*
+* @see https://platform.openai.com/docs/api-reference/responses
+*/
+async function extractInputContent(input, log) {
+	let systemPrompt = "";
+	const history = [];
+	let lastUserText = "";
+	const images = [];
+	if (typeof input === "string") return {
+		prompt: input,
+		images: [],
+		systemPrompt: "",
+		history: []
+	};
+	if (!Array.isArray(input)) return {
+		prompt: "",
+		images: [],
+		systemPrompt: "",
+		history: []
+	};
+	for (const item of input) {
+		if (item?.type === "message") {
+			if (item.role === "developer" || item.role === "system") {
+				const text = extractTextFromContent(item.content);
+				if (text) systemPrompt += (systemPrompt ? "\n\n" : "") + text;
+				continue;
+			}
+			if (item.role === "user") {
+				const text = extractTextFromContent(item.content);
+				const imgs = await extractImagesFromContent(item.content, log);
+				lastUserText = text;
+				images.push(...imgs);
+				history.push(item);
+				continue;
+			}
+			if (item.role === "assistant") {
+				history.push(item);
+				continue;
+			}
+		}
+		if (item?.type === "function_call_output") history.push(item);
+	}
+	return {
+		prompt: lastUserText,
+		images,
+		systemPrompt,
+		history
+	};
+}
+function extractTextFromContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.filter((p) => p?.type === "input_text" || p?.type === "text").map((p) => p.text ?? "").join("");
+}
+async function extractImagesFromContent(content, log) {
+	if (!Array.isArray(content)) return [];
+	const images = [];
+	for (const part of content) if (part?.type === "input_image") {
+		const url = part.image_url ?? part.url;
+		if (typeof url === "string" && /^https?:\/\//i.test(url)) try {
+			images.push(await fetchImageAsBase64({ url }));
+		} catch (err) {
+			log.warn({
+				event: "image_fetch_failed",
+				url,
+				err
+			}, "image fetch failed");
+		}
+		else if (part.data && part.media_type) images.push({
+			type: "image",
+			mimeType: part.media_type,
+			data: part.data
+		});
+	}
+	return images;
+}
+async function handleResponses(request, ctx, registry) {
+	const { log, trace } = requestLogger(request);
+	let parsed;
+	try {
+		parsed = JSON.parse(await request.text());
+	} catch {
+		return jsonError(400, "invalid json");
+	}
+	const { input, stream = false, model: modelInput, instructions, x_model: modelSpecInput } = parsed ?? {};
+	if (input == null) return jsonError(400, "input required");
+	const extracted = await extractInputContent(input, log);
+	const { prompt } = extracted;
+	const { images, systemPrompt: inputSystemPrompt } = extracted;
+	if (!prompt && images.length === 0) return jsonError(400, "no user content in input");
+	const systemPrompt = [typeof instructions === "string" ? instructions : "", inputSystemPrompt].filter(Boolean).join("\n\n");
+	const { model, modelSpec } = resolveRequestModel({
+		modelInput,
+		modelSpecInput,
+		defaultModel: ctx.defaultModel,
+		log
+	});
+	const modelName = model.id ?? "claude-opus-4-7";
+	const { sessionId } = parseSessionId(request);
+	const shellEnv = parseShellEnv(request);
+	const { session } = await ctx.createSession({
+		cwd: ctx.cwd,
+		sessionId,
+		perRequestApiKeys: withSpecApiKey(resolvePerRequestApiKeys(request), modelSpec),
+		systemPromptOverride: () => systemPrompt.length > 0 ? systemPrompt : void 0,
+		shellEnv,
+		model,
+		thinkingLevel: null,
+		log,
+		onSessionSetup: (args) => ctx.onSessionSetup?.(args),
+		prepare: null
+	});
+	registry.set(sessionId, session);
+	const responseId = `resp_${randomUUID().replace(/-/g, "").slice(0, 20)}`;
+	if (stream) {
+		const response = runStream({
+			session,
+			prompt,
+			images,
+			responseId,
+			sessionId,
+			modelName,
+			log,
+			postPrompt: ctx.postPrompt,
+			registry
+		});
+		const traceId = parseTraceId(trace.traceparent);
+		if (traceId) response.headers.set("x-trace-id", traceId);
+		return response;
+	}
+	const response = await runBlocking({
+		session,
+		prompt,
+		images,
+		responseId,
+		sessionId,
+		modelName,
+		log,
+		postPrompt: ctx.postPrompt,
+		registry
+	});
+	const traceId = parseTraceId(trace.traceparent);
+	if (traceId) response.headers.set("x-trace-id", traceId);
+	return response;
+}
+function runStream({ session, prompt, images, responseId, sessionId, modelName, log, postPrompt, registry }) {
+	return createSSEResponse(async (writer) => {
+		let seq = 0;
+		let textContent = "";
+		const outputItems = [];
+		const tcByContentIdx = /* @__PURE__ */ new Map();
+		let nextOutputIndex = 0;
+		let capturedModelError = null;
+		const send = (event) => {
+			writer.write(`data: ${JSON.stringify(event)}\n\n`);
+		};
+		const failWithProviderError = (providerError) => {
+			log.warn({
+				event: "model_provider_error",
+				code: providerError.code,
+				upstream_status: providerError.upstreamStatus,
+				provider: providerError.provider
+			}, "forwarding model-provider error to client");
+			send({
+				type: "response.failed",
+				sequence_number: seq++,
+				response: {
+					id: responseId,
+					status: "failed",
+					error: {
+						code: providerError.code,
+						message: providerError.message,
+						x_model_provider_error: {
+							provider: providerError.provider,
+							type: providerError.type,
+							upstream_status: providerError.upstreamStatus
+						}
+					}
+				}
+			});
+		};
+		send({
+			type: "response.created",
+			sequence_number: seq++,
+			response: {
+				id: responseId,
+				object: "response",
+				status: "in_progress",
+				output: [],
+				model: modelName,
+				created_at: Math.floor(Date.now() / 1e3)
+			}
+		});
+		let textItemEmitted = false;
+		const ensureTextItem = () => {
+			if (textItemEmitted) return;
+			textItemEmitted = true;
+			send({
+				type: "response.output_item.added",
+				sequence_number: seq++,
+				output_index: nextOutputIndex,
+				item: {
+					type: "message",
+					id: `item_${randomUUID().slice(0, 8)}`,
+					role: "assistant",
+					content: []
+				}
+			});
+		};
+		session.subscribe((event) => {
+			const ev = event;
+			const endedMessage = ev.message ?? (Array.isArray(ev.messages) ? ev.messages[ev.messages.length - 1] : null);
+			if (endedMessage?.stopReason === "error" && typeof endedMessage.errorMessage === "string" && endedMessage.errorMessage.length > 0) capturedModelError = endedMessage.errorMessage;
+			if (ev.type !== "message_update") return;
+			const inner = ev.assistantMessageEvent;
+			if (!inner) return;
+			if (inner.type === "text_delta") {
+				ensureTextItem();
+				textContent += inner.delta ?? "";
+				send({
+					type: "response.output_text.delta",
+					sequence_number: seq++,
+					output_index: textItemEmitted ? 0 : nextOutputIndex,
+					delta: inner.delta ?? ""
+				});
+				return;
+			}
+			if (inner.type === "toolcall_start") {
+				const idx = inner.contentIndex;
+				const item = inner.partial?.content?.[idx];
+				const tc = item?.type === "toolCall" ? item : void 0;
+				const itemId = `item_${randomUUID().slice(0, 8)}`;
+				const callId = tc?.id ?? `call_${nextOutputIndex}`;
+				const outputIndex = nextOutputIndex++;
+				tcByContentIdx.set(idx, {
+					itemId,
+					callId,
+					outputIndex
+				});
+				send({
+					type: "response.output_item.added",
+					sequence_number: seq++,
+					output_index: outputIndex,
+					item: {
+						type: "function_call",
+						id: itemId,
+						call_id: callId,
+						name: tc?.name ?? "",
+						arguments: "",
+						status: "in_progress"
+					}
+				});
+				return;
+			}
+			if (inner.type === "toolcall_delta") {
+				const info = tcByContentIdx.get(inner.contentIndex);
+				if (!info) return;
+				send({
+					type: "response.function_call_arguments.delta",
+					sequence_number: seq++,
+					output_index: info.outputIndex,
+					call_id: info.callId,
+					delta: inner.delta ?? ""
+				});
+			}
+		});
+		try {
+			await runConversation({
+				session,
+				prompt,
+				images,
+				log,
+				postPrompt
+			});
+			if (capturedModelError !== null) failWithProviderError(toModelProviderError(new Error(capturedModelError)));
+		} catch (err) {
+			log.error({
+				err,
+				event: "responses_stream_error"
+			}, "stream error");
+			if (isModelProviderError(err)) failWithProviderError(toModelProviderError(err));
+		} finally {
+			registry.delete(sessionId);
+		}
+		if (textContent) {
+			send({
+				type: "response.output_text.done",
+				sequence_number: seq++,
+				output_index: 0,
+				text: textContent
+			});
+			outputItems.push({
+				type: "message",
+				role: "assistant",
+				content: [{
+					type: "output_text",
+					text: textContent
+				}]
+			});
+		}
+		for (const [, info] of tcByContentIdx) send({
+			type: "response.output_item.done",
+			sequence_number: seq++,
+			output_index: info.outputIndex,
+			item: {
+				type: "function_call",
+				id: info.itemId,
+				call_id: info.callId,
+				status: "completed"
+			}
+		});
+		send({
+			type: "response.completed",
+			sequence_number: seq++,
+			response: {
+				id: responseId,
+				object: "response",
+				status: "completed",
+				output: outputItems,
+				model: modelName,
+				output_text: textContent,
+				created_at: Math.floor(Date.now() / 1e3),
+				usage: {
+					input_tokens: 0,
+					output_tokens: 0,
+					total_tokens: 0,
+					input_tokens_details: { cached_tokens: 0 },
+					output_tokens_details: { reasoning_tokens: 0 }
+				}
+			}
+		});
+		writer.write("data: [DONE]\n\n");
+	});
+}
+async function runBlocking({ session, prompt, images, responseId, sessionId, modelName, log, postPrompt, registry }) {
+	let textContent = "";
+	const functionCalls = [];
+	const tcByContentIdx = /* @__PURE__ */ new Map();
+	session.subscribe((event) => {
+		if (event.type === "message_update") {
+			const inner = event.assistantMessageEvent;
+			if (inner?.type === "text_delta") {
+				textContent += inner.delta ?? "";
+				return;
+			}
+			if (inner?.type === "toolcall_start") {
+				const idx = inner.contentIndex;
+				const item = inner.partial?.content?.[idx];
+				tcByContentIdx.set(idx, functionCalls.length);
+				functionCalls.push({
+					type: "function_call",
+					id: `item_${randomUUID().slice(0, 8)}`,
+					call_id: item?.id ?? `call_${functionCalls.length}`,
+					name: item?.name ?? "",
+					arguments: "",
+					status: "completed"
+				});
+				return;
+			}
+			if (inner?.type === "toolcall_delta") {
+				const i = tcByContentIdx.get(inner.contentIndex);
+				if (i !== void 0 && functionCalls[i]) functionCalls[i].arguments += inner.delta ?? "";
+			}
+		}
+	});
+	try {
+		await runConversation({
+			session,
+			prompt,
+			images,
+			log,
+			postPrompt
+		});
+	} catch (err) {
+		log.error({
+			err,
+			event: "responses_blocking_error"
+		}, "blocking error");
+		return jsonError(500, err?.message ?? String(err));
+	} finally {
+		registry.delete(sessionId);
+	}
+	const output = [];
+	if (textContent) output.push({
+		type: "message",
+		role: "assistant",
+		content: [{
+			type: "output_text",
+			text: textContent
+		}]
+	});
+	output.push(...functionCalls);
+	return jsonResponse({
+		id: responseId,
+		object: "response",
+		status: "completed",
+		output,
+		model: modelName,
+		output_text: textContent,
+		created_at: Math.floor(Date.now() / 1e3),
+		usage: {
+			input_tokens: 0,
+			output_tokens: 0,
+			total_tokens: 0,
+			input_tokens_details: { cached_tokens: 0 },
+			output_tokens_details: { reasoning_tokens: 0 }
+		}
+	});
+}
+function create(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const registry = options.sessionRegistry ?? createMapSessionRegistry();
+	const ctx = {
+		...options,
+		cwd
+	};
+	return async (request) => {
+		const { pathname } = new URL(request.url);
+		if (request.method !== "POST") return null;
+		const abortSessionId = pathname.match(/^\/v1\/responses\/([^/]+)\/abort$/)?.[1];
+		if (abortSessionId) try {
+			return await runInTraceContext(() => handleAbort({
+				request,
+				sessionId: abortSessionId,
+				registry
+			}));
+		} catch (err) {
+			const { log } = requestLogger(request);
+			log.error({
+				err,
+				event: "responses_abort_unhandled_error"
+			}, "unhandled error");
+			return jsonError(500, "internal error");
+		}
+		if (pathname !== "/v1/responses") return null;
+		try {
+			return await runInTraceContext(() => handleResponses(request, ctx, registry));
+		} catch (err) {
+			const { log } = requestLogger(request);
+			log.error({
+				err,
+				event: "responses_unhandled_error"
+			}, "unhandled error");
+			return jsonError(500, "internal error");
+		}
+	};
+}
+//#endregion
+//#region src/protocols/index.ts
+/**
+* Build the individual protocol handlers, each returning null for
+* requests it doesn't recognize. An in-memory session registry backs
+* chat-completions steering unless deliberately overridden.
+*/
+function createProtocolHandlers(options) {
+	const shared = {
+		cwd: options.cwd,
+		createSession: options.createSession,
+		onSessionSetup: options.onSessionSetup,
+		postPrompt: options.postPrompt,
+		passthroughHeaderPrefixes: options.passthroughHeaderPrefixes
+	};
+	const chatCompletions = create$1({
+		...shared,
+		sessionRegistry: createMapSessionRegistry(),
+		...options.chatCompletions
+	});
+	return {
+		prewarm: createPrewarm({
+			paths: options.prewarmPaths ?? [],
+			chatCompletions
+		}),
+		chatCompletions,
+		messages: create$2({
+			...shared,
+			...options.messages
+		}),
+		responses: create({
+			...shared,
+			...options.responses
+		})
+	};
+}
+/** Chain handlers; null when none matched. */
+function composeHandlers(handlers) {
+	return async (request) => {
+		for (const handler of handlers) {
+			const response = await handler(request);
+			if (response) return response;
+		}
+		return null;
+	};
+}
+function createProtocols(options) {
+	const handlers = createProtocolHandlers(options);
+	const enabled = (name) => (!options.only || options.only.includes(name)) && (!options.exclude || !options.exclude.includes(name));
+	const composed = composeHandlers([
+		...enabled("chat-completions") ? [handlers.prewarm, handlers.chatCompletions] : [],
+		...enabled("messages") ? [handlers.messages] : [],
+		...enabled("responses") ? [handlers.responses] : []
+	]);
+	return async (request) => {
+		const response = await composed(request);
+		if (response) return response;
+		return new Response(JSON.stringify({ error: { message: "not found" } }), {
+			status: 404,
+			headers: { "Content-Type": "application/json" }
+		});
+	};
+}
+//#endregion
+//#region src/express.ts
+function requestUrl(req) {
+	return `${req.headers["x-forwarded-proto"] ?? "http"}://${req.headers["x-forwarded-host"] ?? req.headers.host ?? "localhost"}${req.originalUrl ?? req.url ?? "/"}`;
+}
+function requestHeaders(req) {
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(req.headers)) {
+		if (value == null) continue;
+		if (Array.isArray(value)) for (const v of value) headers.append(key, v);
+		else headers.set(key, value);
+	}
+	return headers;
+}
+async function toWebRequest(req) {
+	const init = {
+		method: req.method,
+		headers: requestHeaders(req)
+	};
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		const { Readable } = await import("node:stream");
+		init.body = Readable.toWeb(req);
+		init.duplex = "half";
+	}
+	return new Request(requestUrl(req), init);
+}
+async function sendWebResponse(res, webResponse) {
+	const headers = {};
+	webResponse.headers.forEach((v, k) => {
+		headers[k] = v;
+	});
+	res.writeHead(webResponse.status, headers);
+	if (webResponse.body) {
+		const { Readable } = await import("node:stream");
+		Readable.fromWeb(webResponse.body).pipe(res);
+	} else res.end();
+}
+/**
+* Mountable middleware for a web-standard handler. A null result calls
+* next() so unmatched requests fall through to whatever the caller
+* mounts after it.
+*/
+function webHandlerToMiddleware(handler) {
+	return async (req, res, next) => {
+		try {
+			const webResponse = await handler(await toWebRequest(req));
+			if (!webResponse) {
+				next();
+				return;
+			}
+			await sendWebResponse(res, webResponse);
+		} catch (err) {
+			logger.error({
+				err,
+				event: "server_error"
+			}, "unhandled server error");
+			if (!res.headersSent) {
+				res.writeHead(500, { "content-type": "application/json" });
+				res.end(JSON.stringify({ error: { message: "internal error" } }));
+			}
+		}
+	};
+}
+/**
+* Path-scope a middleware the way express mounting does: skip (next())
+* unless the request path matches the prefix, and present a
+* mount-relative req.url to the inner middleware. Lets express-style
+* handlers that expect `app.use('/a2a', h)` participate in a composed
+* catch-all.
+*/
+function mountAt(prefix, middleware) {
+	return (req, res, next) => {
+		const originalUrl = req.url ?? "/";
+		const path = originalUrl.split("?")[0] ?? "";
+		if (path !== prefix && !path.startsWith(`${prefix}/`)) {
+			next();
+			return;
+		}
+		const rest = originalUrl.slice(prefix.length);
+		req.url = rest.startsWith("/") ? rest : `/${rest}`;
+		middleware(req, res, (err) => {
+			req.url = originalUrl;
+			next(err);
+		});
+	};
+}
+/** Run middlewares in order; each next() advances to the following one. */
+function chainMiddleware(middlewares) {
+	return (req, res, next) => {
+		let i = 0;
+		const run = (err) => {
+			if (err) {
+				next(err);
+				return;
+			}
+			const middleware = middlewares[i++];
+			if (!middleware) {
+				next();
+				return;
+			}
+			middleware(req, res, run);
+		};
+		run();
+	};
+}
+//#endregion
+export { DEFAULT_MODEL, DEFAULT_PROVIDER, DEFAULT_THINKING_LEVEL, KNOWN_PI_PROVIDERS, PI_AGENT_DIR, VALID_THINKING_LEVELS, buildAgentCard, buildModelFromSpec, chainMiddleware, composeHandlers, createAgentExecutor, createMapSessionRegistry, createPrewarm, createProtocolHandlers, createProtocols, deriveTraceContext, getCurrentTraceparent, logger, modelSpecSchema, mountAt, newTraceContext, parseModelSpec, parseTraceId, requestHeaders, requestLogger, requestUrl, resolveRequestModel, runInTraceContext, setCurrentTraceparent, webHandlerToMiddleware, withSpecApiKey };