@bothat-io/molenkopf 0.1.2

package/packages/proxy/src/http/usage-accounting.ts

@@ -0,0 +1,100 @@
+import type { AuditManifest } from "../../../core/src/manifest/audit-store.ts";
+import { costEur } from "../../../core/src/identity/pricing.ts";
+import { budgetPeriodKey } from "../../../core/src/identity/budget.ts";
+import type { BudgetPeriod } from "../../../core/src/identity/types.ts";
+import { clientIdForAgent } from "./client-identity.ts";
+import type { RuntimeState, UsagePeriodTotals, UsageTotals } from "./runtime-state.ts";
+
+export function recordUsage(state: RuntimeState, manifest: AuditManifest): void {
+  const cost = costEur(state.identity?.data.pricing?.[manifest.providerId ?? ""], manifest.upstreamInputTokens ?? 0, manifest.upstreamOutputTokens ?? 0);
+  const at = new Date(manifest.timestamp);
+  if (manifest.providerId) accumulate(state.usageByProvider, manifest.providerId, manifest, cost, at);
+  const client = manifest.client;
+  if (client) {
+    if (client.userId) accumulate(state.usageByUser, userUsageKey(client.userId), manifest, cost, at);
+    else if (client.source === "user") accumulate(state.usageByUser, client.id, manifest, cost, at);
+    for (const id of agentUsageKeys(client)) accumulate(state.usageByAgent, id, manifest, cost, at);
+    if (client.keyId) accumulate(state.usageByKey, client.keyId, manifest, cost, at);
+    for (const teamId of client.teamIds ?? []) accumulate(state.usageByTeam, teamId, manifest, cost, at);
+  }
+  state.usageSnapshot?.schedule(state);
+}
+
+export function userUsageKey(userId: string): string {
+  return `user:${userId}`;
+}
+
+export function keyTokensUsed(state: RuntimeState, keyId: string, period: BudgetPeriod = "total", now = new Date()): number {
+  return tokensOf(usageForPeriod(state.usageByKey[keyId], period, now));
+}
+
+export function keyCostUsed(state: RuntimeState, keyId: string, period: BudgetPeriod = "total", now = new Date()): number {
+  return costOf(usageForPeriod(state.usageByKey[keyId], period, now));
+}
+
+export function userTokensUsed(state: RuntimeState, userId: string, period: BudgetPeriod = "total", now = new Date()): number {
+  return tokensOf(usageForPeriod(state.usageByUser[userUsageKey(userId)], period, now));
+}
+
+export function userCostUsed(state: RuntimeState, userId: string, period: BudgetPeriod = "total", now = new Date()): number {
+  return costOf(usageForPeriod(state.usageByUser[userUsageKey(userId)], period, now));
+}
+
+export function teamTokensUsed(state: RuntimeState, teamId: string, period: BudgetPeriod = "total", now = new Date()): number {
+  return tokensOf(usageForPeriod(state.usageByTeam[teamId], period, now));
+}
+
+export function teamCostUsed(state: RuntimeState, teamId: string, period: BudgetPeriod = "total", now = new Date()): number {
+  return costOf(usageForPeriod(state.usageByTeam[teamId], period, now));
+}
+
+export function orgTokensUsed(state: RuntimeState, period: BudgetPeriod = "total", now = new Date()): number {
+  return Object.values(state.usageByUser).reduce((sum, usage) => sum + tokensOf(usageForPeriod(usage, period, now)), 0);
+}
+
+export function orgCostUsed(state: RuntimeState, period: BudgetPeriod = "total", now = new Date()): number {
+  return Object.values(state.usageByUser).reduce((sum, usage) => sum + costOf(usageForPeriod(usage, period, now)), 0);
+}
+
+export function agentTokensUsed(state: RuntimeState, clientId: string): number {
+  return tokensOf(state.usageByAgent[clientId] ?? state.usageByUser[clientId]);
+}
+
+function agentUsageKeys(client: NonNullable<AuditManifest["client"]>): string[] {
+  const ids = new Set<string>();
+  if (client.source === "agent") ids.add(client.id);
+  if (client.agentId) ids.add(clientIdForAgent(client.agentId));
+  return [...ids];
+}
+
+export function usageForPeriod(usage: UsageTotals | undefined, period: BudgetPeriod = "total", now = new Date()): UsagePeriodTotals {
+  if (!usage) return { requests: 0, inputTokens: 0, outputTokens: 0, costEur: 0 };
+  return period === "total" ? usage : usage.periods?.[budgetPeriodKey(period, now)] ?? { requests: 0, inputTokens: 0, outputTokens: 0, costEur: 0 };
+}
+
+function accumulate(map: Record<string, UsageTotals>, key: string, manifest: AuditManifest, cost: number, at: Date): void {
+  const usage = map[key] ?? { requests: 0, inputTokens: 0, outputTokens: 0, costEur: 0 };
+  addUsage(usage, manifest, cost);
+  usage.periods ??= {};
+  for (const period of ["day", "week", "month"] as const) {
+    const key = budgetPeriodKey(period, at);
+    usage.periods[key] = addUsage(usage.periods[key] ?? { requests: 0, inputTokens: 0, outputTokens: 0, costEur: 0 }, manifest, cost);
+  }
+  map[key] = usage;
+}
+
+function addUsage(usage: UsagePeriodTotals, manifest: AuditManifest, cost: number): UsagePeriodTotals {
+  usage.requests++;
+  usage.inputTokens += manifest.upstreamInputTokens ?? 0;
+  usage.outputTokens += manifest.upstreamOutputTokens ?? 0;
+  usage.costEur = (usage.costEur ?? 0) + cost;
+  return usage;
+}
+
+function tokensOf(usage: UsageTotals | undefined): number {
+  return usage ? usage.inputTokens + usage.outputTokens : 0;
+}
+
+function costOf(usage: UsageTotals | undefined): number {
+  return usage?.costEur ?? 0;
+}

