@rynfar/meridian 1.40.0 → 1.41.1

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

@@ -25,9 +25,10 @@ import {
 } from "./cli-rtab0qa6.js";
 import {
   claudeLog,
+  createPlatformCredentialStore,
   refreshOAuthToken,
   withClaudeLogContext
-} from "./cli-m9pfb7h9.js";
+} from "./cli-e289rj3k.js";
 import {
   __commonJS,
   __esm,
@@ -1178,13 +1179,13 @@ __export(exports_sdkFeatures, {
   getAllFeatureConfigs: () => getAllFeatureConfigs
 });
 import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2, renameSync as renameSync2 } from "node:fs";
-import { join as join6 } from "node:path";
-import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
+import { homedir as homedir3 } from "node:os";
 function getConfigPath() {
-  const dir = join6(homedir4(), ".config", "meridian");
+  const dir = join5(homedir3(), ".config", "meridian");
   if (!existsSync5(dir))
     mkdirSync2(dir, { recursive: true });
-  return join6(dir, "sdk-features.json");
+  return join5(dir, "sdk-features.json");
 }
 function readConfig() {
   const now = Date.now();
@@ -1282,7 +1283,7 @@ function resetAdapterFeatures(adapterName) {
 var DEFAULT_FEATURES, ADAPTER_DEFAULTS, cachedConfig = null, lastReadTime = 0, CACHE_TTL_MS = 5000, VALID_CLAUDE_MD_VALUES, VALID_THINKING_VALUES;
 var init_sdkFeatures = __esm(() => {
   DEFAULT_FEATURES = {
-    codeSystemPrompt: false,
+    codeSystemPrompt: true,
     clientSystemPrompt: true,
     claudeMd: "off",
     memory: false,
@@ -1295,7 +1296,11 @@ var init_sdkFeatures = __esm(() => {
     sdkDebug: false,
     additionalDirectories: ""
   };
-  ADAPTER_DEFAULTS = {};
+  ADAPTER_DEFAULTS = {
+    passthrough: {
+      codeSystemPrompt: false
+    }
+  };
   VALID_CLAUDE_MD_VALUES = new Set(["off", "project", "full"]);
   VALID_THINKING_VALUES = new Set(["adaptive", "enabled", "disabled"]);
 });
@@ -3702,8 +3707,8 @@ var serve = (options, listeningListener) => {
 };
 
 // src/proxy/server.ts
-import { homedir as homedir5 } from "node:os";
-import { join as join7 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { join as join6 } from "node:path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
 // src/proxy/rateLimitStore.ts
@@ -3730,6 +3735,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 +8112,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 +8134,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 +8554,6 @@ let timer;
 let activeTab = 'requests';
 let activeLogFilter = 'all';
 
-
-
 function ms(v) {
   if (v == null) return '—';
   if (v < 1000) return v + 'ms';
@@ -8991,14 +9155,91 @@ 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";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync2, statSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { join as join2, dirname as dirname2 } from "path";
 import { promisify } from "util";
 var exec = promisify(execCallback);
+var STUB_SIZE_THRESHOLD = 4096;
 var CANONICAL_OPUS_MODEL = "claude-opus-4-7";
 var CANONICAL_SONNET_MODEL = "claude-sonnet-4-6";
 var CANONICAL_HAIKU_MODEL = "claude-haiku-4-5";
@@ -9138,40 +9379,92 @@ async function getClaudeAuthStatusAsync(profileId, envOverrides) {
 }
 var cachedClaudePath = null;
 var cachedClaudePathPromise = null;
+var DEFAULT_DEPS = {
+  existsSync: existsSync2,
+  statSync: (p) => statSync(p),
+  exec,
+  resolvePackage: (specifier) => fileURLToPath2(import.meta.resolve(specifier)),
+  envGet: (name) => process.env[name],
+  platform: process.platform,
+  arch: process.arch,
+  isBun: typeof process.versions.bun !== "undefined"
+};
+function tryEnvOverride(deps) {
+  const explicit = deps.envGet("MERIDIAN_CLAUDE_PATH");
+  if (!explicit)
+    return null;
+  return deps.existsSync(explicit) ? explicit : null;
+}
+function tryBundledBinary(deps) {
+  try {
+    const pkgPath = deps.resolvePackage("@anthropic-ai/claude-code/package.json");
+    const bundled = join2(dirname2(pkgPath), "bin", "claude.exe");
+    if (!deps.existsSync(bundled))
+      return null;
+    const size = deps.statSync(bundled).size;
+    if (size <= STUB_SIZE_THRESHOLD)
+      return null;
+    return bundled;
+  } catch {
+    return null;
+  }
+}
+function tryPlatformPackage(deps) {
+  const binName = deps.platform === "win32" ? "claude.exe" : "claude";
+  const candidates = [`@anthropic-ai/claude-code-${deps.platform}-${deps.arch}`];
+  if (deps.platform === "linux") {
+    candidates.push(`@anthropic-ai/claude-code-${deps.platform}-${deps.arch}-musl`);
+  }
+  for (const pkg of candidates) {
+    try {
+      const pkgJson = deps.resolvePackage(`${pkg}/package.json`);
+      const candidate = join2(dirname2(pkgJson), binName);
+      if (deps.existsSync(candidate))
+        return candidate;
+    } catch {}
+  }
+  return null;
+}
+async function tryPathLookup(deps) {
+  const cmd = deps.platform === "win32" ? "where claude" : "which claude";
+  try {
+    const { stdout } = await deps.exec(cmd);
+    const candidates = stdout.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+    for (const candidate of candidates) {
+      if (deps.platform === "win32" && candidate.startsWith("/"))
+        continue;
+      if (deps.existsSync(candidate))
+        return candidate;
+    }
+  } catch {}
+  return null;
+}
+function tryLegacySdkCliJs(deps) {
+  if (!deps.isBun)
+    return null;
+  try {
+    const sdkPath = deps.resolvePackage("@anthropic-ai/claude-agent-sdk");
+    const cliJs = join2(dirname2(sdkPath), "cli.js");
+    return deps.existsSync(cliJs) ? cliJs : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveClaudeExecutable(deps = DEFAULT_DEPS) {
+  return tryEnvOverride(deps) ?? tryBundledBinary(deps) ?? tryPlatformPackage(deps) ?? await tryPathLookup(deps) ?? tryLegacySdkCliJs(deps);
+}
 async function resolveClaudeExecutableAsync() {
   if (cachedClaudePath)
     return cachedClaudePath;
   if (cachedClaudePathPromise)
     return cachedClaudePathPromise;
   cachedClaudePathPromise = (async () => {
-    const runningUnderBun = typeof process.versions.bun !== "undefined";
-    try {
-      const pkgPath = fileURLToPath2(import.meta.resolve("@anthropic-ai/claude-code/package.json"));
-      const bundledBinary = join2(dirname2(pkgPath), "bin", "claude.exe");
-      if (existsSync2(bundledBinary)) {
-        cachedClaudePath = bundledBinary;
-        return bundledBinary;
-      }
-    } catch {}
-    try {
-      const { stdout } = await exec("which claude");
-      const claudePath = stdout.trim();
-      if (claudePath && existsSync2(claudePath)) {
-        cachedClaudePath = claudePath;
-        return claudePath;
-      }
-    } catch {}
-    if (runningUnderBun) {
-      try {
-        const sdkPath = fileURLToPath2(import.meta.resolve("@anthropic-ai/claude-agent-sdk"));
-        const sdkCliJs = join2(dirname2(sdkPath), "cli.js");
-        if (existsSync2(sdkCliJs)) {
-          cachedClaudePath = sdkCliJs;
-          return sdkCliJs;
-        }
-      } catch {}
+    const resolved = await resolveClaudeExecutable();
+    if (resolved) {
+      cachedClaudePath = resolved;
+      return resolved;
     }
-    throw new Error("Could not find Claude Code executable. Install via: npm install -g @anthropic-ai/claude-code");
+    throw new Error("Could not find Claude Code executable. Install via: npm install -g @anthropic-ai/claude-code, " + "or set MERIDIAN_CLAUDE_PATH=/path/to/claude to point at an existing binary.");
   })();
   try {
     return await cachedClaudePathPromise;
@@ -9216,7 +9509,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 +9528,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 +9536,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 +9573,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 +9676,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 +9690,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 +9716,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 +9731,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 +9759,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 +10138,11 @@ var CLAUDE_CODE_ONLY_TOOLS = [
   "ExitPlanMode",
   "EnterWorktree",
   "ExitWorktree",
+  "Monitor",
   "NotebookEdit",
+  "PushNotification",
+  "RemoteTrigger",
+  "ScheduleWakeup",
   "TodoWrite",
   "AskUserQuestion",
   "Skill",
@@ -9695,8 +10177,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 +10284,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);
@@ -9860,6 +10342,10 @@ var DROID_ALLOWED_MCP_TOOLS = [
   `mcp__${DROID_MCP_SERVER_NAME}__glob`,
   `mcp__${DROID_MCP_SERVER_NAME}__grep`
 ];
+function resolveDroidPassthrough() {
+  const envVal = process.env.MERIDIAN_PASSTHROUGH ?? process.env.CLAUDE_PROXY_PASSTHROUGH;
+  return envVal === "1" || envVal === "true" || envVal === "yes";
+}
 var droidTransforms = [
   {
     name: "droid-core",
@@ -9871,7 +10357,7 @@ var droidTransforms = [
         incompatibleTools: CLAUDE_CODE_ONLY_TOOLS,
         allowedMcpTools: DROID_ALLOWED_MCP_TOOLS,
         sdkAgents: {},
-        passthrough: false,
+        passthrough: resolveDroidPassthrough(),
         leaksCwdViaSystemReminder: true
       };
     }
@@ -9942,7 +10428,8 @@ var droidAdapter = {
     return "";
   },
   usesPassthrough() {
-    return false;
+    const envVal = process.env.MERIDIAN_PASSTHROUGH ?? process.env.CLAUDE_PROXY_PASSTHROUGH;
+    return envVal === "1" || envVal === "true" || envVal === "yes";
   }
 };
 
@@ -10504,10 +10991,6 @@ function detectAdapter(c) {
   return defaultAdapter;
 }
 
-// src/proxy/query.ts
-import { join as join3 } from "node:path";
-import { homedir as homedir2 } from "node:os";
-
 // src/mcpTools.ts
 import { createSdkMcpServer as createSdkMcpServer2, tool } from "@anthropic-ai/claude-agent-sdk";
 import * as fs from "node:fs/promises";
@@ -11962,7 +12445,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;
@@ -16200,9 +16683,16 @@ function createOpencodeMcpServer() {
 }
 
 // src/proxy/query.ts
+function stripConfigDir(env2) {
+  if (!("CLAUDE_CONFIG_DIR" in env2))
+    return env2;
+  const out = { ...env2 };
+  delete out.CLAUDE_CONFIG_DIR;
+  return out;
+}
 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;
 }
@@ -16304,10 +16794,9 @@ function buildQueryOptions(ctx) {
       } : {},
       ...onStderr ? { stderr: onStderr } : {},
       env: {
-        ...cleanEnv,
+        ...sharedMemory ? stripConfigDir(cleanEnv) : cleanEnv,
         ENABLE_TOOL_SEARCH: hasDeferredTools ? "true" : "false",
         ...passthrough ? { ENABLE_CLAUDEAI_MCP_SERVERS: "false" } : {},
-        ...sharedMemory ? { CLAUDE_CONFIG_DIR: join3(homedir2(), ".claude") } : {},
         ...process.getuid?.() === 0 ? { IS_SANDBOX: "1" } : {}
       },
       ...Object.keys(sdkAgents).length > 0 ? { agents: sdkAgents } : {},
@@ -16342,7 +16831,7 @@ function getAdapterTransforms(adapterName) {
 
 // src/proxy/plugins/loader.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync2, existsSync as existsSync3 } from "fs";
-import { join as join4, isAbsolute as isAbsolute2, extname } from "path";
+import { join as join3, isAbsolute as isAbsolute2, extname } from "path";
 
 // src/proxy/plugins/validation.ts
 var KNOWN_ADAPTERS = ["opencode", "crush", "droid", "pi", "forgecode", "passthrough"];
@@ -16426,7 +16915,7 @@ async function loadPlugins(pluginDir, configPath) {
   const loaded = [];
   const seenNames = new Set;
   for (const { filename, entry } of ordered) {
-    const filePath = isAbsolute2(filename) ? filename : join4(pluginDir, filename);
+    const filePath = isAbsolute2(filename) ? filename : join3(pluginDir, filename);
     if (entry && !entry.enabled) {
       loaded.push({
         name: filename,
@@ -16802,12 +17291,12 @@ import {
   openSync,
   readFileSync as readFileSync3,
   renameSync,
-  statSync,
+  statSync as statSync2,
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join5 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join4 } from "node:path";
 var DEFAULT_MAX_STORED_SESSIONS = 1e4;
 var STALE_LOCK_THRESHOLD_MS = 30000;
 function getMaxStoredSessions() {
@@ -16831,7 +17320,7 @@ function acquireLock(lockPath) {
       return false;
     }
     try {
-      const stat = statSync(lockPath);
+      const stat = statSync2(lockPath);
       if (Date.now() - stat.mtimeMs > STALE_LOCK_THRESHOLD_MS) {
         unlinkSync(lockPath);
         const fd = openSync(lockPath, "wx");
@@ -16858,11 +17347,11 @@ function getStorePath() {
   if (!existsSync4(dir)) {
     mkdirSync(dir, { recursive: true });
   }
-  return join5(dir, "sessions.json");
+  return join4(dir, "sessions.json");
 }
 function getDefaultCacheDir() {
-  const newDir = join5(homedir3(), ".cache", "meridian");
-  const oldDir = join5(homedir3(), ".cache", "opencode-claude-max-proxy");
+  const newDir = join4(homedir2(), ".cache", "meridian");
+  const oldDir = join4(homedir2(), ".cache", "opencode-claude-max-proxy");
   if (existsSync4(newDir))
     return newDir;
   if (existsSync4(oldDir)) {
@@ -17380,8 +17869,8 @@ function createProxyServer(config = {}) {
   const sessionDiscoveredTools = new Map;
   const sessionToolCache = new Map;
   const sessionMcpCache = new LRUMap(getMaxSessionsLimit());
-  const pluginDir = finalConfig.pluginDir ?? join7(homedir5(), ".config", "meridian", "plugins");
-  const pluginConfigPath = finalConfig.pluginConfigPath ?? join7(homedir5(), ".config", "meridian", "plugins.json");
+  const pluginDir = finalConfig.pluginDir ?? join6(homedir4(), ".config", "meridian", "plugins");
+  const pluginConfigPath = finalConfig.pluginConfigPath ?? join6(homedir4(), ".config", "meridian", "plugins.json");
   let loadedPlugins = [];
   let pluginTransforms = [];
   const app = new Hono2;
@@ -17447,6 +17936,9 @@ function createProxyServer(config = {}) {
         if (!Array.isArray(body.messages)) {
           return c.json({ type: "error", error: { type: "invalid_request_error", message: "messages: Field required" } }, 400);
         }
+        if (body.messages.length === 0) {
+          return c.json({ type: "error", error: { type: "invalid_request_error", message: "messages: Cannot be empty — at least one message is required" } }, 400);
+        }
         const profile = resolveProfile(finalConfig.profiles, finalConfig.defaultProfile, c.req.header("x-meridian-profile") || undefined);
         const authStatus = await getClaudeAuthStatusAsync(profile.id !== "default" ? profile.id : undefined, Object.keys(profile.env).length > 0 ? profile.env : undefined);
         const agentMode = c.req.header("x-opencode-agent-mode") ?? null;
@@ -17455,10 +17947,11 @@ function createProxyServer(config = {}) {
         const workingDirectory = (process.env.MERIDIAN_WORKDIR ?? process.env.CLAUDE_PROXY_WORKDIR) || adapter.extractWorkingDirectory(body) || process.cwd();
         const clientWorkingDirectory = adapter.extractClientWorkingDirectory?.(body) || workingDirectory;
         const {
-          CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS,
           ANTHROPIC_API_KEY: _dropApiKey,
           ANTHROPIC_BASE_URL: _dropBaseUrl,
           ANTHROPIC_AUTH_TOKEN: _dropAuthToken,
+          CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS,
+          CLAUDE_CODE_USE_POWERSHELL_TOOL: _dropUsePowershell,
           ...cleanEnv
         } = process.env;
         const sdkModelDefaults = resolveSdkModelDefaults();
@@ -17698,7 +18191,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."
               };
             }]
           }]
@@ -17717,7 +18210,7 @@ function createProxyServer(config = {}) {
           const upstreamStartAt = Date.now();
           let firstChunkAt;
           let currentSessionId;
-          const sdkUuidMap = cachedSession?.sdkMessageUuids ? [...cachedSession.sdkMessageUuids] : new Array(allMessages.length - 1).fill(null);
+          const sdkUuidMap = cachedSession?.sdkMessageUuids ? [...cachedSession.sdkMessageUuids] : [];
           while (sdkUuidMap.length < allMessages.length)
             sdkUuidMap.push(null);
           claudeLog("upstream.start", { mode: "non_stream", model });
@@ -17762,7 +18255,7 @@ function createProxyServer(config = {}) {
                     taskBudget,
                     betas,
                     settingSources,
-                    codeSystemPrompt: sdkFeatures.codeSystemPrompt ? true : undefined,
+                    codeSystemPrompt: sdkFeatures.codeSystemPrompt,
                     clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
                     memory: sdkFeatures.memory,
                     dreaming: sdkFeatures.dreaming,
@@ -17824,7 +18317,7 @@ function createProxyServer(config = {}) {
                       taskBudget,
                       betas,
                       settingSources,
-                      codeSystemPrompt: sdkFeatures.codeSystemPrompt ? true : undefined,
+                      codeSystemPrompt: sdkFeatures.codeSystemPrompt,
                       clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
                       memory: sdkFeatures.memory,
                       dreaming: sdkFeatures.dreaming,
@@ -17935,6 +18428,12 @@ function createProxyServer(config = {}) {
                   lastStopReason = message.message.stop_reason;
                 }
               }
+              if (message.type === "result") {
+                const resultUsage = message.usage;
+                if (resultUsage) {
+                  lastUsage = { ...lastUsage, ...resultUsage };
+                }
+              }
             }
             claudeLog("upstream.completed", {
               mode: "non_stream",
@@ -18114,11 +18613,12 @@ Subprocess stderr: ${stderrOutput}`;
                 throw error;
               }
             };
-            const sdkUuidMap = cachedSession?.sdkMessageUuids ? [...cachedSession.sdkMessageUuids] : new Array(allMessages.length - 1).fill(null);
+            const sdkUuidMap = cachedSession?.sdkMessageUuids ? [...cachedSession.sdkMessageUuids] : [];
             while (sdkUuidMap.length < allMessages.length)
               sdkUuidMap.push(null);
             let messageStartEmitted = false;
             let lastUsage;
+            const streamedToolUseIds = new Set;
             try {
               let currentSessionId;
               const MAX_RATE_LIMIT_RETRIES = 2;
@@ -18156,7 +18656,7 @@ Subprocess stderr: ${stderrOutput}`;
                       taskBudget,
                       betas,
                       settingSources,
-                      codeSystemPrompt: sdkFeatures.codeSystemPrompt ? true : undefined,
+                      codeSystemPrompt: sdkFeatures.codeSystemPrompt,
                       clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
                       memory: sdkFeatures.memory,
                       dreaming: sdkFeatures.dreaming,
@@ -18218,7 +18718,7 @@ Subprocess stderr: ${stderrOutput}`;
                         taskBudget,
                         betas,
                         settingSources,
-                        codeSystemPrompt: sdkFeatures.codeSystemPrompt ? true : undefined,
+                        codeSystemPrompt: sdkFeatures.codeSystemPrompt,
                         clientSystemPrompt: sdkFeatures.clientSystemPrompt === false ? false : undefined,
                         memory: sdkFeatures.memory,
                         dreaming: sdkFeatures.dreaming,
@@ -18309,7 +18809,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 +19171,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 +19339,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 +19484,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 +19576,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 +19596,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 +19620,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 +19651,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 +19675,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()
     });
   });