@rynfar/meridian 1.40.0 → 1.41.0

package/dist/{cli-3azh7s3k.js → cli-swjr844z.js}

@@ -25,9 +25,10 @@ import {
 } from "./cli-rtab0qa6.js";
 import {
   claudeLog,
+  createPlatformCredentialStore,
   refreshOAuthToken,
   withClaudeLogContext
-} from "./cli-m9pfb7h9.js";
+} from "./cli-0eky480v.js";
 import {
   __commonJS,
   __esm,
@@ -3730,6 +3731,120 @@ class RateLimitStore {
 }
 var rateLimitStore = new RateLimitStore;
 
+// src/proxy/oauthUsage.ts
+var OAUTH_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+var OAUTH_BETA_HEADER = "oauth-2025-04-20";
+var CACHE_TTL_MS_DEFAULT = 30000;
+var cacheByProfile = new Map;
+var inflightByProfile = new Map;
+var DEFAULT_KEY = "__default__";
+var WINDOW_TYPES = [
+  "five_hour",
+  "seven_day",
+  "seven_day_opus",
+  "seven_day_sonnet",
+  "seven_day_oauth_apps",
+  "seven_day_cowork",
+  "seven_day_omelette"
+];
+function parseIsoToMs(raw2) {
+  if (!raw2)
+    return null;
+  const ms = Date.parse(raw2);
+  return Number.isFinite(ms) ? ms : null;
+}
+function normalizeUtilization(raw2) {
+  if (typeof raw2 !== "number" || !Number.isFinite(raw2))
+    return null;
+  return Math.max(0, raw2 / 100);
+}
+function buildSnapshot(raw2) {
+  const windows = [];
+  for (const key of WINDOW_TYPES) {
+    const w = raw2[key];
+    if (!w)
+      continue;
+    const utilization = normalizeUtilization(w.utilization);
+    const resetsAt = parseIsoToMs(w.resets_at);
+    if (utilization === null && resetsAt === null)
+      continue;
+    windows.push({ type: key, utilization, resetsAt });
+  }
+  const extra = raw2.extra_usage;
+  const extraUsage = extra ? {
+    isEnabled: !!extra.is_enabled,
+    monthlyLimit: extra.monthly_limit ?? 0,
+    usedCredits: extra.used_credits ?? 0,
+    utilization: normalizeUtilization(extra.utilization ?? null),
+    currency: extra.currency ?? "USD"
+  } : null;
+  return { windows, extraUsage, fetchedAt: Date.now() };
+}
+async function readAccessToken(store) {
+  const creds = await store.read();
+  return creds?.claudeAiOauth?.accessToken ?? null;
+}
+async function callAnthropic(token, signal) {
+  const res = await fetch(OAUTH_USAGE_URL, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "anthropic-beta": OAUTH_BETA_HEADER,
+      Accept: "application/json"
+    },
+    signal: signal ?? AbortSignal.timeout(1e4)
+  });
+  if (!res.ok)
+    return { __status: res.status };
+  return await res.json();
+}
+async function fetchOAuthUsage(opts) {
+  const ttl = opts?.ttlMs ?? CACHE_TTL_MS_DEFAULT;
+  const cacheKey2 = opts?.profileId ?? DEFAULT_KEY;
+  if (!opts?.force) {
+    const cached = cacheByProfile.get(cacheKey2);
+    if (cached && Date.now() - cached.fetchedAt < ttl)
+      return cached;
+  }
+  const existing = inflightByProfile.get(cacheKey2);
+  if (existing)
+    return existing;
+  const store = opts?.store ?? createPlatformCredentialStore({ claudeConfigDir: opts?.claudeConfigDir });
+  const promise = (async () => {
+    try {
+      const token = await readAccessToken(store);
+      if (!token)
+        return null;
+      let result = await callAnthropic(token);
+      if ("__status" in result && result.__status === 401) {
+        claudeLog("oauth_usage.token_refresh_attempt", { profile: cacheKey2 });
+        const refreshed = await refreshOAuthToken(store);
+        if (!refreshed) {
+          claudeLog("oauth_usage.refresh_failed", { profile: cacheKey2 });
+          return null;
+        }
+        const newToken = await readAccessToken(store);
+        if (!newToken)
+          return null;
+        result = await callAnthropic(newToken);
+      }
+      if ("__status" in result) {
+        claudeLog("oauth_usage.upstream_error", { profile: cacheKey2, status: result.__status });
+        return null;
+      }
+      const snapshot = buildSnapshot(result);
+      cacheByProfile.set(cacheKey2, snapshot);
+      return snapshot;
+    } catch (err) {
+      claudeLog("oauth_usage.fetch_failed", { profile: cacheKey2, error: err instanceof Error ? err.message : String(err) });
+      return null;
+    } finally {
+      inflightByProfile.delete(cacheKey2);
+    }
+  })();
+  inflightByProfile.set(cacheKey2, promise);
+  return promise;
+}
+
 // src/proxy/types.ts
 var DEFAULT_PROXY_CONFIG = {
   port: 3456,
@@ -7993,13 +8108,20 @@ function ensureDefaultAgents(agents, mcpToolNames) {
     }
   }
 }