package/packages/proxy/src/http/usage-restore.ts

@@ -0,0 +1,15 @@
+import type { AuditStore } from "../../../core/src/manifest/audit-store.ts";
+import type { UsageSnapshotStore } from "../../../core/src/identity/usage-snapshot.ts";
+import { recordUsage, type RuntimeState } from "./runtime-state.ts";
+
+const USAGE_FIELDS = ["usageByAgent", "usageByUser", "usageByProvider", "usageByKey", "usageByTeam"] as const;
+
+export async function restoreUsage(state: RuntimeState, snapshots: UsageSnapshotStore, audit: AuditStore): Promise<void> {
+  const snapshot = await snapshots.load();
+  if (snapshot) {
+    for (const field of USAGE_FIELDS) if (snapshot[field]) state[field] = snapshot[field] as RuntimeState[typeof field];
+    return;
+  }
+  for (const manifest of await audit.list()) recordUsage(state, manifest);
+  await snapshots.save(state).catch(() => {});
+}

package/packages/proxy/src/runtime/cli-diagnostics.ts

@@ -0,0 +1,64 @@
+import { redactSecrets } from "../../../core/src/security/secret-redactor.ts";
+
+export type CliLifecycleState = "unknown" | "spawned" | "stdin_sent" | "first_output" | "timeout" | "killed" | "closed" | "malformed";
+export type CliErrorClass = "auth_failure" | "permission_prompt" | "timeout" | "empty_output" | "exit_error" | "spawn_error" | "unknown";
+
+export type CliErrorDiagnostics = {
+  class: CliErrorClass;
+  lifecycle: { state: CliLifecycleState; events: string[] };
+  permissionBlocked: boolean;
+};
+
+export function cliErrorDiagnostics(error: unknown): CliErrorDiagnostics {
+  const message = safeMessage(error);
+  const events = lifecycleEvents(message);
+  const classification = classifyCliMessage(message);
+  return {
+    class: classification,
+    lifecycle: { state: lifecycleState(events, classification), events },
+    permissionBlocked: classification === "permission_prompt"
+  };
+}
+
+export function safeCliMessage(error: unknown): string {
+  const message = safeMessage(error);
+  const classification = classifyCliMessage(message);
+  if (classification === "auth_failure") return "Local CLI authentication failed. Re-import a current auth.json or run the runtime login command, then test again.";
+  if (classification === "permission_prompt") return "Local CLI reported a permission prompt.";
+  return message;
+}
+
+export function successfulCliLifecycle(): CliErrorDiagnostics["lifecycle"] {
+  return { state: "closed", events: ["spawned", "stdin_sent", "first_output", "closed"] };
+}
+
+function classifyCliMessage(message: string): CliErrorClass {
+  if (/output_class:auth_failure|not logged in|please run \/login|authentication|credentials/i.test(message)) return "auth_failure";
+  if (/output_class:permission_prompt|requested permissions|haven't granted|permission[^.]{0,80}(denied|blocked|required)|requires permission|not allowed/i.test(message)) return "permission_prompt";
+  if (/timed out after/i.test(message)) return "timeout";
+  if (/returned empty output|malformed/i.test(message)) return "empty_output";
+  if (/failed:/i.test(message)) return "spawn_error";
+  if (/exited with/i.test(message)) return "exit_error";
+  return "unknown";
+}
+
+function lifecycleEvents(message: string): string[] {
+  const match = message.match(/lifecycle:\s*([^;]+)/i);
+  if (!match) return [];
+  return match[1].split("->").map((item) => item.trim().replace(/^\d+ms\s+/, "").slice(0, 120)).filter(Boolean);
+}
+
+function lifecycleState(events: string[], classification: CliErrorClass): CliLifecycleState {
+  if (classification === "empty_output") return "malformed";
+  if (events.some((event) => event.startsWith("timeout"))) return "timeout";
+  if (events.some((event) => event.startsWith("kill"))) return "killed";
+  if (events.some((event) => event.startsWith("close"))) return "closed";
+  if (events.some((event) => event.includes("first byte"))) return "first_output";
+  if (events.some((event) => event === "stdin sent")) return "stdin_sent";
+  if (events.some((event) => event.startsWith("spawn"))) return "spawned";
+  return "unknown";
+}
+
+function safeMessage(error: unknown): string {
+  return redactSecrets(String(error instanceof Error ? error.message : error)).text.slice(0, 720);
+}

package/packages/proxy/src/runtime/cli-env.ts

@@ -0,0 +1,22 @@
+import type { ProviderConfig } from "../../../core/src/providers/provider-catalog.ts";
+
+const PRESERVED_ENV = new Set([
+  "APPDATA", "COMSPEC", "HOME", "HOMEDRIVE", "HOMEPATH", "LANG", "LC_ALL", "LC_CTYPE",
+  "LOCALAPPDATA", "LOGNAME", "NUMBER_OF_PROCESSORS", "OS", "PATH", "PATHEXT", "PROGRAMDATA",
+  "PROGRAMFILES", "PROGRAMFILES(X86)", "PROGRAMW6432", "PROCESSOR_ARCHITECTURE", "SHELL",
+  "SYSTEMDRIVE", "SYSTEMROOT", "TEMP", "TERM", "TMP", "TMPDIR", "USER", "USERDOMAIN",
+  "USERNAME", "USERPROFILE", "WINDIR", "XDG_CACHE_HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME"
+]);
+
+export function cliEnv(provider: ProviderConfig, source: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (value !== undefined && PRESERVED_ENV.has(key.toUpperCase())) env[key] = value;
+  }
+  if (provider.runtimeAuthDir && provider.runtime === "codex") env.CODEX_HOME = provider.runtimeAuthDir;
+  if (provider.runtimeAuthDir && provider.runtime === "claude") {
+    env.CLAUDE_CONFIG_DIR = provider.runtimeAuthDir;
+    env.CLAUDE_HOME = provider.runtimeAuthDir;
+  }
+  return env;
+}

