@rynfar/meridian 1.51.0 → 1.53.0

package/dist/{cli-7df5eg5d.js → cli-027as0fx.js}

@@ -22,9 +22,11 @@ import {
   themeCss
 } from "./cli-xmweegb1.js";
 import {
+  CANONICAL_SONNET_MODEL,
   env,
   envBool,
   envInt,
+  explicitModelPin,
   getAuthCacheInfo,
   getClaudeAuthStatusAsync,
   getResolvedClaudeExecutableInfo,
@@ -37,7 +39,7 @@ import {
   resolvePassthrough,
   resolveSdkModelDefaults,
   stripExtendedContext
-} from "./cli-aybvv9nb.js";
+} from "./cli-vjeftz4z.js";
 import {
   getSetting
 } from "./cli-340h1chz.js";
@@ -1532,7 +1534,7 @@ function getExplicitThinking(adapterName) {
   return typeof explicit === "string" && VALID_THINKING_VALUES.has(explicit) ? explicit : undefined;
 }
 function getAllFeatureConfigs() {
-  const adapters = ["opencode", "crush", "forgecode", "pi", "droid", "passthrough", "openai"];
+  const adapters = ["opencode", "crush", "forgecode", "pi", "droid", "passthrough", "openai", "codex"];
   const result = {};
   for (const name of adapters) {
     result[name] = getFeaturesForAdapter(name);
@@ -1610,6 +1612,9 @@ var init_sdkFeatures = __esm(() => {
     },
     cherry: {
       codeSystemPrompt: false
+    },
+    codex: {
+      codeSystemPrompt: false
     }
   };
   VALID_CLAUDE_MD_VALUES = new Set(["off", "project", "full"]);
@@ -10179,6 +10184,11 @@ function isStaleSessionError(error) {
   const msg = error.message;
   return msg.includes("No message found with message.uuid") || msg.includes("No conversation found with session ID") || msg.includes("No conversation found to continue") || msg.includes("No conversations found to resume");
 }
+function isBusySessionError(error, stderr) {
+  const needle = "is currently running as a background agent";
+  const msg = error instanceof Error ? error.message : String(error);
+  return msg.includes(needle) || (stderr?.includes(needle) ?? false);
+}
 function isRateLimitError(errMsg) {
   const lower = errMsg.toLowerCase();
   return lower.includes("429") || lower.includes("rate limit") || lower.includes("too many requests");
@@ -10459,7 +10469,7 @@ ${historyBlock}` : historyBlock;
     messagesToSend = turns.slice(-1);
   }
   const result = {
-    model: body.model ?? "claude-sonnet-4-6",
+    model: body.model ?? CANONICAL_SONNET_MODEL,
     messages: messagesToSend,
     max_tokens: body.max_tokens ?? body.max_completion_tokens ?? 8192,
     tools,
@@ -10665,6 +10675,15 @@ var FULL_CAPABILITIES = Object.freeze({
 });
 function buildModelList(isMaxSubscription, now = Math.floor(Date.now() / 1000)) {
   return [
+    {
+      id: "claude-sonnet-5",
+      object: "model",
+      created: now,
+      owned_by: "anthropic",
+      display_name: "Claude Sonnet 5",
+      context_window: 200000,
+      capabilities: FULL_CAPABILITIES
+    },
     {
       id: "claude-sonnet-4-6",
       object: "model",
@@ -10722,6 +10741,331 @@ function buildModelList(isMaxSubscription, now = Math.floor(Date.now() / 1000))
   ];
 }
 
+// src/proxy/openaiResponses.ts
+function partsToText(content) {
+  if (typeof content === "string")
+    return content;
+  return content.filter((p) => typeof p.text === "string").map((p) => p.text).join("");
+}
+function mapToolChoice(tc) {
+  if (tc === "auto")
+    return { type: "auto" };
+  if (tc === "required")
+    return { type: "any" };
+  if (tc && typeof tc === "object") {
+    const o = tc;
+    if (o.type === "function" && o.name)
+      return { type: "tool", name: o.name };
+    if (o.type === "auto")
+      return { type: "auto" };
+    if (o.type === "any" || o.type === "required")
+      return { type: "any" };
+  }
+  return;
+}
+function translateResponsesToAnthropic(body) {
+  if (body.input === undefined || body.input === null)
+    return null;
+  const items = typeof body.input === "string" ? [{ type: "message", role: "user", content: [{ type: "input_text", text: body.input }] }] : body.input;
+  const systemParts = [];
+  if (body.instructions)
+    systemParts.push(body.instructions);
+  const messages = [];
+  const pushBlock = (role, block) => {
+    const last = messages[messages.length - 1];
+    if (last && last.role === role && Array.isArray(last.content)) {
+      last.content.push(block);
+    } else {
+      messages.push({ role, content: [block] });
+    }
+  };
+  for (const item of items) {
+    switch (item.type) {
+      case "message": {
+        const msg = item;
+        if (msg.role === "developer" || msg.role === "system") {
+          const t = partsToText(msg.content);
+          if (t)
+            systemParts.push(t);
+          break;
+        }
+        const text = partsToText(msg.content);
+        if (text)
+          pushBlock(msg.role === "assistant" ? "assistant" : "user", { type: "text", text });
+        break;
+      }
+      case "function_call": {
+        const fc = item;
+        let input = {};
+        try {
+          input = fc.arguments ? JSON.parse(fc.arguments) : {};
+        } catch {
+          input = {};
+        }
+        pushBlock("assistant", { type: "tool_use", id: fc.call_id, name: fc.name, input });
+        break;
+      }
+      case "function_call_output": {
+        const fo = item;
+        pushBlock("user", { type: "tool_result", tool_use_id: fo.call_id, content: fo.output });
+        break;
+      }
+      case "reasoning":
+        break;
+      default:
+        break;
+    }
+  }
+  const result = {
+    model: typeof body.model === "string" ? body.model : "",
+    messages,
+    max_tokens: body.max_output_tokens ?? 8192,
+    stream: body.stream ?? false
+  };
+  if (systemParts.length > 0)
+    result.system = systemParts.join(`
+
+`);
+  if (Array.isArray(body.tools) && body.tools.length > 0) {
+    result.tools = body.tools.filter((t) => t.type === "function").map((t) => ({
+      name: t.name,
+      description: t.description ?? "",
+      input_schema: t.parameters ?? { type: "object", properties: {} }
+    }));
+  }
+  const tc = mapToolChoice(body.tool_choice);
+  if (tc)
+    result.tool_choice = tc;
+  if (body.temperature !== undefined)
+    result.temperature = body.temperature;
+  if (body.top_p !== undefined)
+    result.top_p = body.top_p;
+  if (body.reasoning?.effort !== undefined)
+    result.reasoning_effort = body.reasoning.effort;
+  return result;
+}
+function reasoningRequested(body) {
+  if (body.reasoning && typeof body.reasoning === "object")
+    return true;
+  const include = body.include;
+  return Array.isArray(include) && include.some((v) => typeof v === "string" && v.startsWith("reasoning"));
+}
+function mapUsage(usage) {
+  const input = usage?.input_tokens ?? 0;
+  const output = usage?.output_tokens ?? 0;
+  return { input_tokens: input, output_tokens: output, total_tokens: input + output };
+}
+function translateAnthropicToResponses(res, ctx) {
+  const output = [];
+  const textParts = [];
+  for (const block of res.content ?? []) {
+    if (block.type === "text" && typeof block.text === "string") {
+      textParts.push({ type: "output_text", text: block.text, annotations: [] });
+    } else if (block.type === "tool_use") {
+      output.push({
+        type: "function_call",
+        id: `fc_${block.id}`,
+        call_id: block.id,
+        name: block.name,
+        arguments: JSON.stringify(block.input ?? {}),
+        status: "completed"
+      });
+    }
+  }
+  if (textParts.length > 0) {
+    output.unshift({
+      type: "message",
+      id: `msg_${ctx.responseId}`,
+      status: "completed",
+      role: "assistant",
+      content: textParts
+    });
+  }
+  if (ctx.reasoningRequested) {
+    output.unshift({
+      type: "reasoning",
+      id: `rs_${ctx.responseId}`,
+      summary: [],
+      encrypted_content: null,
+      status: "completed"
+    });
+  }
+  return {
+    id: ctx.responseId,
+    object: "response",
+    created_at: ctx.created,
+    model: ctx.model,
+    status: "completed",
+    output,
+    usage: mapUsage(res.usage),
+    parallel_tool_calls: true,
+    tool_choice: "auto",
+    tools: []
+  };
+}
+function createResponsesSseTranslator(ctx) {
+  let seq = 0;
+  let outputIndex = 0;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let createdEmitted = false;
+  const blocks = new Map;
+  const finalOutput = [];
+  const emit = (event, data) => ({
+    event,
+    data: { type: event, ...data, sequence_number: seq++ }
+  });
+  const responseEnvelope = (status, extra = {}) => ({
+    id: ctx.responseId,
+    object: "response",
+    created_at: ctx.created,
+    model: ctx.model,
+    status,
+    ...extra
+  });
+  return (event) => {
+    const out = [];
+    switch (event.type) {
+      case "message_start": {
+        inputTokens = event.message?.usage?.input_tokens ?? 0;
+        if (!createdEmitted) {
+          createdEmitted = true;
+          out.push(emit("response.created", { response: responseEnvelope("in_progress", { output: [] }) }));
+          out.push(emit("response.in_progress", { response: responseEnvelope("in_progress", { output: [] }) }));
+          if (ctx.reasoningRequested) {
+            const oi = outputIndex++;
+            const itemId = `rs_${ctx.responseId}`;
+            const item = { type: "reasoning", id: itemId, summary: [], encrypted_content: null, status: "completed" };
+            out.push(emit("response.output_item.added", { output_index: oi, item: { ...item, status: "in_progress" } }));
+            finalOutput.push(item);
+            out.push(emit("response.output_item.done", { output_index: oi, item }));
+          }
+        }
+        break;
+      }
+      case "content_block_start": {
+        const idx = event.index ?? 0;
+        const cb = event.content_block ?? {};
+        if (cb.type === "text") {
+          const oi = outputIndex++;
+          const itemId = `msg_${ctx.responseId}_${oi}`;
+          blocks.set(idx, { kind: "text", outputIndex: oi, itemId, text: "", args: "" });
+          out.push(emit("response.output_item.added", {
+            output_index: oi,
+            item: { type: "message", id: itemId, status: "in_progress", role: "assistant", content: [] }
+          }));
+          out.push(emit("response.content_part.added", {
+            item_id: itemId,
+            output_index: oi,
+            content_index: 0,
+            part: { type: "output_text", text: "", annotations: [] }
+          }));
+        } else if (cb.type === "tool_use") {
+          const oi = outputIndex++;
+          const itemId = `fc_${cb.id}`;
+          blocks.set(idx, { kind: "tool", outputIndex: oi, itemId, text: "", args: "", callId: cb.id, name: cb.name });
+          out.push(emit("response.output_item.added", {
+            output_index: oi,
+            item: { type: "function_call", id: itemId, call_id: cb.id, name: cb.name, arguments: "", status: "in_progress" }
+          }));
+        } else {
+          blocks.set(idx, { kind: "skip", outputIndex: -1, itemId: "", text: "", args: "" });
+        }
+        break;
+      }
+      case "content_block_delta": {
+        const idx = event.index ?? 0;
+        const st = blocks.get(idx);
+        if (!st || st.kind === "skip")
+          break;
+        if (st.kind === "text" && event.delta?.type === "text_delta" && typeof event.delta.text === "string") {
+          st.text += event.delta.text;
+          out.push(emit("response.output_text.delta", {
+            item_id: st.itemId,
+            output_index: st.outputIndex,
+            content_index: 0,
+            delta: event.delta.text
+          }));
+        } else if (st.kind === "tool" && event.delta?.type === "input_json_delta" && typeof event.delta.partial_json === "string") {
+          st.args += event.delta.partial_json;
+          out.push(emit("response.function_call_arguments.delta", {
+            item_id: st.itemId,
+            output_index: st.outputIndex,
+            delta: event.delta.partial_json
+          }));
+        }
+        break;
+      }
+      case "content_block_stop": {
+        const idx = event.index ?? 0;
+        const st = blocks.get(idx);
+        if (!st || st.kind === "skip")
+          break;
+        if (st.kind === "text") {
+          out.push(emit("response.output_text.done", {
+            item_id: st.itemId,
+            output_index: st.outputIndex,
+            content_index: 0,
+            text: st.text
+          }));
+          out.push(emit("response.content_part.done", {
+            item_id: st.itemId,
+            output_index: st.outputIndex,
+            content_index: 0,
+            part: { type: "output_text", text: st.text, annotations: [] }
+          }));
+          const item = {
+            type: "message",
+            id: st.itemId,
+            status: "completed",
+            role: "assistant",
+            content: [{ type: "output_text", text: st.text, annotations: [] }]
+          };
+          finalOutput.push(item);
+          out.push(emit("response.output_item.done", { output_index: st.outputIndex, item }));
+        } else if (st.kind === "tool") {
+          out.push(emit("response.function_call_arguments.done", {
+            item_id: st.itemId,
+            output_index: st.outputIndex,
+            arguments: st.args
+          }));
+          const item = {
+            type: "function_call",
+            id: st.itemId,
+            call_id: st.callId,
+            name: st.name,
+            arguments: st.args,
+            status: "completed"
+          };
+          finalOutput.push(item);
+          out.push(emit("response.output_item.done", { output_index: st.outputIndex, item }));
+        }
+        break;
+      }
+      case "message_delta": {
+        if (typeof event.usage?.output_tokens === "number")
+          outputTokens = event.usage.output_tokens;
+        break;
+      }
+      case "message_stop": {
+        out.push(emit("response.completed", {
+          response: responseEnvelope("completed", {
+            output: finalOutput,
+            usage: { input_tokens: inputTokens, output_tokens: outputTokens, total_tokens: inputTokens + outputTokens },
+            parallel_tool_calls: true,
+            tool_choice: "auto",
+            tools: []
+          })
+        }));
+        break;
+      }
+      default:
+        break;
+    }
+    return out;
+  };
+}
+
 // src/proxy/messages.ts
 function stripCacheControlForHashing(obj) {
   if (!obj || typeof obj !== "object")
@@ -10780,6 +11124,27 @@ function getLastUserMessage(messages) {
   }
   return messages.slice(-1);
 }
+function frameReplayTurns(turns) {
+  const nonEmpty = turns.filter((t) => t.text);
+  const joined = nonEmpty.map((t) => t.text).join(`
+
+`);
+  if (nonEmpty.length < 2)
+    return joined;
+  const last = nonEmpty[nonEmpty.length - 1];
+  if (last.role !== "user")
+    return joined;
+  const history = nonEmpty.slice(0, -1).map((t) => t.text).join(`
+
+`);
+  return `<conversation_history>
+${history}
+</conversation_history>
+
+` + `The above is a replay of your prior conversation with this user — the original session could not be resumed. ` + `It is context only: do not continue or imitate its transcript format, do not write "[Assistant: ...]" markers, ` + `and never invent tool output — use your actual tools when action is needed. ` + `Respond only as the assistant to the user's message below.
+
+` + last.text;
+}
 function stripNonStandardStreamFields(event) {
   if (event && typeof event === "object") {
     const e = event;
@@ -11099,7 +11464,7 @@ init_env();
 var openCodeTransforms = [
   {
     name: "opencode-core",
-    adapters: ["opencode", "openai"],
+    adapters: ["opencode", "openai", "codex"],
     onRequest(ctx) {
       const body = ctx.body;
       const blockedTools = BLOCKED_BUILTIN_TOOLS;
@@ -11903,6 +12268,15 @@ var openAiAdapter = {
   name: "openai"
 };
 
+// src/proxy/adapters/codex.ts
+var codexAdapter = {
+  ...openCodeAdapter,
+  name: "codex",
+  usesPassthrough() {
+    return true;
+  }
+};
+
 // src/proxy/adapters/cherry.ts
 var CHERRY_WEB_TOOLS = ["WebSearch", "WebFetch"];
 var isWebTool = (t) => CHERRY_WEB_TOOLS.includes(t);
@@ -12024,7 +12398,8 @@ var ADAPTER_MAP = {
   claudecode: claudeCodeAdapter,
   cherry: cherryAdapter,
   cherrystudio: cherryAdapter,
-  openai: openAiAdapter
+  openai: openAiAdapter,
+  codex: codexAdapter
 };
 var envDefault = process.env.MERIDIAN_DEFAULT_AGENT || "";
 if (envDefault && !ADAPTER_MAP[envDefault]) {
@@ -17852,6 +18227,7 @@ function buildQueryOptions(ctx, abortController) {
     resumeSessionId,
     isUndo,
     undoRollbackUuid,
+    forkSession,
     sdkHooks,
     blockedTools,
     incompatibleTools,
@@ -17891,7 +18267,6 @@ function buildQueryOptions(ctx, abortController) {
       ...resolveSystemPrompt(systemContext, passthrough, settingSources, codeSystemPrompt, clientSystemPrompt, cwdNote),
       ...passthrough ? {
         tools: [],
-        settingSources: [],
         disallowedTools: [...allBlockedTools],
         ...passthroughMcp ? {
           allowedTools: [...passthroughMcp.toolNames],
@@ -17903,13 +18278,11 @@ function buildQueryOptions(ctx, abortController) {
         mcpServers: { [mcpServerName]: createOpencodeMcpServer() }
       },
       plugins: [],
-      ...settingSources && settingSources.length > 0 ? {
-        settingSources,
-        settings: {
-          autoMemoryEnabled: ctx.memory ?? true,
-          autoDreamEnabled: ctx.dreaming ?? false
-        }
-      } : {},
+      settings: {
+        autoMemoryEnabled: ctx.memory ?? true,
+        autoDreamEnabled: ctx.dreaming ?? false
+      },
+      settingSources: settingSources ?? [],
       ...onStderr ? { stderr: onStderr } : {},
       env: {
         ...sharedMemory ? stripConfigDir(cleanEnv) : cleanEnv,
@@ -17921,7 +18294,8 @@ function buildQueryOptions(ctx, abortController) {
       },
       ...Object.keys(sdkAgents).length > 0 ? { agents: sdkAgents } : {},
       ...resumeSessionId ? { resume: resumeSessionId } : {},
-      ...isUndo ? { forkSession: true, ...undoRollbackUuid ? { resumeSessionAt: undoRollbackUuid } : {} } : {},
+      ...isUndo || forkSession ? { forkSession: true } : {},
+      ...isUndo && undoRollbackUuid ? { resumeSessionAt: undoRollbackUuid } : {},
       ...sdkHooks ? { hooks: sdkHooks } : {},
       ...effort ? { effort } : {},
       ...thinking ? { thinking } : {},
@@ -17998,6 +18372,17 @@ var cherryTransforms = [
   }
 ];
 
+// src/proxy/transforms/codex.ts
+var codexTransforms = [
+  {
+    name: "codex-force-passthrough",
+    adapters: ["codex"],
+    onRequest(ctx) {
+      return { ...ctx, passthrough: true };
+    }
+  }
+];
+
 // src/proxy/transforms/registry.ts
 var ADAPTER_TRANSFORMS = {
   opencode: openCodeTransforms,
@@ -18007,7 +18392,8 @@ var ADAPTER_TRANSFORMS = {
   forgecode: forgeCodeTransforms,
   passthrough: passthroughTransforms,
   cherry: cherryTransforms,
-  openai: openCodeTransforms
+  openai: openCodeTransforms,
+  codex: [...openCodeTransforms, ...codexTransforms]
 };
 function getAdapterTransforms(adapterName) {
   return ADAPTER_TRANSFORMS[adapterName] ?? [];
@@ -19019,15 +19405,13 @@ function buildFreshPrompt(messages, sanitizeOpts = {}) {
         yield msg;
     }();
   }
-  return messages.map((m) => {
+  return frameReplayTurns(messages.map((m) => {
     if (m.role === "assistant") {
       const assistantText = flattenAssistantContent(m.content);
-      return assistantText ? `[Assistant: ${assistantText}]` : "";
+      return { role: "assistant", text: assistantText ? `[Assistant: ${assistantText}]` : "" };
     }
-    return flattenUserContent(m.content, sanitizeOpts, toolIndex);
-  }).filter(Boolean).join(`
-
-`) || "";
+    return { role: "user", text: flattenUserContent(m.content, sanitizeOpts, toolIndex) };
+  }));
 }
 var proxyLogSilent = false;
 function plog(message) {
@@ -19090,6 +19474,8 @@ function createProxyServer(config = {}) {
   const sessionMcpCache = new LRUMap(getMaxSessionsLimit());
   const PENDING_STORE_WAIT_MS = 3000;
   const PENDING_STORE_AUTO_RESOLVE_MS = 1e4;
+  const BUSY_SESSION_MAX_RETRIES = 3;
+  const BUSY_SESSION_RETRY_DELAY_MS = parseInt(process.env.MERIDIAN_BUSY_RETRY_DELAY_MS ?? "500", 10);
   const pendingSessionStores = new Map;
   const registerPendingStore = (key) => {
     let resolveFn = () => {};
@@ -19133,7 +19519,7 @@ function createProxyServer(config = {}) {
         status: "ok",
         service: "meridian",
         format: "anthropic",
-        endpoints: ["/v1/messages", "/messages", "/v1/chat/completions", "/v1/models", "/telemetry", "/metrics", "/health"]
+        endpoints: ["/v1/messages", "/messages", "/v1/chat/completions", "/v1/responses", "/v1/models", "/telemetry", "/metrics", "/health"]
       });
     }
     return c.html(landingHtml);
@@ -19198,7 +19584,7 @@ function createProxyServer(config = {}) {
         const requestSource = c.req.header("x-meridian-source")?.slice(0, 64) || undefined;
         const requestedModel = typeof body.model === "string" ? body.model : "sonnet";
         let model = mapModelToClaudeModel(requestedModel, authStatus?.subscriptionType, agentMode);
-        const envOverrides = requestedModel.startsWith("claude-opus-") ? { ANTHROPIC_DEFAULT_OPUS_MODEL: requestedModel } : requestedModel.startsWith("claude-fable-") ? { ANTHROPIC_DEFAULT_FABLE_MODEL: requestedModel } : requestedModel.startsWith("claude-mythos-") ? { ANTHROPIC_DEFAULT_FABLE_MODEL: requestedModel } : requestedModel.startsWith("claude-sonnet-") ? { ANTHROPIC_DEFAULT_SONNET_MODEL: requestedModel } : requestedModel.startsWith("claude-haiku-") ? { ANTHROPIC_DEFAULT_HAIKU_MODEL: requestedModel } : undefined;
+        const envOverrides = explicitModelPin(requestedModel);
         const cwdResolution = resolveSdkWorkingDirectory({
           envOverride: process.env.MERIDIAN_WORKDIR ?? process.env.CLAUDE_PROXY_WORKDIR,
           adapterCwd: adapter.extractWorkingDirectory(body),
@@ -19407,17 +19793,18 @@ function createProxyServer(config = {}) {
           }
         } else {
           const toolIndex = buildToolUseIndex(allMessages ?? messagesToConvert ?? []);
-          textPrompt = messagesToConvert?.map((m) => {
+          const promptTurns = (messagesToConvert ?? []).map((m) => {
             if (m.role === "assistant") {
               if (isResume)
-                return "";
+                return { role: "assistant", text: "" };
               const assistantText = flattenAssistantContent(m.content);
-              return assistantText ? `[Assistant: ${assistantText}]` : "";
+              return { role: "assistant", text: assistantText ? `[Assistant: ${assistantText}]` : "" };
             }
-            return flattenUserContent(m.content, sanitizeOpts, toolIndex);
-          }).filter(Boolean).join(`
+            return { role: "user", text: flattenUserContent(m.content, sanitizeOpts, toolIndex) };
+          });
+          textPrompt = isResume ? promptTurns.map((t) => t.text).filter(Boolean).join(`
 
-`) || "";
+`) || "" : frameReplayTurns(promptTurns);
         }
         const passthrough = adapter.instancePassthrough !== undefined ? adapter.instancePassthrough : pipelineCtx.passthrough !== undefined ? pipelineCtx.passthrough : envBool("PASSTHROUGH");
         const settingSources = envBool("LOAD_CONTEXT") || sdkFeatures.claudeMd === "full" ? ["user", "project"] : sdkFeatures.claudeMd === "project" ? ["project"] : pipelineCtx.settingSources ?? [];
@@ -19543,7 +19930,7 @@ function createProxyServer(config = {}) {
                   input: toolInput
                 });
               }
-              if (stream2 && earlyStopEnabled && turnGenerating && !requestAbort.controller.signal.aborted) {
+              if (earlyStopEnabled && turnGenerating && !requestAbort.controller.signal.aborted) {
                 await holdDenyUntilTurnEnd();
               }
               if (isExactDuplicate) {
@@ -19600,8 +19987,12 @@ function createProxyServer(config = {}) {
               }
               let tokenRefreshed = false;
               let didFreshBaseRetry = false;
+              let busySessionRetries = 0;
+              let busySessionFork = false;
               while (true) {
                 let didYieldContent = false;
+                const attemptStderrStart = stderrLines.length;
+                turnGenerating = true;
                 try {
                   for await (const event of query(buildQueryOptions({
                     prompt: makePrompt(),
@@ -19620,6 +20011,7 @@ function createProxyServer(config = {}) {
                     resumeSessionId,
                     isUndo,
                     undoRollbackUuid,
+                    forkSession: busySessionFork || undefined,
                     sdkHooks,
                     blockedTools: pipelineCtx.blockedTools,
                     incompatibleTools: pipelineCtx.incompatibleTools,
@@ -19654,8 +20046,25 @@ function createProxyServer(config = {}) {
                   return;
                 } catch (error) {
                   const errMsg = error instanceof Error ? error.message : String(error);
+                  releaseHeldDenies("non_stream_attempt_error");
                   if (didYieldContent)
                     throw error;
+                  if (resumeSessionId && isBusySessionError(error, stderrLines.slice(attemptStderrStart).join(`
+`))) {
+                    if (busySessionRetries < BUSY_SESSION_MAX_RETRIES) {
+                      busySessionRetries++;
+                      claudeLog("session.busy_retry", { mode: "non_stream", attempt: busySessionRetries, resumeSessionId });
+                      plog(`[PROXY] ${requestMeta.requestId} session busy (bg agent), retrying resume ${busySessionRetries}/${BUSY_SESSION_MAX_RETRIES}`);
+                      await new Promise((resolve3) => setTimeout(resolve3, BUSY_SESSION_RETRY_DELAY_MS * busySessionRetries));
+                      continue;
+                    }
+                    if (!busySessionFork) {
+                      busySessionFork = true;
+                      claudeLog("session.busy_fork", { mode: "non_stream", resumeSessionId });
+                      plog(`[PROXY] ${requestMeta.requestId} session still busy after ${BUSY_SESSION_MAX_RETRIES} retries — forking session`);
+                      continue;
+                    }
+                  }
                   if (isStaleSessionError(error)) {
                     claudeLog("session.stale_uuid_retry", {
                       mode: "non_stream",
@@ -19839,6 +20248,7 @@ function createProxyServer(config = {}) {
                 }
               }
               if (message.type === "assistant") {
+                releaseHeldDenies("assistant_message");
                 assistantMessages += 1;
                 if (message.uuid) {
                   sdkUuidMap.push(message.uuid);
@@ -19899,6 +20309,7 @@ function createProxyServer(config = {}) {
                 }
               }
             }
+            releaseHeldDenies("non_stream_loop_exit");
             claudeLog("upstream.completed", {
               mode: "non_stream",
               model,
@@ -19918,6 +20329,7 @@ function createProxyServer(config = {}) {
               plog(`[PROXY] ${requestMeta.requestId} discovered=${discoveredTools.size} (${newNames}) session_total=${allNames.length}`);
             }
           } catch (error) {
+            releaseHeldDenies("non_stream_error");
             const stderrOutput = stderrLines.join(`
 `).trim();
             if (stderrOutput && error instanceof Error && !error.message.includes(stderrOutput)) {
@@ -20158,8 +20570,11 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                 }
                 let tokenRefreshed = false;
                 let didFreshBaseRetry = false;
+                let busySessionRetries = 0;
+                let busySessionFork = false;
                 while (true) {
                   let didYieldClientEvent = false;
+                  const attemptStderrStart = stderrLines.length;
                   try {
                     for await (const event of query(buildQueryOptions({
                       prompt: makePrompt(),
@@ -20178,6 +20593,7 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                       resumeSessionId,
                       isUndo,
                       undoRollbackUuid,
+                      forkSession: busySessionFork || undefined,
                       sdkHooks,
                       blockedTools: pipelineCtx.blockedTools,
                       incompatibleTools: pipelineCtx.incompatibleTools,
@@ -20214,6 +20630,22 @@ data: ${JSON.stringify({ type: "content_block_stop", index: idx })}
                     const errMsg = error instanceof Error ? error.message : String(error);
                     if (didYieldClientEvent)
                       throw error;
+                    if (resumeSessionId && isBusySessionError(error, stderrLines.slice(attemptStderrStart).join(`
+`))) {
+                      if (busySessionRetries < BUSY_SESSION_MAX_RETRIES) {
+                        busySessionRetries++;
+                        claudeLog("session.busy_retry", { mode: "stream", attempt: busySessionRetries, resumeSessionId });
+                        plog(`[PROXY] ${requestMeta.requestId} session busy (bg agent), retrying resume ${busySessionRetries}/${BUSY_SESSION_MAX_RETRIES}`);
+                        await new Promise((resolve3) => setTimeout(resolve3, BUSY_SESSION_RETRY_DELAY_MS * busySessionRetries));
+                        continue;
+                      }
+                      if (!busySessionFork) {
+                        busySessionFork = true;
+                        claudeLog("session.busy_fork", { mode: "stream", resumeSessionId });
+                        plog(`[PROXY] ${requestMeta.requestId} session still busy after ${BUSY_SESSION_MAX_RETRIES} retries — forking session`);
+                        continue;
+                      }
+                    }
                     if (isStaleSessionError(error)) {
                       claudeLog("session.stale_uuid_retry", {
                         mode: "stream",
@@ -21373,7 +21805,7 @@ data: ${JSON.stringify({
     }
     const completionId = `chatcmpl-${randomUUID()}`;
     const created = Math.floor(Date.now() / 1000);
-    const model = typeof rawBody.model === "string" && rawBody.model ? rawBody.model : "claude-sonnet-4-6";
+    const model = typeof rawBody.model === "string" && rawBody.model ? rawBody.model : CANONICAL_SONNET_MODEL;
     const { getFeaturesForAdapter: getFeaturesForAdapter2 } = (init_sdkFeatures(), __toCommonJS(exports_sdkFeatures));
     const sdkFeatures = getFeaturesForAdapter2("openai");
     if (!anthropicBody.stream) {
@@ -21452,6 +21884,107 @@ data: ${JSON.stringify({
       }
     });
   });
+  app.post("/v1/responses", async (c) => {
+    const rawBody = await c.req.json();
+    const anthropicBody = translateResponsesToAnthropic(rawBody);
+    if (!anthropicBody) {
+      return c.json({ error: { type: "invalid_request_error", message: "input: Field required", code: null } }, 400);
+    }
+    if (!anthropicBody.model) {
+      return c.json({ error: { type: "invalid_request_error", message: "model: Field required", code: null } }, 400);
+    }
+    const internalHeaders = {
+      "Content-Type": "application/json",
+      "x-meridian-agent": "codex"
+    };
+    const xApiKey = c.req.header("x-api-key");
+    if (xApiKey)
+      internalHeaders["x-api-key"] = xApiKey;
+    const authz = c.req.header("authorization");
+    if (authz)
+      internalHeaders["authorization"] = authz;
+    const xProfile = c.req.header("x-meridian-profile");
+    if (xProfile)
+      internalHeaders["x-meridian-profile"] = xProfile;
+    const internalReq = new Request("http://internal/v1/messages", {
+      method: "POST",
+      headers: internalHeaders,
+      body: JSON.stringify(anthropicBody)
+    });
+    const internalRes = await app.fetch(internalReq);
+    if (!internalRes.ok) {
+      const errBody = await internalRes.text();
+      return c.json({ error: { type: "upstream_error", message: errBody, code: null } }, internalRes.status);
+    }
+    const responseId = `resp_${randomUUID().replace(/-/g, "")}`;
+    const created = Math.floor(Date.now() / 1000);
+    const model = typeof rawBody.model === "string" && rawBody.model ? rawBody.model : CANONICAL_SONNET_MODEL;
+    const ctx = { responseId, model, created, reasoningRequested: reasoningRequested(rawBody) };
+    if (!anthropicBody.stream) {
+      const anthropicRes = await internalRes.json();
+      return c.json(translateAnthropicToResponses(anthropicRes, ctx));
+    }
+    const encoder = new TextEncoder;
+    const readable = new ReadableStream({
+      async start(controller) {
+        const reader = internalRes.body?.getReader();
+        if (!reader) {
+          controller.close();
+          return;
+        }
+        const decoder = new TextDecoder;
+        let buffer = "";
+        const translate = createResponsesSseTranslator(ctx);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (!line.startsWith("data: "))
+                continue;
+              const dataStr = line.slice(6).trim();
+              if (!dataStr)
+                continue;
+              let event;
+              try {
+                event = JSON.parse(dataStr);
+              } catch {
+                continue;
+              }
+              if (typeof event.type !== "string")
+                continue;
+              for (const emission of translate(event)) {
+                controller.enqueue(encoder.encode(`event: ${emission.event}
+data: ${JSON.stringify(emission.data)}
+
+`));
+              }
+            }
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          controller.enqueue(encoder.encode(`event: response.failed
+data: ${JSON.stringify({ response: { id: responseId, status: "failed", error: { message } } })}
+
+`));
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    return new Response(readable, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  });
   app.get("/v1/models", async (c) => {
     const authStatus = await getClaudeAuthStatusAsync();
     const isMax = authStatus?.subscriptionType === "max";