+function cloneAgentDefinition(def) {
+  return {
+    ...def,
+    ...def.tools ? { tools: [...def.tools] } : {},
+    ...def.disallowedTools ? { disallowedTools: [...def.disallowedTools] } : {}
+  };
+}
 function addCaseVariants(agents) {
   const baseNames = Object.keys(agents);
   for (const name of baseNames) {
     const def = agents[name];
     const titleCase = name.replace(/(^|-)(\w)/g, (_m, sep, ch) => sep + ch.toUpperCase());
     if (titleCase !== name && !agents[titleCase]) {
-      agents[titleCase] = def;
+      agents[titleCase] = cloneAgentDefinition(def);
     }
   }
   const ALIASES = {
@@ -8008,10 +8130,50 @@ function addCaseVariants(agents) {
   };
   for (const [alias, target] of Object.entries(ALIASES)) {
     if (!agents[alias] && agents[target]) {
-      agents[alias] = agents[target];
+      agents[alias] = cloneAgentDefinition(agents[target]);
     }
   }
 }
+function getNested(obj, ...keys) {
+  let cur = obj;
+  for (const key of keys) {
+    if (cur === null || typeof cur !== "object")
+      return;
+    cur = cur[key];
+  }
+  return cur;
+}
+function parseAgentNamesFromSchema(taskTool) {
+  const enumNames = getNested(taskTool, "input_schema", "properties", "subagent_type", "enum");
+  if (!Array.isArray(enumNames))
+    return [];
+  return enumNames.filter((n) => typeof n === "string");
+}
+function buildAgentDefinitionsFromTool(taskTool, mcpToolNames) {
+  const rawDescription = getNested(taskTool, "description");
+  const description = typeof rawDescription === "string" ? rawDescription : "";
+  const fromDescription = buildAgentDefinitions(description, mcpToolNames);
+  if (Object.keys(fromDescription).length > 0)
+    return fromDescription;
+  const names = parseAgentNamesFromSchema(taskTool);
+  if (names.length === 0)
+    return {};
+  const agents = {};
+  for (const name of names) {
+    if (agents[name])
+      continue;
+    const desc = `User-defined agent: ${name}`;
+    agents[name] = {
+      description: desc,
+      prompt: buildAgentPrompt(name, desc),
+      model: "inherit",
+      ...mcpToolNames?.length ? { tools: [...mcpToolNames] } : {}
+    };
+  }
+  ensureDefaultAgents(agents, mcpToolNames);
+  addCaseVariants(agents);
+  return agents;
+}
 function buildAgentPrompt(name, description) {
   return `You are the "${name}" agent. ${description}
 
@@ -8388,8 +8550,6 @@ let timer;
 let activeTab = 'requests';
 let activeLogFilter = 'all';
 
-
-
 function ms(v) {
   if (v == null) return '—';
   if (v < 1000) return v + 'ms';
@@ -8991,6 +9151,82 @@ function isExtraUsageRequiredError(errMsg) {
   const lower = errMsg.toLowerCase();
   return lower.includes("extra usage") && lower.includes("1m");
 }
+var STDERR_TAIL_MAX = 500;
+var RAW_TAIL_MAX = 300;
+function extractStderrTail(errMsg) {
+  const marker = "Subprocess stderr:";
+  const idx = errMsg.indexOf(marker);
+  if (idx < 0)
+    return;
+  const tail = errMsg.slice(idx + marker.length).trim();
+  if (!tail)
+    return;
+  return tail.length > STDERR_TAIL_MAX ? tail.slice(0, STDERR_TAIL_MAX) : tail;
+}
+function makeRawTail(errMsg) {
+  const marker = "Subprocess stderr:";
+  const idx = errMsg.indexOf(marker);
+  const head = (idx >= 0 ? errMsg.slice(0, idx) : errMsg).trim();
+  if (!head)
+    return;
+  return head.length > RAW_TAIL_MAX ? head.slice(0, RAW_TAIL_MAX) : head;
+}
+function extractSdkTermination(errMsg) {
+  const stderrTail = extractStderrTail(errMsg);
+  const haystack = `${errMsg}
+${stderrTail ?? ""}`;
+  const lower = haystack.toLowerCase();
+  if (lower.includes("reached maximum number of turns")) {
+    const m = haystack.match(/Reached maximum number of turns \((\d+)\)/i);
+    return {
+      reason: "max_turns",
+      ...m ? { turns: Number(m[1]) } : {},
+      ...stderrTail ? { stderrTail } : {}
+    };
+  }
+  if (lower.includes("exited with code") || lower.includes("process exited")) {
+    const m = haystack.match(/exited with code (\d+)/i);
+    return {
+      reason: "process_exit",
+      ...m ? { exitCode: Number(m[1]) } : {},
+      ...stderrTail ? { stderrTail } : {}
+    };
+  }
+  if (lower.includes("aborterror") || /\baborted\b/.test(lower)) {
+    return {
+      reason: "aborted",
+      ...stderrTail ? { stderrTail } : {}
+    };
+  }
+  const rawTail = makeRawTail(errMsg);
+  return {
+    reason: "unknown",
+    ...stderrTail ? { stderrTail } : {},
+    ...rawTail ? { rawTail } : {}
+  };
+}
+function formatSdkTermination(t, ctx) {
+  const parts = [`reason=${t.reason}`];
+  if (t.turns !== undefined)
+    parts.push(`turns=${t.turns}`);
+  if (t.exitCode !== undefined)
+    parts.push(`exit=${t.exitCode}`);
+  if (ctx.model)
+    parts.push(`model=${ctx.model}`);
+  if (ctx.requestSource)
+    parts.push(`source=${ctx.requestSource}`);
+  if (ctx.isResume !== undefined)
+    parts.push(`resume=${ctx.isResume}`);
+  if (ctx.hasDeferredTools !== undefined)
+    parts.push(`deferred=${ctx.hasDeferredTools}`);
+  if (ctx.sdkSessionId)
+    parts.push(`session=${ctx.sdkSessionId.slice(0, 8)}`);
+  if (t.rawTail)
+    parts.push(`raw=${JSON.stringify(t.rawTail)}`);
+  if (t.stderrTail)
+    parts.push(`stderr=${JSON.stringify(t.stderrTail)}`);
+  return `sdk_termination ${parts.join(" ")}`;
+}
 
 // src/proxy/models.ts
 import { exec as execCallback } from "child_process";
@@ -9216,7 +9452,7 @@ function parseDataUrlImage(url) {
 }
 function translateOpenAiContentToAnthropic(content) {
   if (typeof content === "string")
-    return content;
+    return [{ type: "text", text: content }];
   const parts = [];
   for (const part of content) {
     if (part.type === "text" && typeof part.text === "string") {
@@ -9235,9 +9471,6 @@ function translateOpenAiContentToAnthropic(content) {
       parts.push({ type: "text", text: "[Unsupported image_url omitted: only data URLs are currently supported]" });
     }
   }
-  if (parts.length === 1 && parts[0]?.type === "text") {
-    return parts[0].text;
-  }
   return parts;
 }
 function summarizeAnthropicContent(content) {
@@ -9246,6 +9479,32 @@ function summarizeAnthropicContent(content) {
   return content.map((part) => {
     if (part.type === "text")
       return part.text;
+    if (part.type === "thinking")
+      return `
+<think>
+` + part.thinking + `
+</think>
+`;
+    if (part.type === "tool_use")
+      return `
+<tool_call name="` + part.name + `">
+` + JSON.stringify(part.input) + `
+</tool_call>
+`;
+    if (part.type === "tool_result") {
+      if (typeof part.content === "string")
+        return `
+<tool_result>
+` + part.content + `
+</tool_result>
+`;
+      else
+        return part.content.map((c) => c.type === "text" ? `
+<tool_result>
+${c.text}
+</tool_result>
+` : "").join("");
+    }
     if (part.type === "image")
       return "[Image attached]";
     return "";
@@ -9257,18 +9516,89 @@ function translateOpenAiToAnthropic(body) {
     return null;
   const systemParts = [];
   const turns = [];
+  const tools = [];
   for (const msg of messages) {
     const text = extractOpenAiContent(msg.content ?? "");
     if (msg.role === "system") {
       if (text)
         systemParts.push(text);
+    } else if (msg.role === "tool") {
+      turns.push({
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: msg.tool_call_id ?? "",
+          content: translateOpenAiContentToAnthropic(msg.content ?? "")
+        }]
+      });
+    } else if (msg.role === "assistant") {
+      const msgContent = translateOpenAiContentToAnthropic(msg.content ?? "");
+      const content = [];
+      const toolCalls = msg.tool_calls ?? null;
+      const firstBlock = msgContent[0];
+      const endOfThink = firstBlock?.type === "text" && firstBlock.text.startsWith("<think>") ? firstBlock.text.indexOf("</think>") : -1;
+      if (firstBlock?.type === "text" && firstBlock.text.startsWith("<think>") && endOfThink !== -1) {
+        const thinking = firstBlock.text.substring("<think>".length, endOfThink);
+        let textStart = endOfThink + "</think>".length;
+        if (firstBlock.text[textStart] === `
+`)
+          textStart += 1;
+        const text2 = firstBlock.text.substring(textStart);
+        content.push({ type: "thinking", thinking });
+        if (text2.length)
+          content.push({ type: "text", text: text2 });
+        if (msgContent.length > 1)
+          content.push(...msgContent.slice(1));
+      } else {
+        content.push(...msgContent);
+      }
+      if (toolCalls) {
+        const calls = toolCalls.filter((call) => call.type === "function").map((call) => {
+          let input;
+          try {
+            const parsed = JSON.parse(call.function.arguments);
+            input = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : { __raw: call.function.arguments };
+          } catch {
+            input = { __raw: call.function.arguments };
+          }
+          return {
+            type: "tool_use",
+            id: call.id,
+            name: call.function.name,
+            input
+          };
+        });
+        content.push(...calls);
+      }
+      let finalContent = content;
+      if (content.length === 1 && content[0]?.type === "text") {
+        finalContent = content[0].text;
+      }
+      turns.push({
+        role: "assistant",
+        content: finalContent
+      });
     } else {
       turns.push({
-        role: msg.role === "assistant" ? "assistant" : "user",
+        role: "user",
         content: translateOpenAiContentToAnthropic(msg.content ?? "")
       });
     }
   }
+  const reqTools = body.tools ?? [];
+  for (const reqTool of reqTools) {
+    if (reqTool.type === "function") {
+      const tool = reqTool.function;
+      tools.push({
+        name: tool.name,
+        description: tool.description ?? "",
+        input_schema: tool.parameters,
+        strict: tool.strict
+      });
+    } else {
+      return null;
+    }
+  }
   let systemPrompt = systemParts.join(`
 `);
   let messagesToSend = turns;
@@ -9289,6 +9619,7 @@ ${historyBlock}` : historyBlock;
     model: body.model ?? "claude-sonnet-4-6",
     messages: messagesToSend,
     max_tokens: body.max_tokens ?? body.max_completion_tokens ?? 8192,
+    tools,
     stream: body.stream ?? false
   };
   if (systemPrompt)
@@ -9302,10 +9633,23 @@ ${historyBlock}` : historyBlock;
 function toFinishReason(stopReason) {
   if (stopReason === "max_tokens")
     return "length";
+  else if (stopReason === "tool_use")
+    return "tool_calls";
   return "stop";
 }
-function translateAnthropicToOpenAi(response, completionId, model, created) {
-  const content = (response.content ?? []).filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
+function translateAnthropicToOpenAi(response, completionId, model, created, options) {
+  const contentBlocks = response.content ?? [];
+  const content = contentBlocks.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
+  const toolCalls = contentBlocks.filter((b) => b.type === "tool_use").map((b) => ({
+    type: "function",
+    id: b.id,
+    function: {
+      name: b.name,
+      arguments: JSON.stringify(b.input)
+    }
+  }));
+  const thinkingPassthrough = options?.thinkingPassthrough;
+  const thinking = thinkingPassthrough !== false ? contentBlocks.filter((b) => b.type === "thinking").map((b) => b.thinking).join("") : "";
   const promptTokens = response.usage?.input_tokens ?? 0;
   const completionTokens = response.usage?.output_tokens ?? 0;
   return {
@@ -9315,7 +9659,12 @@ function translateAnthropicToOpenAi(response, completionId, model, created) {
     model,
     choices: [{
       index: 0,
-      message: { role: "assistant", content },
+      message: {
+        role: "assistant",
+        content: content || null,
+        reasoning_content: thinking.length ? thinking : undefined,
+        tool_calls: toolCalls.length ? toolCalls : undefined
+      },
       finish_reason: toFinishReason(response.stop_reason)
     }],
     usage: {
@@ -9325,7 +9674,16 @@ function translateAnthropicToOpenAi(response, completionId, model, created) {
     }
   };
 }
-function translateAnthropicSseEvent(event, completionId, model, created) {
+function createSseTranslator(ctx) {
+  let toolCallIndex = -1;
+  return (event) => {
+    if (event.type === "content_block_start" && event.content_block?.type === "tool_use" && typeof event.content_block.name === "string") {
+      toolCallIndex++;
+    }
+    return translateAnthropicSseEvent(event, ctx.completionId, ctx.model, ctx.created, toolCallIndex, ctx.thinkingPassthrough);
+  };
+}
+function translateAnthropicSseEvent(event, completionId, model, created, toolCallNum, thinkingPassthrough) {
   if (event.type === "message_start") {
     return {
       id: completionId,
@@ -9344,6 +9702,69 @@ function translateAnthropicSseEvent(event, completionId, model, created) {
       choices: [{ index: 0, delta: { content: event.delta.text }, finish_reason: null }]
     };
   }
+  if (event.type === "content_block_start" && event.content_block?.type === "tool_use" && typeof event.content_block?.name === "string") {
+    return {
+      id: completionId,
+      object: "chat.completion.chunk",
+      created,
+      model,
+      choices: [{
+        index: 0,
+        delta: {
+          tool_calls: [{
+            type: "function",
+            index: toolCallNum,
+            id: event.content_block?.id,
+            function: {
+              name: event.content_block.name,
+              arguments: ""
+            }
+          }]
+        },
+        finish_reason: null
+      }]
+    };
+  }
+  if (event.type === "content_block_delta" && event.delta?.type === "input_json_delta" && typeof event.delta?.partial_json === "string") {
+    return {
+      id: completionId,
+      object: "chat.completion.chunk",
+      created,
+      model,
+      choices: [{
+        index: 0,
+        delta: {
+          tool_calls: [{
+            index: toolCallNum,
+            function: {
+              arguments: event.delta.partial_json
+            }
+          }]
+        },
+        finish_reason: null
+      }]
+    };
+  }
+  if (event.type === "content_block_delta" && event.delta?.type === "thinking_delta") {
+    if (thinkingPassthrough === false) {
+      return null;
+    }
+    if (typeof event.delta?.thinking === "string") {
+      return {
+        id: completionId,
+        object: "chat.completion.chunk",
+        created,
+        model,
+        choices: [{
+          index: 0,
+          delta: {
+            reasoning_content: event.delta?.thinking
+          },
+          finish_reason: null
+        }]
+      };
+    }
+  }
   if (event.type === "message_delta" && event.delta?.stop_reason) {
     return {
       id: completionId,
@@ -9660,7 +10081,11 @@ var CLAUDE_CODE_ONLY_TOOLS = [
   "ExitPlanMode",
   "EnterWorktree",
   "ExitWorktree",
+  "Monitor",
   "NotebookEdit",
+  "PushNotification",
+  "RemoteTrigger",
+  "ScheduleWakeup",
   "TodoWrite",
   "AskUserQuestion",
   "Skill",
@@ -9695,8 +10120,8 @@ var openCodeTransforms = [
       let sdkAgents = {};
       if (Array.isArray(body.tools)) {
         const taskTool = body.tools.find((t) => t.name === "task" || t.name === "Task");
-        if (taskTool?.description) {
-          sdkAgents = buildAgentDefinitions(taskTool.description, [...allowedMcpTools]);
+        if (taskTool) {
+          sdkAgents = buildAgentDefinitionsFromTool(taskTool, [...allowedMcpTools]);
         }
       }
       let sdkHooks = undefined;
@@ -9802,9 +10227,9 @@ var openCodeAdapter = {
     if (!Array.isArray(body.tools))
       return {};
     const taskTool = body.tools.find((t) => t.name === "task" || t.name === "Task");
-    if (!taskTool?.description)
+    if (!taskTool)
       return {};
-    return buildAgentDefinitions(taskTool.description, [...mcpToolNames]);
+    return buildAgentDefinitionsFromTool(taskTool, [...mcpToolNames]);
   },
   buildSdkHooks(body, sdkAgents) {
     const validAgentNames = Object.keys(sdkAgents);
@@ -11962,7 +12387,7 @@ var emitWarning = (msg, type, code, fn) => {
 var AC = globalThis.AbortController;
 var AS = globalThis.AbortSignal;
 if (typeof AC === "undefined") {
-  AS = class AbortSignal {
+  AS = class AbortSignal2 {
     onabort;
     _onabort = [];
     reason;
@@ -16202,7 +16627,7 @@ function createOpencodeMcpServer() {
 // src/proxy/query.ts
 function computePassthroughMaxTurns(resumeSessionId, hasDeferredTools, advisorModel) {
   const hasResume = !!resumeSessionId;
-  const base = hasResume && hasDeferredTools ? 4 : hasResume || hasDeferredTools ? 3 : 2;
+  const base = hasResume && hasDeferredTools ? 4 : 3;
   const advisorBump = advisorModel ? 3 : 0;
   return base + advisorBump;
 }
@@ -17698,7 +18123,7 @@ function createProxyServer(config = {}) {
               });
               return {
                 decision: "block",
-                reason: "Forwarding to client for execution"
+                reason: "This tool call has been forwarded to the client for execution. " + "The result will be delivered in a future turn. " + "Do not retry, do not call additional tools, and do not generate further text — end your turn now."
               };
             }]
           }]
@@ -18119,6 +18544,7 @@ Subprocess stderr: ${stderrOutput}`;
               sdkUuidMap.push(null);
             let messageStartEmitted = false;
             let lastUsage;
+            const streamedToolUseIds = new Set;
             try {
               let currentSessionId;
               const MAX_RATE_LIMIT_RETRIES = 2;
@@ -18309,7 +18735,6 @@ Subprocess stderr: ${stderrOutput}`;
               const skipBlockIndices = new Set;
               const taskToolBlockIndices = new Set;
               const taskToolJsonBuffer = new Map;
-              const streamedToolUseIds = new Set;
               let nextClientBlockIndex = 0;
               const sdkToClientIndex = new Map;
               try {
@@ -18672,6 +19097,127 @@ Subprocess stderr: ${stderrOutput}`;
               });
               const streamErr = classifyError(errMsg);
               claudeLog("proxy.anthropic.error", { error: errMsg, classified: streamErr.type });