package/packages/proxy/src/runtime/cli-executor.ts

@@ -0,0 +1,134 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { ProviderConfig } from "../../../core/src/providers/provider-catalog.ts";
+import { cliArgs } from "./cli-request.ts";
+import { cliEnv } from "./cli-env.ts";
+
+export function executeCliProvider(provider: ProviderConfig, prompt: string, runModel?: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const baseArgs = cliArgs(provider, runModel);
+    const args = provider.cliInputMode === "argument" ? [...baseArgs, prompt] : baseArgs;
+    const spec = cliSpawnSpec(provider.cliCommand ?? "claude", args);
+    const timeoutMs = provider.cliTimeoutMs ?? 120000;
+    const lifecycle = newLifecycle(provider);
+    const child = spawn(spec.command, spec.args, { stdio: ["pipe", "pipe", "pipe"], windowsHide: true, env: cliEnv(provider) });
+    const stdout: Buffer[] = [], stderr: Buffer[] = [];
+    const limits = outputLimits();
+    let settled = false, killTimer: NodeJS.Timeout | undefined, stdoutSeen = false, stderrSeen = false;
+    const timer = setTimeout(() => {
+      lifecycle.add(`timeout ${timeoutMs}ms`);
+      lifecycle.add(`kill SIGTERM ${child.kill("SIGTERM") ? "sent" : "failed"}`);
+      killTimer = setTimeout(() => lifecycle.add(`kill SIGKILL ${child.kill("SIGKILL") ? "sent" : "failed"}`), 250);
+      killTimer.unref?.();
+      fail(new Error(`local cli provider timed out after ${timeoutMs}ms${detail(lifecycle.items, stdout, stderr)}`), false);
+    }, timeoutMs);
+
+    child.stdout.on("data", (chunk) => {
+      if (!stdoutSeen) { stdoutSeen = true; lifecycle.add("stdout first byte"); }
+      if (!capture(stdout, Buffer.from(chunk), limits.streamBytes)) overflow("stdout");
+    });
+    child.stderr.on("data", (chunk) => {
+      if (!stderrSeen) { stderrSeen = true; lifecycle.add("stderr first byte"); }
+      if (!capture(stderr, Buffer.from(chunk), limits.streamBytes)) overflow("stderr");
+    });
+    child.on("error", (error) => fail(new Error(`local cli provider failed: ${error.message}${detail(lifecycle.items, stdout, stderr)}`), true));
+    child.on("close", (code, signal) => {
+      lifecycle.add(`close code=${code ?? "unknown"} signal=${signal ?? "none"}`);
+      if (settled) { if (killTimer) clearTimeout(killTimer); return; }
+      if (code !== 0) return fail(new Error(exitMessage(code, stdout, stderr, lifecycle.items)), true);
+      finish(true);
+      const output = Buffer.concat(stdout).toString("utf8").trim();
+      if (!output) return reject(new Error(`local cli provider returned empty output${detail(lifecycle.items, stdout, stderr)}`));
+      resolve(output);
+    });
+
+    lifecycle.add("stdin sent");
+    if (provider.cliInputMode !== "argument") child.stdin.end(prompt);
+    else child.stdin.end();
+
+    function fail(error: Error, clearKill: boolean): void {
+      if (settled) return;
+      finish(clearKill);
+      reject(error);
+    }
+    function finish(clearKill: boolean): void {
+      settled = true;
+      clearTimeout(timer);
+      if (clearKill && killTimer) clearTimeout(killTimer);
+    }
+    function overflow(stream: "stdout" | "stderr"): void {
+      lifecycle.add(`${stream} overflow`);
+      child.kill("SIGTERM");
+      fail(new Error(`local cli provider output exceeded ${limits.streamBytes} bytes${detail(lifecycle.items, stdout, stderr)}`), true);
+    }
+  });
+}
+
+function newLifecycle(provider: ProviderConfig) {
+  const started = Date.now();
+  const items = [`0ms spawn runtime=${provider.runtime ?? "cli"}`];
+  return { items, add: (event: string) => items.push(`${Date.now() - started}ms ${event}`) };
+}
+
+function exitMessage(code: number | null, stdout: Buffer[], stderr: Buffer[], events: string[]): string {
+  return `local cli provider exited with ${code ?? "unknown"}${detail(events, stdout, stderr)}`;
+}
+
+function detail(events: string[], stdout: Buffer[], stderr: Buffer[]): string {
+  const outputClass = cliOutputClass(stdout, stderr);
+  return `; lifecycle: ${events.join(" -> ")}${outputClass ? `; output_class:${outputClass}` : ""}`;
+}
+
+function cliOutputClass(stdout: Buffer[], stderr: Buffer[]): string {
+  if (stdout.some((item) => item.length === 0) || stderr.some((item) => item.length === 0)) return "overflow";
+  const raw = [Buffer.concat(stdout).toString("utf8"), Buffer.concat(stderr).toString("utf8")].join("\n");
+  if (/requested permissions|haven't granted|permission[^.]{0,80}(denied|blocked|required)|requires permission|not allowed/i.test(raw)) return "permission_prompt";
+  if (/not logged in|please run \/login|auth|authentication|credentials/i.test(raw)) return "auth_failure";
+  return raw.trim() ? "present" : "";
+}
+
+function capture(chunks: Buffer[], chunk: Buffer, limit: number): boolean {
+  const used = chunks.reduce((sum, item) => sum + item.length, 0);
+  const remaining = limit - used;
+  if (remaining <= 0) return false;
+  if (chunk.length <= remaining) {
+    chunks.push(chunk);
+    return true;
+  }
+  chunks.push(chunk.subarray(0, remaining), Buffer.alloc(0));
+  return false;
+}
+
+function outputLimits(): { streamBytes: number } {
+  const configured = Number(process.env.MOLENKOPF_CLI_OUTPUT_LIMIT_BYTES);
+  return { streamBytes: Number.isInteger(configured) && configured > 0 ? configured : 1024 * 1024 };
+}
+
+function cliSpawnSpec(command: string, args: string[]): { command: string; args: string[] } {
+  const resolved = resolveCliCommand(command);
+  if (process.platform === "win32" && /\.(?:cmd|bat)$/i.test(resolved)) return { command: process.env.ComSpec ?? "cmd.exe", args: ["/d", "/s", "/c", resolved, ...args] };
+  if (process.platform === "win32" && /\.ps1$/i.test(resolved)) return { command: "powershell.exe", args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", resolved, ...args] };
+  return { command: resolved, args };
+}
+
+function resolveCliCommand(command: string, env: Record<string, string | undefined> = process.env, platform = process.platform): string {
+  if (platform !== "win32" || hasExtension(command)) return command;
+  for (const candidate of windowsCandidates(command, env)) if (existsSync(candidate)) return candidate;
+  return command;
+}
+
+function windowsCandidates(command: string, env: Record<string, string | undefined>): string[] {
+  const exts = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+  if (isPathLike(command)) return exts.map((ext) => `${command}${ext.toLowerCase()}`);
+  const pathValue = env.PATH ?? env.Path ?? env.path ?? "";
+  return pathValue.split(";").filter(Boolean).flatMap((dir) => exts.map((ext) => join(dir, `${command}${ext.toLowerCase()}`)));
+}
+
+function isPathLike(command: string): boolean {
+  return command.includes("/") || command.includes("\\");
+}
+
+function hasExtension(command: string): boolean {
+  return /\.[^\\/]+$/.test(command);
+}

package/packages/proxy/src/runtime/cli-provider.ts

@@ -0,0 +1,162 @@
+import type { ProviderConfig } from "../../../core/src/providers/provider-catalog.ts";
+import { estimateTokens } from "../../../core/src/utils/tokens.ts";
+import { executeCliProvider } from "./cli-executor.ts";
+import { cliRequest } from "./cli-request.ts";
+
+export type CliProviderResult = {
+  status: number;
+  headers: Record<string, string>;
+  body: Buffer;
+  usage?: { inputTokens?: number; outputTokens?: number };
+};
+
+export function isCliProvider(provider: ProviderConfig): boolean {
+  return provider.kind === "cli" && (provider.runtime === "claude" || provider.runtime === "codex");
+}
+
+export async function runCliProvider(provider: ProviderConfig, body: string, requestId: string, path = "/v1/responses"): Promise<CliProviderResult> {
+  const request = cliRequest(body, provider);
+  const prompt = request.prompt;
+  const output = await executeCliProvider(provider, prompt, request.runModel);
+  const usage = { inputTokens: estimateTokens(prompt), outputTokens: estimateTokens(output) };
+  const model = request.responseModel;
+  if (isAnthropicMessages(path) && wantsStream(body)) {
+    return {
+      status: 200,
+      headers: { "content-type": "text/event-stream", "cache-control": "no-cache" },
+      body: Buffer.from(anthropicStream(requestId, model, output, usage)),
+      usage
+    };
+  }
+  if (isOpenAiResponses(path) && wantsStream(body)) {
+    return {
+      status: 200,
+      headers: { "content-type": "text/event-stream", "cache-control": "no-cache" },
+      body: Buffer.from(openAiResponsesStream(requestId, model, output, usage)),
+      usage
+    };
+  }
+  return {
+    status: 200,
+    headers: { "content-type": "application/json" },
+    body: Buffer.from(JSON.stringify(responseBody(requestId, model, output, path, usage))),
+    usage
+  };
+}
+
+function responseBody(requestId: string, model: string, text: string, path: string, usage: { inputTokens?: number; outputTokens?: number }) {
+  const input = usage.inputTokens ?? 0, output = usage.outputTokens ?? 0;
+  if (isAnthropicMessages(path)) {
+    return {
+      id: `msg_${requestId.replaceAll("-", "")}`,
+      type: "message",
+      role: "assistant",
+      model,
+      content: [{ type: "text", text }],
+      stop_reason: "end_turn",
+      stop_sequence: null,
+      usage: { input_tokens: input, output_tokens: output }
+    };
+  }
+  return {
+    id: requestId,
+    object: "response",
+    model,
+    output_text: text,
+    output: [{
+      type: "message",
+      role: "assistant",
+      content: [{ type: "output_text", text }]
+    }],
+    usage: { input_tokens: input, output_tokens: output, prompt_tokens: input, completion_tokens: output }
+  };
+}
+
+function isAnthropicMessages(path: string): boolean {
+  return path.split("?")[0] === "/v1/messages";
+}
+
+export function isOpenAiResponses(path: string): boolean {
+  return path.split("?")[0] === "/v1/responses";
+}
+
+export function wantsStream(body: string): boolean {
+  try {
+    const data = JSON.parse(body || "{}") as { stream?: unknown };
+    return data.stream === true;
+  } catch {
+    return false;
+  }
+}
+
+function anthropicStream(requestId: string, model: string, text: string, usage: { inputTokens?: number; outputTokens?: number }): string {
+  const id = `msg_${requestId.replaceAll("-", "")}`;
+  const input = usage.inputTokens ?? 0, output = usage.outputTokens ?? 0;
+  return [
+    sse("message_start", { type: "message_start", message: { id, type: "message", role: "assistant", model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: input, output_tokens: 0 } } }),
+    sse("content_block_start", { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } }),
+    sse("content_block_delta", { type: "content_block_delta", index: 0, delta: { type: "text_delta", text } }),
+    sse("content_block_stop", { type: "content_block_stop", index: 0 }),
+    sse("message_delta", { type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: output } }),
+    sse("message_stop", { type: "message_stop" })
+  ].join("");
+}
+
+function openAiResponsesStream(requestId: string, model: string, text: string, usage: { inputTokens?: number; outputTokens?: number }): string {
+  return [
+    openAiResponsesStreamStart(requestId, model),
+    openAiResponsesStreamOutput(requestId, model, text, usage),
+    "data: [DONE]\n\n"
+  ].join("");
+}
+
+export function openAiResponsesStreamStart(requestId: string, model: string): string {
+  const base = { id: requestId, object: "response", model, output: [] };
+  return [
+    sse("response.created", { type: "response.created", response: { ...base, status: "in_progress" } }),
+    sse("response.in_progress", { type: "response.in_progress", response: { ...base, status: "in_progress" } })
+  ].join("");
+}
+
+export function openAiResponsesStreamOutput(requestId: string, model: string, text: string, usage: { inputTokens?: number; outputTokens?: number }): string {
+  const input = usage.inputTokens ?? 0, output = usage.outputTokens ?? 0;
+  const itemId = `msg_${requestId.replaceAll("-", "")}`;
+  const base = { id: requestId, object: "response", model, output: [] };
+  const item = { id: itemId, type: "message", status: "completed", role: "assistant", content: [{ type: "output_text", text, annotations: [] }] };
+  const completed = {
+    ...base,
+    status: "completed",
+    output: [item],
+    output_text: text,
+    usage: {
+      input_tokens: input,
+      output_tokens: output,
+      total_tokens: input + output,
+      prompt_tokens: input,
+      completion_tokens: output
+    }
+  };
+  return [
+    sse("response.output_item.added", { type: "response.output_item.added", output_index: 0, item: { ...item, status: "in_progress", content: [] } }),
+    sse("response.content_part.added", { type: "response.content_part.added", item_id: itemId, output_index: 0, content_index: 0, part: { type: "output_text", text: "", annotations: [] } }),
+    sse("response.output_text.delta", { type: "response.output_text.delta", item_id: itemId, output_index: 0, content_index: 0, delta: text }),
+    sse("response.output_text.done", { type: "response.output_text.done", item_id: itemId, output_index: 0, content_index: 0, text }),
+    sse("response.content_part.done", { type: "response.content_part.done", item_id: itemId, output_index: 0, content_index: 0, part: item.content[0] }),
+    sse("response.output_item.done", { type: "response.output_item.done", output_index: 0, item }),
+    sse("response.completed", { type: "response.completed", response: completed })
+  ].join("");
+}
+
+export function openAiResponsesStreamFailure(requestId: string, model: string): string {
+  return [
+    sse("response.failed", {
+      type: "response.failed",
+      response: { id: requestId, object: "response", model, status: "failed", error: { code: "proxy_error", message: "Local CLI provider failed." } }
+    }),
+    "data: [DONE]\n\n"
+  ].join("");
+}
+
+function sse(event: string, data: unknown): string {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}