+              const sdkTerm = extractSdkTermination(errMsg);
+              const canRecoverAsToolUse = sdkTerm.reason === "max_turns" && passthrough && capturedToolUses.length > 0 && messageStartEmitted;
+              if (canRecoverAsToolUse) {
+                diagnosticLog2.session(`${requestMeta.requestId} sdk_termination_recovered ${formatSdkTermination(sdkTerm, {
+                  model,
+                  requestSource,
+                  isResume,
+                  hasDeferredTools,
+                  sdkSessionId: resumeSessionId
+                })} captured=${capturedToolUses.length}`, requestMeta.requestId);
+                const unseenToolUses = capturedToolUses.filter((tu) => !streamedToolUseIds.has(tu.id));
+                for (let i = 0;i < unseenToolUses.length; i++) {
+                  const tu = unseenToolUses[i];
+                  const blockIndex = eventsForwarded + i;
+                  safeEnqueue(encoder.encode(`event: content_block_start
+data: ${JSON.stringify({
+                    type: "content_block_start",
+                    index: blockIndex,
+                    content_block: { type: "tool_use", id: tu.id, name: tu.name, input: {} }
+                  })}
+
+`), "recover_tool_block_start");
+                  safeEnqueue(encoder.encode(`event: content_block_delta
+data: ${JSON.stringify({
+                    type: "content_block_delta",
+                    index: blockIndex,
+                    delta: { type: "input_json_delta", partial_json: JSON.stringify(tu.input) }
+                  })}
+
+`), "recover_tool_input");
+                  safeEnqueue(encoder.encode(`event: content_block_stop
+data: ${JSON.stringify({
+                    type: "content_block_stop",
+                    index: blockIndex
+                  })}
+
+`), "recover_tool_block_stop");
+                }
+                safeEnqueue(encoder.encode(`event: message_delta
+data: ${JSON.stringify({
+                  type: "message_delta",
+                  delta: { stop_reason: "tool_use", stop_sequence: null },
+                  usage: { output_tokens: 0 }
+                })}
+
+`), "recover_message_delta");
+                safeEnqueue(encoder.encode(`event: message_stop
+data: {"type":"message_stop"}
+
+`), "recover_message_stop");
+                const recoverTotalMs = Date.now() - requestStartAt;
+                const recoverQueueWaitMs = requestMeta.queueStartedAt - requestMeta.queueEnteredAt;
+                telemetryStore2.record({
+                  requestId: requestMeta.requestId,
+                  timestamp: Date.now(),
+                  adapter: adapter.name,
+                  requestSource,
+                  model,
+                  requestModel: body.model || undefined,
+                  mode: "stream",
+                  isResume,
+                  isPassthrough: passthrough,
+                  hasDeferredTools,
+                  deferredToolCount: hasDeferredTools ? deferredToolCount : undefined,
+                  toolCount,
+                  lineageType,
+                  messageCount: allMessages.length,
+                  sdkSessionId: resumeSessionId,
+                  status: 200,
+                  queueWaitMs: recoverQueueWaitMs,
+                  proxyOverheadMs: upstreamStartAt - requestStartAt - recoverQueueWaitMs,
+                  ttfbMs: firstChunkAt ? firstChunkAt - upstreamStartAt : null,
+                  upstreamDurationMs: Date.now() - upstreamStartAt,
+                  totalDurationMs: recoverTotalMs,
+                  contentBlocks: eventsForwarded + unseenToolUses.length,
+                  textEvents: textEventsForwarded,
+                  error: null
+                });
+                if (!streamClosed) {
+                  try {
+                    controller.close();
+                  } catch {}
+                  streamClosed = true;
+                }
+                return;
+              }
+              diagnosticLog2.error(`${requestMeta.requestId} ${formatSdkTermination(sdkTerm, {
+                model,
+                requestSource,
+                isResume,
+                hasDeferredTools,
+                sdkSessionId: resumeSessionId
+              })}`, requestMeta.requestId);
+              const streamErrTotalMs = Date.now() - requestStartAt;
+              const streamErrQueueWaitMs = requestMeta.queueStartedAt - requestMeta.queueEnteredAt;
+              telemetryStore2.record({
+                requestId: requestMeta.requestId,
+                timestamp: Date.now(),
+                adapter: adapter.name,
+                requestSource,
+                model,
+                requestModel: body.model || undefined,
+                mode: "stream",
+                isResume,
+                isPassthrough: passthrough,
+                hasDeferredTools,
+                deferredToolCount: hasDeferredTools ? deferredToolCount : undefined,
+                toolCount,
+                lineageType,
+                messageCount: allMessages.length,
+                sdkSessionId: resumeSessionId,
+                status: streamErr.status,
+                queueWaitMs: streamErrQueueWaitMs,
+                proxyOverheadMs: upstreamStartAt - requestStartAt - streamErrQueueWaitMs,
+                ttfbMs: firstChunkAt ? firstChunkAt - upstreamStartAt : null,
+                upstreamDurationMs: Date.now() - upstreamStartAt,
+                totalDurationMs: streamErrTotalMs,
+                contentBlocks: eventsForwarded,
+                textEvents: textEventsForwarded,
+                error: streamErr.type
+              });
               if (messageStartEmitted) {
                 safeEnqueue(encoder.encode(`event: message_delta
 data: ${JSON.stringify({
@@ -18719,6 +19265,10 @@ data: ${JSON.stringify({
         });
         const classified = classifyError(errMsg);
         claudeLog("proxy.error", { error: errMsg, classified: classified.type });
+        const sdkTerm = extractSdkTermination(errMsg);
+        diagnosticLog2.error(`${requestMeta.requestId} ${formatSdkTermination(sdkTerm, {
+          requestSource: c.req.header("x-meridian-source")?.slice(0, 64) || undefined
+        })}`, requestMeta.requestId);
         const errorQueueWaitMs = requestMeta.queueStartedAt - requestMeta.queueEnteredAt;
         telemetryStore2.record({
           requestId: requestMeta.requestId,
@@ -18860,7 +19410,7 @@ data: ${JSON.stringify({
     });
   });
   app.get("/profiles", async (c) => {
-    const { profilePageHtml } = await import("./profilePage-77z05e0r.js");
+    const { profilePageHtml } = await import("./profilePage-k0faye28.js");
     return c.html(profilePageHtml);
   });
   app.post("/profiles/active", async (c) => {
@@ -18952,9 +19502,14 @@ 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 { getFeaturesForAdapter: getFeaturesForAdapter2 } = (init_sdkFeatures(), __toCommonJS(exports_sdkFeatures));
+    const adapter = detectAdapter(c);
+    const sdkFeatures = getFeaturesForAdapter2(adapter.name);
     if (!anthropicBody.stream) {
       const anthropicRes = await internalRes.json();
-      return c.json(translateAnthropicToOpenAi(anthropicRes, completionId, model, created));
+      return c.json(translateAnthropicToOpenAi(anthropicRes, completionId, model, created, {
+        thinkingPassthrough: sdkFeatures.thinkingPassthrough
+      }));
     }
     const encoder = new TextEncoder;
     const readable = new ReadableStream({
@@ -18967,6 +19522,7 @@ data: ${JSON.stringify({
         const decoder = new TextDecoder;
         let buffer = "";
         let streamError = null;
+        const translate = createSseTranslator({ completionId, model, created, thinkingPassthrough: sdkFeatures.thinkingPassthrough });
         try {
           while (true) {
             const { done, value } = await reader.read();
@@ -18990,7 +19546,7 @@ data: ${JSON.stringify({
               }
               if (typeof event.type !== "string")
                 continue;
-              const chunk = translateAnthropicSseEvent(event, completionId, model, created);
+              const chunk = translate(event);
               if (chunk)
                 controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
 
@@ -19021,11 +19577,21 @@ data: ${JSON.stringify({
     const isMax = authStatus?.subscriptionType === "max";
     return c.json({ object: "list", data: buildModelList(isMax) });
   });
-  app.get("/v1/usage/quota", (c) => {
-    const entries = rateLimitStore.getAll().filter((entry) => entry.rateLimitType !== undefined);
-    return c.json({
-      buckets: entries.map((entry) => ({
-        type: entry.rateLimitType,
+  app.get("/v1/usage/quota", async (c) => {
+    const sdkEntries = rateLimitStore.getAll().filter((entry) => entry.rateLimitType !== undefined);
+    const requestedProfile = c.req.query("profile");
+    const profilesList = getEffectiveProfiles(finalConfig.profiles);
+    const targetProfileId = requestedProfile || getActiveProfileId() || finalConfig.defaultProfile || profilesList[0]?.id || null;
+    const targetProfile = targetProfileId ? profilesList.find((p) => p.id === targetProfileId) : undefined;
+    const oauth = await fetchOAuthUsage({
+      profileId: targetProfileId ?? undefined,
+      claudeConfigDir: targetProfile?.claudeConfigDir
+    });
+    const byType = new Map;
+    for (const entry of sdkEntries) {
+      const type = entry.rateLimitType;
+      byType.set(type, {
+        type,
         status: entry.status,
         utilization: entry.utilization ?? null,
         resetsAt: entry.resetsAt ?? null,
@@ -19035,7 +19601,85 @@ data: ${JSON.stringify({
         overageDisabledReason: entry.overageDisabledReason ?? null,
         surpassedThreshold: entry.surpassedThreshold ?? null,
         observedAt: entry.observedAt
-      })),
+      });
+    }
+    if (oauth) {
+      for (const w of oauth.windows) {
+        const existing = byType.get(w.type);
+        const status = (w.utilization ?? 0) >= 1 ? "rejected" : (w.utilization ?? 0) >= 0.8 ? "allowed_warning" : "allowed";
+        byType.set(w.type, {
+          type: w.type,
+          status: existing?.status === "rejected" ? "rejected" : status,
+          utilization: w.utilization ?? existing?.utilization ?? null,
+          resetsAt: w.resetsAt ?? existing?.resetsAt ?? null,
+          isUsingOverage: existing?.isUsingOverage ?? false,
+          overageStatus: existing?.overageStatus ?? null,
+          overageResetsAt: existing?.overageResetsAt ?? null,
+          overageDisabledReason: existing?.overageDisabledReason ?? null,
+          surpassedThreshold: existing?.surpassedThreshold ?? null,
+          observedAt: oauth.fetchedAt
+        });
+      }
+    }
+    return c.json({
+      profile: targetProfileId ?? null,
+      buckets: Array.from(byType.values()),
+      extraUsage: oauth?.extraUsage ?? null,
+      sources: {
+        oauth: oauth ? { fetchedAt: oauth.fetchedAt } : null,
+        sdk: { entryCount: sdkEntries.length }
+      },
+      asOf: Date.now()
+    });
+  });
+  app.get("/v1/usage/quota/all", async (c) => {
+    const profilesList = getEffectiveProfiles(finalConfig.profiles);
+    const activeId = getActiveProfileId() || finalConfig.defaultProfile || profilesList[0]?.id || null;
+    if (profilesList.length === 0) {
+      const oauth = await fetchOAuthUsage({});
+      return c.json({
+        profiles: [{
+          id: "default",
+          isActive: true,
+          windows: oauth?.windows ?? [],
+          extraUsage: oauth?.extraUsage ?? null,
+          fetchedAt: oauth?.fetchedAt ?? null,
+          error: oauth ? null : "no_token"
+        }],
+        activeProfile: "default",
+        asOf: Date.now()
+      });
+    }
+    const results = await Promise.all(profilesList.map(async (p) => {
+      const type = p.type ?? "claude-max";
+      if (type !== "claude-max") {
+        return {
+          id: p.id,
+          isActive: p.id === activeId,
+          type,
+          windows: [],
+          extraUsage: null,
+          fetchedAt: null,
+          error: "not_oauth"
+        };
+      }
+      const oauth = await fetchOAuthUsage({
+        profileId: p.id,
+        claudeConfigDir: p.claudeConfigDir
+      });
+      return {
+        id: p.id,
+        isActive: p.id === activeId,
+        type,
+        windows: oauth?.windows ?? [],
+        extraUsage: oauth?.extraUsage ?? null,
+        fetchedAt: oauth?.fetchedAt ?? null,
+        error: oauth ? null : "no_token"
+      };
+    }));
+    return c.json({
+      profiles: results,
+      activeProfile: activeId,
       asOf: Date.now()
     });
   });