package/packages/proxy/src/runtime/cli-request.ts

@@ -0,0 +1,79 @@
+import type { ProviderConfig } from "../../../core/src/providers/provider-catalog.ts";
+
+type ParsedRequest = Record<string, unknown> | undefined;
+
+export type CliRequestShape = {
+  prompt: string;
+  responseModel: string;
+  runModel?: string;
+};
+
+export function cliRequest(body: string, provider: ProviderConfig): CliRequestShape {
+  const parsed = parseBody(body);
+  const model = requestModel(parsed, provider);
+  return {
+    prompt: parsed ? promptFromJson(parsed) || body : body,
+    responseModel: model.responseModel,
+    runModel: model.runModel
+  };
+}
+
+export function cliArgs(provider: ProviderConfig, runModel?: string): string[] {
+  const args = [...(provider.cliArgs ?? defaultArgs(provider))];
+  if (provider.runtime === "claude") {
+    ensureFlag(args, "--no-session-persistence");
+    if (runModel && !hasModelFlag(args)) args.push("--model", runModel);
+  }
+  if (provider.runtime === "codex") {
+    ensureFlag(args, "--ephemeral");
+    if (provider.runtimeAuthDir) ensureFlag(args, "--ignore-user-config");
+    if (runModel && !hasModelFlag(args)) args.push("-m", runModel);
+  }
+  return args;
+}
+
+function requestModel(parsed: ParsedRequest, provider: ProviderConfig): { responseModel: string; runModel?: string } {
+  const raw = typeof parsed?.model === "string" ? parsed.model.trim() : "";
+  const fallback = provider.runtime === "claude" ? "sonnet" : provider.runtime === "codex" ? "gpt-5" : provider.id;
+  if (!raw) return { responseModel: fallback };
+  return { responseModel: raw, runModel: raw };
+}
+
+function defaultArgs(provider: ProviderConfig): string[] {
+  return provider.runtime === "codex" ? ["exec"] : ["--print"];
+}
+
+function ensureFlag(args: string[], flag: string): void {
+  if (!args.includes(flag)) args.push(flag);
+}
+
+function hasModelFlag(args: string[]): boolean {
+  return args.some((arg) => arg === "-m" || arg === "--model" || arg.startsWith("--model="));
+}
+
+function parseBody(body: string): ParsedRequest {
+  if (!body.trim()) return {};
+  try {
+    const parsed = JSON.parse(body);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as ParsedRequest : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function promptFromJson(record: Record<string, unknown>): string {
+  return collectText(record.input) || collectMessages(record.messages) || collectText(record.prompt);
+}
+
+function collectMessages(value: unknown): string {
+  if (!Array.isArray(value)) return "";
+  return value.map((item) => collectText((item as Record<string, unknown>)?.content)).filter(Boolean).join("\n");
+}
+
+function collectText(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map(collectText).filter(Boolean).join("\n");
+  if (!value || typeof value !== "object") return "";
+  const record = value as Record<string, unknown>;
+  return collectText(record.text ?? record.input_text ?? record.output_text ?? record.content);
+}

package/packages/proxy/src/runtime/codex-runtime-config.ts

@@ -0,0 +1,37 @@
+import type { RuntimeProfileConfig } from "../../../core/src/providers/provider-catalog.ts";
+
+const CODEX_SANDBOX = new Set(["read-only", "workspace-write", "danger-full-access"]);
+const CODEX_APPROVAL = new Set(["untrusted", "on-failure", "on-request", "never"]);
+
+export function codexConfigSummary(toml: string): RuntimeProfileConfig {
+  const values = topLevelValues(toml);
+  const bypass = values.get("dangerously_bypass_approvals_and_sandbox") === "true";
+  return {
+    sandbox: bypass ? "danger-full-access" : enumText(values.get("sandbox_mode") || "", CODEX_SANDBOX, "invalid_sandbox"),
+    approval: bypass ? "never" : enumText(values.get("approval_policy") || "", CODEX_APPROVAL, "invalid_approval")
+  };
+}
+
+function topLevelValues(toml: string): Map<string, string> {
+  const values = new Map<string, string>();
+  for (const rawLine of toml.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line.startsWith("[")) break;
+    const match = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*(.+)$/);
+    if (match) values.set(match[1], cleanValue(match[2]));
+  }
+  return values;
+}
+
+function cleanValue(value: string): string {
+  const trimmed = value.replace(/\s+#.*$/, "").trim();
+  const quoted = trimmed.match(/^"([^"]*)"$/) || trimmed.match(/^'([^']*)'$/);
+  return (quoted?.[1] ?? trimmed).replace(/_/g, "-");
+}
+
+function enumText(value: string, allowed: Set<string>, error: string): string | undefined {
+  if (!value) return undefined;
+  if (!allowed.has(value)) throw new Error(error);
+  return value;
+}