@oxbit/cli 0.11.0 → 0.11.2

package/agent/dist/index.js

@@ -7,33 +7,6 @@ import { randomBytes, createHash, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
 import { createServer } from "node:http";
-const count = (...values) => values.find((value2) => Number.isSafeInteger(value2) && value2 > 0);
-async function readText$1(models2, request, signal) {
-  let text = "";
-  for await (const chunk of models2.stream(request, signal)) text += chunk;
-  return text;
-}
-async function listModels(models2, endpoint, signal) {
-  const body = JSON.parse(await readText$1(models2, { ...endpoint, method: "GET", path: "/v1/models" }, signal));
-  if (!Array.isArray(body?.data)) throw new Error("The model list has no data array");
-  return body.data.filter((item) => typeof item?.id === "string" && item.id).slice(0, 1e3).map((item) => ({
-    id: item.id,
-    name: typeof item.display_name === "string" ? item.display_name : typeof item.name === "string" ? item.name : item.id,
-    contextWindow: count(item.max_input_tokens, item.context_length),
-    maxOutput: count(item.max_tokens, item.top_provider?.max_completion_tokens)
-  }));
-}
-function modelError(error) {
-  const { status: status2, body } = error ?? {};
-  if (typeof status2 !== "number") return error instanceof Error ? error : new Error(String(error));
-  let detail = typeof body === "string" ? body.trim().slice(0, 1e3) : "";
-  try {
-    const parsed = JSON.parse(detail);
-    detail = parsed?.error?.message ?? parsed?.message ?? detail;
-  } catch {
-  }
-  return new Error(`Model API error ${status2}${detail ? `: ${detail}` : ""}`);
-}
 async function* lines(chunks) {
   let buffer = "";
   for await (const chunk of chunks) {
@@ -64,10 +37,10 @@ async function* parseSSE(chunks) {
     }
     if (line.startsWith(":")) continue;
     const colon = line.indexOf(":");
-    const field = colon < 0 ? line : line.slice(0, colon);
+    const field2 = colon < 0 ? line : line.slice(0, colon);
     const value2 = colon < 0 ? "" : line.slice(colon + 1).replace(/^ /, "");
-    if (field === "event") event = value2;
-    else if (field === "data") data.push(value2);
+    if (field2 === "event") event = value2;
+    else if (field2 === "data") data.push(value2);
   }
 }
 async function* jsonEvents(chunks) {
@@ -76,6 +49,210 @@ async function* jsonEvents(chunks) {
     if (value2 && typeof value2 === "object") yield { ...event && !value2.type ? { type: event } : {}, ...value2 };
   }
 }
+function replayable(items) {
+  const kept = items.filter((item) => item.type !== "reasoning" || item.encrypted_content);
+  return kept.length === items.length ? items : kept.map((item) => item.type === "reasoning" ? item : Object.fromEntries(Object.entries(item).filter(([key]) => key !== "id")));
+}
+function responsesBody({ model, system, turns, tools, effort }, replay2) {
+  const input2 = [];
+  for (const turn of turns) {
+    if (turn.role === "user") input2.push({ type: "message", role: "user", content: [{ type: "input_text", text: turn.text }] });
+    else if (turn.role === "tool")
+      for (const result of turn.results) input2.push({ type: "function_call_output", call_id: result.id, output: result.output });
+    else if (turn.native && replay2.includes(turn.native.api)) input2.push(...replayable(turn.native.items));
+    else {
+      if (turn.text) input2.push({ type: "message", role: "assistant", content: turn.text });
+      for (const call of turn.calls) input2.push({ type: "function_call", call_id: call.id, name: call.name, arguments: call.arguments });
+    }
+  }
+  return {
+    model,
+    instructions: system,
+    input: input2,
+    stream: true,
+    store: false,
+    ...tools.length ? { tools: tools.map((tool) => ({ type: "function", ...tool, strict: false })) } : {},
+    ...effort ? { reasoning: { effort, summary: "auto" } } : {}
+  };
+}
+const openaiResponses = {
+  request: (input2) => ({ method: "POST", path: "/v1/responses", body: responsesBody(input2, ["openai"]) }),
+  async *events(chunks) {
+    const items = [];
+    for await (const event of jsonEvents(chunks)) {
+      switch (event.type) {
+        case "response.output_text.delta":
+          if (event.delta) yield { type: "text", text: event.delta };
+          break;
+        case "response.reasoning_summary_text.delta":
+        case "response.reasoning_text.delta":
+          if (event.delta) yield { type: "reasoning", text: event.delta };
+          break;
+        case "response.reasoning_summary_part.added":
+          if (event.summary_index > 0) yield { type: "reasoning", text: "\n\n" };
+          break;
+        case "response.output_item.done":
+          items[event.output_index ?? items.length] = event.item;
+          if (event.item?.type === "function_call")
+            yield { type: "tool_call", call: { id: event.item.call_id, name: event.item.name, arguments: event.item.arguments ?? "" } };
+          break;
+        case "response.completed":
+        case "response.incomplete": {
+          const { usage, incomplete_details: incomplete } = event.response ?? {};
+          if (usage) yield { type: "usage", input: usage.input_tokens ?? 0, output: usage.output_tokens ?? 0 };
+          const native = items.filter(Boolean);
+          const reason = native.some((item) => item.type === "function_call") ? "tool_use" : event.type === "response.completed" ? "end_turn" : incomplete?.reason === "content_filter" ? "refusal" : "max_tokens";
+          yield { type: "stop", reason, native };
+          return;
+        }
+        case "response.failed":
+          throw new Error(event.response?.error?.message ?? "The model response failed");
+        case "error":
+          throw new Error(event.message ?? "The model stream failed");
+      }
+    }
+  }
+};
+const CHATGPT_CLIENT_VERSION = "0.162.1";
+const CHATGPT_MODELS_PATH = `/codex/models?client_version=${CHATGPT_CLIENT_VERSION}`;
+const XHIGH = ["low", "medium", "high", "xhigh"];
+const MAX = { contextWindow: 272e3, efforts: [...XHIGH, "max"] };
+const CHATGPT_MODELS = [
+  { id: "gpt-6.1-sol", name: "GPT-6.1-Sol", ...MAX },
+  { id: "gpt-6-astra", name: "GPT-6-Astra", ...MAX },
+  { id: "gpt-6-sol", name: "GPT-6-Sol", ...MAX },
+  { id: "gpt-6-luna", name: "GPT-6-Luna", ...MAX },
+  { id: "gpt-5.6-sol", name: "GPT-5.6-Sol", ...MAX },
+  { id: "gpt-5.6-terra", name: "GPT-5.6-Terra", ...MAX },
+  { id: "gpt-5.6-luna", name: "GPT-5.6-Luna", ...MAX },
+  { id: "gpt-5.5", name: "GPT-5.5", contextWindow: 272e3, efforts: XHIGH }
+];
+const chatgptResponses = {
+  request: (input2) => ({
+    method: "POST",
+    path: "/codex/responses",
+    body: {
+      ...responsesBody({ ...input2, system: input2.system || "You are a helpful assistant." }, ["openai", "chatgpt"]),
+      include: ["reasoning.encrypted_content"],
+      tool_choice: "auto"
+    }
+  }),
+  events: openaiResponses.events
+};
+const ORDER = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
+const LABELS = { none: "None", minimal: "Minimal", low: "Low", medium: "Medium", high: "High", xhigh: "Extra high", max: "Max" };
+const UNKNOWN_EFFORTS = ["low", "medium", "high"];
+const FIVE = ["low", "medium", "high", "xhigh", "max"];
+const NONE_TO_MAX = ["none", ...FIVE];
+const NONE_TO_XHIGH = ["none", "low", "medium", "high", "xhigh"];
+const OPENAI = [
+  ["gpt-6-astra", FIVE],
+  ["gpt-6.1-sol", FIVE],
+  ["gpt-6-sol", NONE_TO_MAX],
+  ["gpt-6-luna", NONE_TO_MAX],
+  ["gpt-5.6", FIVE],
+  ["gpt-5.5", NONE_TO_XHIGH],
+  ["gpt-5.4", NONE_TO_XHIGH],
+  ["gpt-5.2", NONE_TO_XHIGH],
+  ["gpt-5.1", ["none", "low", "medium", "high"]],
+  ["gpt-5", ["minimal", "low", "medium", "high"]],
+  ["gpt-4", []],
+  ["gpt-4o", []],
+  ["gpt-4.1", []],
+  ["gpt-4.5", []],
+  ["gpt-3.5", []],
+  ["chatgpt-4o", []]
+];
+const ANTHROPIC = [
+  ["claude-fable-5-1", FIVE],
+  ["claude-mythos-5-1", FIVE],
+  ["claude-fable-5", FIVE],
+  ["claude-mythos-5", FIVE],
+  ["claude-opus-5-5", FIVE],
+  ["claude-sonnet-5-5", FIVE],
+  ["claude-haiku-5-5", FIVE],
+  ["claude-opus-5", FIVE],
+  ["claude-sonnet-5", FIVE],
+  ["claude-opus-4-8", FIVE],
+  ["claude-opus-4-7", FIVE],
+  ["claude-mythos-preview", ["low", "medium", "high", "max"]],
+  ["claude-opus-4-6", ["low", "medium", "high", "max"]],
+  ["claude-sonnet-4-6", ["low", "medium", "high", "max"]],
+  ["claude-opus-4-5", ["low", "medium", "high"]]
+];
+const CODEX_CLIENT = /* @__PURE__ */ new Set(["ultra", "persistent"]);
+const family = (table, id2) => table.find(([prefix]) => id2 === prefix || id2.startsWith(`${prefix}-`))?.[1];
+const rank = (level) => ORDER.indexOf(level) + 1 || ORDER.length + 1;
+const sorted = (levels) => [...new Set(levels)].sort((a, b) => rank(a) - rank(b));
+const effortLabel = (level) => LABELS[level] ?? level.charAt(0).toUpperCase() + level.slice(1);
+function modelEfforts(api, model) {
+  if (model.efforts) return [...model.efforts];
+  const id2 = model.id.toLowerCase();
+  if (api === "anthropic") return [...family(ANTHROPIC, id2) ?? []];
+  if (api === "openai" || api === "chatgpt") return [...family(OPENAI, id2) ?? UNKNOWN_EFFORTS];
+  return [...UNKNOWN_EFFORTS];
+}
+function listedEfforts(item) {
+  const effort = item?.capabilities?.effort;
+  if (effort && typeof effort === "object")
+    return effort.supported === false ? [] : FIVE.filter((level) => effort[level]?.supported === true);
+  if (Array.isArray(item?.supported_reasoning_levels))
+    return sorted(item.supported_reasoning_levels.map((preset) => preset?.effort).filter((level) => typeof level === "string" && !!level && !CODEX_CLIENT.has(level)));
+  const reasoning = item?.reasoning;
+  if (reasoning && typeof reasoning === "object") {
+    const levels = Array.isArray(reasoning.supported_efforts) ? reasoning.supported_efforts.filter((level) => typeof level === "string" && !!level) : ORDER;
+    return sorted(reasoning.mandatory ? levels.filter((level) => level !== "none") : levels);
+  }
+  if (Array.isArray(item?.supported_parameters))
+    return item.supported_parameters.some((name) => name === "reasoning" || name === "reasoning_effort") ? void 0 : [];
+  return void 0;
+}
+const count = (...values) => values.find((value2) => Number.isSafeInteger(value2) && value2 > 0);
+async function readText$1(models2, request, signal) {
+  let text = "";
+  for await (const chunk of models2.stream(request, signal)) text += chunk;
+  return text;
+}
+const withEfforts = (info, item) => {
+  const efforts = listedEfforts(item);
+  return efforts ? { ...info, efforts } : info;
+};
+async function listModels(models2, endpoint, signal) {
+  if (endpoint.api === "chatgpt") return listChatGPTModels(models2, signal);
+  const body = JSON.parse(await readText$1(models2, { ...endpoint, method: "GET", path: "/v1/models" }, signal));
+  if (!Array.isArray(body?.data)) throw new Error("The model list has no data array");
+  return body.data.filter((item) => typeof item?.id === "string" && item.id).slice(0, 1e3).map((item) => withEfforts({
+    id: item.id,
+    name: typeof item.display_name === "string" ? item.display_name : typeof item.name === "string" ? item.name : item.id,
+    contextWindow: count(item.max_input_tokens, item.context_length),
+    maxOutput: count(item.max_tokens, item.top_provider?.max_completion_tokens)
+  }, item));
+}
+async function listChatGPTModels(models2, signal) {
+  try {
+    const body = JSON.parse(await readText$1(models2, { api: "chatgpt", method: "GET", path: CHATGPT_MODELS_PATH }, signal));
+    const listed = (Array.isArray(body?.models) ? body.models : []).filter((item) => typeof item?.slug === "string" && item.slug && item.visibility === "list").sort((a, b) => (Number(a.priority) || 0) - (Number(b.priority) || 0)).map((item) => withEfforts({
+      id: item.slug,
+      name: typeof item.display_name === "string" && item.display_name ? item.display_name : item.slug,
+      contextWindow: count(item.context_window)
+    }, item));
+    if (listed.length) return listed;
+  } catch (error) {
+    if (signal?.aborted) throw error;
+  }
+  return CHATGPT_MODELS.map((model) => ({ ...model, ...model.efforts ? { efforts: [...model.efforts] } : {} }));
+}
+function modelError(error) {
+  const { status: status2, body } = error ?? {};
+  if (typeof status2 !== "number") return error instanceof Error ? error : new Error(String(error));
+  let detail = typeof body === "string" ? body.trim().slice(0, 1e3) : "";
+  try {
+    const parsed = JSON.parse(detail);
+    detail = parsed?.error?.message ?? parsed?.message ?? detail;
+  } catch {
+  }
+  return new Error(`Model API error ${status2}${detail ? `: ${detail}` : ""}`);
+}
 const OUTPUT_LIMIT$1 = 1e5;
 const BASH_TIMEOUT = 12e4;
 const BASH_MAX_TIMEOUT = 6e5;
@@ -341,6 +518,7 @@ async function runTool(call, context, tools = TOOLS, gate = {}) {
   const toolCallId = call.id;
   const update = (status2, output2) => context.update({ sessionUpdate: "tool_call_update", toolCallId, status: status2, rawOutput: output2.slice(0, 8e3) });
   const where = locations(context.root, args);
+  const meta = tool?.meta?.(args);
   context.update({
     sessionUpdate: "tool_call",
     toolCallId,
@@ -348,7 +526,8 @@ async function runTool(call, context, tools = TOOLS, gate = {}) {
     kind: tool?.kind ?? "other",
     status: "in_progress",
     rawInput: args,
-    ...where ? { locations: where } : {}
+    ...where ? { locations: where } : {},
+    ...meta ? { _meta: meta } : {}
   });
   try {
     if (typeof parsed === "string") throw new Error(parsed);
@@ -418,13 +597,15 @@ function replay(turns, tools, update) {
         }
         const tool = tools.find((item) => item.spec.name === call.name);
         const args = rawInput && typeof rawInput === "object" ? rawInput : {};
+        const meta = tool?.meta?.(args);
         update({
           sessionUpdate: "tool_call",
           toolCallId: call.id,
           title: (tool?.title(args) ?? call.name).slice(0, 200),
           kind: tool?.kind ?? "other",
           status: "in_progress",
-          rawInput
+          rawInput,
+          ...meta ? { _meta: meta } : {}
         });
       }
     } else
@@ -437,6 +618,56 @@ function replay(turns, tools, update) {
         });
   }
 }
+const sleep$1 = (ms, signal) => new Promise((resolve2) => {
+  if (signal.aborted) return resolve2(false);
+  const abort = () => {
+    clearTimeout(timer);
+    resolve2(false);
+  };
+  const timer = setTimeout(() => {
+    signal.removeEventListener("abort", abort);
+    resolve2(true);
+  }, ms);
+  signal.addEventListener("abort", abort, { once: true });
+});
+const DEFAULT_RETRY = { retries: 4, baseMs: 1e3, maxMs: 3e4, sleep: sleep$1 };
+const NETWORK = /network|connection|connect to|timed out|timeout|load failed|failed to fetch|fetch failed|offline|socket|ECONNRESET|ECONNREFUSED|ETIMEDOUT|EPIPE|EAI_AGAIN|stream ended before the response finished/i;
+const BUSY = /overloaded|rate.?limit/i;
+const QUOTA = /insufficient_quota|exceeded your current quota|billing/i;
+const header = (headers, name) => {
+  if (!headers || typeof headers !== "object") return void 0;
+  if (typeof headers.get === "function") return headers.get(name) ?? void 0;
+  const entry = Object.entries(headers).find(([key]) => key.toLowerCase() === name);
+  return typeof entry?.[1] === "string" ? entry[1] : void 0;
+};
+function retryAfterMs(error) {
+  const value2 = error ?? {};
+  if (typeof value2.retryAfterMs === "number" && value2.retryAfterMs >= 0) return value2.retryAfterMs;
+  const ms = header(value2.headers, "retry-after-ms");
+  if (ms?.trim() && Number(ms) >= 0) return Number(ms);
+  const raw = value2.retryAfter ?? header(value2.headers, "retry-after");
+  if (typeof raw === "number") return raw >= 0 ? raw * 1e3 : void 0;
+  if (typeof raw !== "string" || !raw.trim()) return void 0;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return seconds >= 0 ? seconds * 1e3 : void 0;
+  const date = Date.parse(raw);
+  return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+function isTransient(error) {
+  const { status: status2, body } = error ?? {};
+  const message2 = error instanceof Error ? error.message : String(error);
+  const text = `${typeof body === "string" ? body : ""} ${message2}`;
+  if (QUOTA.test(text)) return false;
+  if (typeof status2 === "number")
+    return status2 === 408 || status2 === 409 || status2 === 429 || status2 >= 500 && status2 !== 501 && status2 !== 505 || BUSY.test(text);
+  return BUSY.test(message2) || NETWORK.test(message2) || error instanceof TypeError && /fetch|load/i.test(message2);
+}
+function retryDelay(error, attempt, policy) {
+  if (attempt >= policy.retries || !isTransient(error)) return void 0;
+  const after = retryAfterMs(error);
+  if (after !== void 0) return after <= policy.maxMs ? after : void 0;
+  return Math.min(policy.maxMs, policy.baseMs * 2 ** attempt);
+}
 async function* abortable(source, signal) {
   const iterator = source[Symbol.asyncIterator]();
   const aborted = new Promise((_, reject) => {
@@ -456,7 +687,29 @@ async function* abortable(source, signal) {
     });
   }
 }
-async function streamStep({ adapter, models: models2, endpoint, input: input2, signal, turns, update, contextWindow }) {
+async function streamStep(options) {
+  const policy = { ...DEFAULT_RETRY, ...options.retry };
+  for (let attempt = 0; ; attempt++) {
+    const progress = { streamed: false };
+    try {
+      return await attemptStep(options, progress);
+    } catch (error) {
+      const delay = progress.streamed ? void 0 : retryDelay(error, attempt, policy);
+      if (delay === void 0) throw modelError(error);
+      const seconds = Math.round(delay / 100) / 10;
+      options.update({ sessionUpdate: "agent_message_chunk", content: {
+        type: "text",
+        text: `
+
+${modelError(error).message}. Retrying in ${seconds} s (${attempt + 1} of ${policy.retries}).
+
+`
+      } });
+      if (!await policy.sleep(delay, options.signal)) return { turn: { role: "assistant", text: "", calls: [] } };
+    }
+  }
+}
+async function attemptStep({ adapter, models: models2, endpoint, input: input2, signal, turns, update, contextWindow }, progress) {
   const calls = [];
   const turn = { role: "assistant", text: "", calls };
   const result = { turn };
@@ -464,12 +717,16 @@ async function streamStep({ adapter, models: models2, endpoint, input: input2, s
     const request = adapter.request(input2);
     for await (const event of adapter.events(abortable(models2.stream({ ...endpoint, ...request }, signal), signal))) {
       if (event.type === "text") {
+        progress.streamed = true;
         turn.text += event.text;
         update({ sessionUpdate: "agent_message_chunk", content: { type: "text", text: event.text } });
-      } else if (event.type === "reasoning")
+      } else if (event.type === "reasoning") {
+        progress.streamed = true;
         update({ sessionUpdate: "agent_thought_chunk", content: { type: "text", text: event.text } });
-      else if (event.type === "tool_call") calls.push(event.call);
-      else if (event.type === "usage") {
+      } else if (event.type === "tool_call") {
+        progress.streamed = true;
+        calls.push(event.call);
+      } else if (event.type === "usage") {
         result.usage = { input: event.input, output: event.output };
         if (contextWindow) update({ sessionUpdate: "usage_update", used: event.input + event.output, size: contextWindow });
       } else if (event.type === "stop") {
@@ -479,80 +736,13 @@ async function streamStep({ adapter, models: models2, endpoint, input: input2, s
     }
     if (!result.stop && !signal.aborted) throw new Error("The model stream ended before the response finished");
   } catch (error) {
-    if (!signal.aborted) throw modelError(error);
+    if (!signal.aborted) throw error;
   } finally {
     if (!result.stop) calls.length = 0;
     if (turn.text || calls.length) turns.push(turn);
   }
   return result;
 }
-function replayable(items) {
-  const kept = items.filter((item) => item.type !== "reasoning" || item.encrypted_content);
-  return kept.length === items.length ? items : kept.map((item) => item.type === "reasoning" ? item : Object.fromEntries(Object.entries(item).filter(([key]) => key !== "id")));
-}
-const openaiResponses = {
-  request({ model, system, turns, tools, effort }) {
-    const input2 = [];
-    for (const turn of turns) {
-      if (turn.role === "user") input2.push({ type: "message", role: "user", content: [{ type: "input_text", text: turn.text }] });
-      else if (turn.role === "tool")
-        for (const result of turn.results) input2.push({ type: "function_call_output", call_id: result.id, output: result.output });
-      else if (turn.native?.api === "openai") input2.push(...replayable(turn.native.items));
-      else {
-        if (turn.text) input2.push({ type: "message", role: "assistant", content: turn.text });
-        for (const call of turn.calls) input2.push({ type: "function_call", call_id: call.id, name: call.name, arguments: call.arguments });
-      }
-    }
-    return {
-      method: "POST",
-      path: "/v1/responses",
-      body: {
-        model,
-        instructions: system,
-        input: input2,
-        stream: true,
-        store: false,
-        ...tools.length ? { tools: tools.map((tool) => ({ type: "function", ...tool, strict: false })) } : {},
-        ...effort ? { reasoning: { effort, summary: "auto" } } : {}
-      }
-    };
-  },
-  async *events(chunks) {
-    const items = [];
-    for await (const event of jsonEvents(chunks)) {
-      switch (event.type) {
-        case "response.output_text.delta":
-          if (event.delta) yield { type: "text", text: event.delta };
-          break;
-        case "response.reasoning_summary_text.delta":
-        case "response.reasoning_text.delta":
-          if (event.delta) yield { type: "reasoning", text: event.delta };
-          break;
-        case "response.reasoning_summary_part.added":
-          if (event.summary_index > 0) yield { type: "reasoning", text: "\n\n" };
-          break;
-        case "response.output_item.done":
-          items[event.output_index ?? items.length] = event.item;
-          if (event.item?.type === "function_call")
-            yield { type: "tool_call", call: { id: event.item.call_id, name: event.item.name, arguments: event.item.arguments ?? "" } };
-          break;
-        case "response.completed":
-        case "response.incomplete": {
-          const { usage, incomplete_details: incomplete } = event.response ?? {};
-          if (usage) yield { type: "usage", input: usage.input_tokens ?? 0, output: usage.output_tokens ?? 0 };
-          const native = items.filter(Boolean);
-          const reason = native.some((item) => item.type === "function_call") ? "tool_use" : event.type === "response.completed" ? "end_turn" : incomplete?.reason === "content_filter" ? "refusal" : "max_tokens";
-          yield { type: "stop", reason, native };
-          return;
-        }
-        case "response.failed":
-          throw new Error(event.response?.error?.message ?? "The model response failed");
-        case "error":
-          throw new Error(event.message ?? "The model stream failed");
-      }
-    }
-  }
-};
 const STOP$1 = { stop: "end_turn", tool_calls: "tool_use", function_call: "tool_use", length: "max_tokens", content_filter: "refusal" };
 function mergeDetails(details, fragments) {
   if (!Array.isArray(fragments)) return;
@@ -934,12 +1124,181 @@ Additional focus: ${focus}` : "");
     }
   }
 }
+const OXBIT_SUBAGENT_TOOL = "task";
+const FORWARDED_HOOKS = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse", "PostToolUseFailure", "PreCompact", "PostCompact"]);
+const childCallId = (spawnId, id2) => `${spawnId}/${id2}`;
+function childExtensions(host, { parent, childId }) {
+  const source = host.extensions;
+  if (!source) return {};
+  const view = () => ({ id: parent.id, cwd: parent.cwd, model: parent.model, turns: [], meta: { mcpServers: parent.meta.mcpServers } });
+  const runner = source.hooks;
+  const hooks = runner && {
+    run: async (event, input2, signal) => FORWARDED_HOOKS.has(event) ? runner.run(event, { ...input2, session_id: parent.id, agent_id: childId }, signal) : {}
+  };
+  return {
+    tools: source.tools?.map((provider2) => ({ tools: () => provider2.tools(view()) })),
+    context: source.context?.map((provider2) => ({ label: provider2.label, system: () => provider2.system(view()) })),
+    ...hooks ? { hooks } : {},
+    ...source.compactor ? { compactor: source.compactor } : {}
+  };
+}
+function childUpdate(host, { parent, spawnId, native }) {
+  if (native) return (sessionId, update) => host.update(sessionId, update);
+  return (_sessionId, update) => {
+    if (update.sessionUpdate !== "tool_call" && update.sessionUpdate !== "tool_call_update") return;
+    host.update(parent.id, {
+      ...update,
+      toolCallId: childCallId(spawnId, String(update.toolCallId)),
+      _meta: { ...update._meta, oxbit: { ...update._meta?.oxbit, subagentOf: spawnId } }
+    });
+  };
+}
+const forwarded = (params, { parent, spawnId }) => ({
+  ...params,
+  ..."sessionId" in params ? { sessionId: parent.id } : {},
+  ...typeof params.toolCallId === "string" ? { toolCallId: childCallId(spawnId, params.toolCallId) } : {},
+  ...typeof params.toolCall?.toolCallId === "string" ? { toolCall: { ...params.toolCall, toolCallId: childCallId(spawnId, params.toolCall.toolCallId) } } : {}
+});
+function childRequest(host, link) {
+  const aborted = new Promise((_, reject) => {
+    const fail = () => reject(new Error("Cancelled by the user"));
+    if (link.signal.aborted) fail();
+    else link.signal.addEventListener("abort", fail, { once: true });
+  });
+  aborted.catch(() => {
+  });
+  return (method, params) => {
+    const raw = host.request(method, link.native ? params : forwarded(params, link));
+    raw.catch(() => {
+    });
+    return Promise.race([raw, aborted]);
+  };
+}
+const childHost = (host, link) => ({
+  ...host,
+  subagents: void 0,
+  generateTitles: false,
+  update: childUpdate(host, link),
+  request: childRequest(host, link),
+  extensions: childExtensions(host, link)
+});
+const RESULT_LIMIT$1 = 4e4;
+const PROMPT_LIMIT = 1e5;
+const TASK_META_LIMIT = 4096;
+const CANCELLED = "Cancelled by the user";
+const SUBAGENT_PROMPT = [
+  "You are a subagent. Another agent delegated the task in the user message to you.",
+  "You cannot see that agent's conversation and cannot ask the user questions. Work until the task is done or you are blocked.",
+  "End with a self-contained report: what you found or changed, with workspace-relative paths, and what is left open. The other agent sees only that report."
+].join("\n");
+const DESCRIPTION = `Delegate a self-contained task to a subagent. It starts with a fresh context and the same tools except ${OXBIT_SUBAGENT_TOOL}, works until done, and returns its final message as this tool's result. The call blocks until the subagent finishes. The user does not see that message, so summarize what matters. Use it for broad searches, multi-file investigations or independent changes, to keep this conversation's context small. Several ${OXBIT_SUBAGENT_TOOL} calls in one response run in parallel. Its file edits and commands go through the same user review as yours.`;
+const field = (args, key) => typeof args[key] === "string" ? args[key] : "";
+function report(child, stopReason) {
+  const last = [...child.turns].reverse().find((turn) => turn.role === "assistant");
+  let output = (last?.role === "assistant" ? last.text.trim() : "") || "The subagent finished without a final message.";
+  if (stopReason !== "end_turn") output += `
+
+[The subagent stopped: ${stopReason}]`;
+  return output.length > RESULT_LIMIT$1 ? `${output.slice(0, RESULT_LIMIT$1)}
+[Truncated at ${RESULT_LIMIT$1} characters.]` : output;
+}
+function taskTool({ host, parent, runChild }) {
+  const meta = (args, state, sessionId) => {
+    const subagent = {
+      name: field(args, "description").trim().slice(0, 200),
+      task: field(args, "prompt").slice(0, TASK_META_LIMIT),
+      model: parent.model,
+      ...sessionId ? { sessionId } : {},
+      state
+    };
+    return { oxbit: { subagent } };
+  };
+  return {
+    spec: { name: OXBIT_SUBAGENT_TOOL, description: DESCRIPTION, parameters: {
+      type: "object",
+      additionalProperties: false,
+      required: ["description", "prompt"],
+      properties: {
+        description: { type: "string", maxLength: 200, description: "The task in 3 to 8 words" },
+        prompt: {
+          type: "string",
+          minLength: 1,
+          maxLength: PROMPT_LIMIT,
+          description: "The full task: the goal, relevant paths and facts from this conversation, constraints, and what to report back"
+        }
+      }
+    } },
+    kind: "other",
+    mutates: true,
+    parallel: true,
+    title: (args) => `Task: ${field(args, "description").trim() || "subagent"}`,
+    meta: (args) => meta(args, "pending"),
+    async run(args, context) {
+      const description = field(args, "description").trim();
+      const prompt = field(args, "prompt");
+      if (!description || description.length > 200) throw new Error("description must be a non-empty string of at most 200 characters");
+      if (!prompt.trim() || prompt.length > PROMPT_LIMIT) throw new Error(`prompt must be 1 to ${PROMPT_LIMIT} characters`);
+      if (context.signal.aborted) throw new Error(CANCELLED);
+      const childId = crypto.randomUUID();
+      const native = !!host.capabilities.childSessions;
+      const sessionId = native ? childId : void 0;
+      const abort = new AbortController();
+      const child = {
+        id: childId,
+        cwd: parent.cwd,
+        model: parent.model,
+        effort: parent.effort,
+        catalog: parent.catalog,
+        turns: [{ role: "user", text: prompt }],
+        context: [SUBAGENT_PROMPT],
+        meta: { subagent: { parentSessionId: parent.id, toolCallId: context.toolCallId }, get mode() {
+          return parent.meta.mode;
+        } }
+      };
+      let state;
+      const finish = (next) => {
+        if (state) return;
+        state = next;
+        if (native) host.update(parent.id, { sessionUpdate: "subagent_state_update", subagentSessionId: childId, state: next });
+        context.update({ sessionUpdate: "tool_call_update", toolCallId: context.toolCallId, _meta: meta(args, next, sessionId) });
+      };
+      const cancel = () => {
+        abort.abort();
+        finish("cancelled");
+      };
+      context.signal.addEventListener("abort", cancel, { once: true });
+      try {
+        if (native) {
+          host.update(parent.id, { sessionUpdate: "subagent_spawned", subagentSessionId: childId, name: description, task: prompt });
+          host.update(childId, { sessionUpdate: "user_message_chunk", content: { type: "text", text: prompt } });
+        }
+        context.update({ sessionUpdate: "tool_call_update", toolCallId: context.toolCallId, _meta: meta(args, "running", sessionId) });
+        const link = { parent, childId, spawnId: context.toolCallId, native, signal: abort.signal };
+        const { stopReason } = await runChild(childHost(host, link), child, abort.signal);
+        if (abort.signal.aborted) throw new Error(CANCELLED);
+        finish("completed");
+        return report(child, stopReason);
+      } catch (error) {
+        if (abort.signal.aborted) {
+          finish("cancelled");
+          throw new Error(CANCELLED);
+        }
+        finish("failed");
+        throw error;
+      } finally {
+        context.signal.removeEventListener("abort", cancel);
+      }
+    }
+  };
+}
 const ADAPTERS = {
   openai: openaiResponses,
   "openai-compatible": chatCompletions,
-  anthropic: anthropicMessages
+  anthropic: anthropicMessages,
+  chatgpt: chatgptResponses
 };
 const MAX_STEPS = 64;
+const STOP_BLOCK_LIMIT = 10;
 const CONTEXT_LIMIT$1 = 1e4;
 const basePrompt = (root, reviewed, shell) => [
   `You are Oxbit Agent, a coding agent inside the Oxbit editor. You work in the workspace "${root.split("/").pop()}" through tools.`,
@@ -962,17 +1321,24 @@ class PromptTurn {
   /** Set by a hook that returns continue: false. */
   halt;
   stopHookActive = false;
-  snapshotted = false;
+  stopBlocks = 0;
+  snapshotting;
   async hook(event, input2) {
     const runner = this.host.extensions?.hooks;
     if (!runner) return {};
-    const outcome = await runner.run(event, {
-      session_id: this.session.id,
-      cwd: this.session.cwd,
-      hook_event_name: event,
-      permission_mode: CLAUDE_PERMISSION_MODES[modeOf(this.session.meta)],
-      ...input2
-    }, this.signal);
+    let outcome;
+    try {
+      outcome = await runner.run(event, {
+        session_id: this.session.id,
+        cwd: this.session.cwd,
+        hook_event_name: event,
+        permission_mode: CLAUDE_PERMISSION_MODES[modeOf(this.session.meta)],
+        ...input2
+      }, this.signal);
+    } catch (error) {
+      if (!this.signal.aborted) this.notice(`The ${event} hooks failed: ${error instanceof Error ? error.message : String(error)}`);
+      return {};
+    }
     if (outcome.systemMessage) this.notice(outcome.systemMessage);
     if (outcome.continue === false) this.halt ??= outcome.stopReason || "A hook stopped the agent";
     return outcome;
@@ -992,6 +1358,8 @@ ${text}
   async tools() {
     const provided = await Promise.all((this.host.extensions?.tools ?? []).map((provider2) => provider2.tools(this.session)));
     const tools = [...builtinTools(this.host.capabilities)];
+    if (this.host.subagents && !this.session.meta.subagent)
+      tools.push(taskTool({ host: this.host, parent: this.session, runChild: (host, child, signal) => new PromptTurn(host, child, signal).run(host.models(), host.endpoint()) }));
     for (const tool of provided.flat()) if (!tools.some((item) => item.spec.name === tool.spec.name)) tools.push(tool);
     return tools;
   }
@@ -1018,7 +1386,7 @@ ${text}
     let steps = 0;
     while (steps++ < MAX_STEPS) {
       const tools = await this.tools();
-      this.snapshotted = false;
+      this.snapshotting = void 0;
       const result = await streamStep({
         adapter,
         models: models2,
@@ -1027,6 +1395,7 @@ ${text}
         update,
         turns: session.turns,
         contextWindow: info?.contextWindow,
+        retry: this.host.retry,
         input: {
           model: session.model,
           system: prompt,
@@ -1048,11 +1417,7 @@ ${text}
         request: (method, params) => this.host.request(method, params),
         filesystem: session.cwd === normalize(this.host.root) ? this.host.filesystem : this.host.filesystemFor(session.cwd)
       };
-      const results = [];
-      for (const call of calls) {
-        const skipped = signal.aborted ? "Cancelled by the user" : this.halt;
-        results.push(skipped ? { id: call.id, name: call.name, output: skipped, error: true } : await runTool(call, context, tools, gate));
-      }
+      const results = await this.runCalls(calls, context, tools, gate);
       if (results.length) session.turns.push({ role: "tool", results });
       if (signal.aborted) return { stopReason: "cancelled" };
       try {
@@ -1075,12 +1440,42 @@ ${text}
     }
     return { stopReason: "max_turn_requests" };
   }
+  /** Runs calls in order; consecutive calls to parallel tools run together, up to the host's subagent concurrency. */
+  async runCalls(calls, context, tools, gate) {
+    const results = [];
+    const one = async (index) => {
+      const call = calls[index];
+      const skipped = this.signal.aborted ? "Cancelled by the user" : this.halt;
+      results[index] = skipped ? { id: call.id, name: call.name, output: skipped, error: true } : await runTool(call, context, tools, gate);
+    };
+    const parallel = (call) => !!tools.find((tool) => tool.spec.name === call.name)?.parallel;
+    const limit = Math.max(1, this.host.subagents?.concurrency ?? 4);
+    for (let index = 0; index < calls.length; ) {
+      let end = index;
+      while (end < calls.length && parallel(calls[end])) end++;
+      if (end === index) {
+        await one(index++);
+        continue;
+      }
+      let next = index;
+      const worker = async () => {
+        while (next < end) await one(next++);
+      };
+      await Promise.all(Array.from({ length: Math.min(limit, end - index) }, worker));
+      index = end;
+    }
+    return results;
+  }
   /** Stop hooks, then continuation providers. Returns the text of the next user message, if any. */
   async afterStop() {
     const last = this.session.turns.at(-1);
     const outcome = await this.hook("Stop", { stop_hook_active: this.stopHookActive, last_assistant_message: last?.role === "assistant" ? last.text : "" });
     if (this.halt) return void 0;
     if (outcome.block) {
+      if (++this.stopBlocks > STOP_BLOCK_LIMIT) {
+        this.notice(`Stop hooks blocked the end of this turn ${STOP_BLOCK_LIMIT} times, so the turn ends here.`);
+        return void 0;
+      }
       this.stopHookActive = true;
       return outcome.reason || "A stop hook asked you to continue.";
     }
@@ -1101,6 +1496,7 @@ ${text}
         update: () => {
         },
         turns: [],
+        retry: this.host.retry,
         input: { model: this.session.model, system: prompt, turns, tools: [] }
       });
       if (!result.stop) throw new Error("Cancelled");
@@ -1119,10 +1515,15 @@ ${text}
     await this.hook("PostCompact", { trigger });
     return true;
   }
-  async snapshot(label) {
+  /** The first mutating call of a step captures; concurrent calls wait for that capture. */
+  snapshot(label) {
     const store = this.host.extensions?.snapshots;
-    if (!store || this.snapshotted) return;
-    this.snapshotted = true;
+    if (!store) return Promise.resolve();
+    if (this.snapshotting) return this.snapshotting.catch(() => {
+    });
+    return this.snapshotting = this.capture(store, label);
+  }
+  async capture(store, label) {
     const snapshot2 = await store.capture(label, this.session.cwd);
     const list2 = Array.isArray(this.session.meta.snapshots) ? this.session.meta.snapshots : [];
     if (snapshot2) this.session.meta.snapshots = [...list2, { id: snapshot2, label, turn: this.session.turns.length }];
@@ -1251,13 +1652,13 @@ function contextLegend(usage) {
 }
 function contextNotes(usage) {
   const model = usage.model || "no model";
-  const header = usage.window ? `Context usage for ${model}: ${formatTokens(usage.used)} of ${formatTokens(usage.window)} tokens (${formatPercent(usage.used, usage.window)}).` : `Context usage for ${model}: about ${formatTokens(usage.used)} tokens. The context window of this model is unknown.`;
+  const header2 = usage.window ? `Context usage for ${model}: ${formatTokens(usage.used)} of ${formatTokens(usage.window)} tokens (${formatPercent(usage.used, usage.window)}).` : `Context usage for ${model}: about ${formatTokens(usage.used)} tokens. The context window of this model is unknown.`;
   const footer = [
     ...usage.window ? [usage.threshold === void 0 ? "Auto compaction is off." : `Auto compaction runs at ${formatTokens(usage.threshold)} tokens (${formatPercent(usage.threshold, usage.window)}).`] : [],
     ...usage.reported ? [`Provider count for the last request: ${formatTokens(usage.reported.input + usage.reported.output)} tokens (${formatTokens(usage.reported.input)} input, ${formatTokens(usage.reported.output)} output).`] : [],
     "Category counts are estimates at 4 characters per token."
   ];
-  return { header, footer };
+  return { header: header2, footer };
 }
 function renderContextUsage(usage) {
   const legend = contextLegend(usage);
@@ -1269,8 +1670,8 @@ function renderContextUsage(usage) {
   const counts = legend.map((row) => formatTokens(row.tokens));
   const digits = Math.max(...counts.map((count2) => count2.length));
   const lines2 = legend.map((row, index) => `${row.glyph} ${row.label.padEnd(width)}  ${counts[index].padStart(digits)}` + (usage.window ? `  ${formatPercent(row.tokens, usage.window).padStart(6)}` : ""));
-  const { header, footer } = contextNotes(usage);
-  return [header, "", "```text", ...rows.length ? [...rows, ""] : [], ...lines2, "```", "", footer.join(" ")].join("\n");
+  const { header: header2, footer } = contextNotes(usage);
+  return [header2, "", "```text", ...rows.length ? [...rows, ""] : [], ...lines2, "```", "", footer.join(" ")].join("\n");
 }
 function contextCommand(host, session) {
   return {
@@ -1283,7 +1684,6 @@ function contextCommand(host, session) {
     }
   };
 }
-const EFFORTS = ["default", "low", "medium", "high"];
 const COMMAND = /^\/([\w:.-]+)(?:\s+([\s\S]*))?$/;
 const id = (params, key) => {
   if (typeof params[key] !== "string" || !params[key]) throw new Error(`Invalid ${key}`);
@@ -1303,7 +1703,7 @@ class Agent {
       protocolVersion: 1,
       agentCapabilities: {
         loadSession: saved,
-        sessionCapabilities: { fork: {}, ...saved ? { list: {} } : {} },
+        sessionCapabilities: { fork: {}, ...saved ? { list: {} } : {}, ...this.host.subagents ? { subagents: {} } : {} },
         promptCapabilities: { embeddedContext: true },
         ...this.host.capabilities.mcp ? { mcpCapabilities: this.host.capabilities.mcp } : {}
       },
@@ -1347,6 +1747,12 @@ class Agent {
     if (!session) throw new Error("Unknown ACP session");
     return session;
   }
+  /** The session model's reasoning levels; empty when the model has no reasoning control. */
+  efforts(session) {
+    const model = session.catalog.find((item) => item.id === session.model) ?? { id: session.model, name: session.model };
+    return modelEfforts(this.host.endpoint().api, model);
+  }
+  /** A model without reasoning levels gets no Reasoning option. */
   options(session) {
     const models2 = {
       id: "model",
@@ -1356,13 +1762,14 @@ class Agent {
       currentValue: session.model,
       options: session.catalog.map((model) => ({ value: model.id, name: model.name }))
     };
+    const efforts = this.efforts(session);
     const reasoning = {
       id: "reasoning",
       name: "Reasoning",
       category: "thought_level",
       type: "select",
       currentValue: session.effort,
-      options: EFFORTS.map((value2) => ({ value: value2, name: value2 === "default" ? "Model default" : value2[0].toUpperCase() + value2.slice(1) }))
+      options: [{ value: "default", name: "Model default" }, ...efforts.map((value2) => ({ value: value2, name: effortLabel(value2) }))]
     };
     const mode = {
       id: "mode",
@@ -1372,7 +1779,7 @@ class Agent {
       currentValue: modeOf(session.meta),
       options: MODES.map(({ id: id2, name }) => ({ value: id2, name }))
     };
-    return [...session.catalog.length ? [models2] : [], reasoning, mode, ...this.host.configOptions?.(session) ?? []];
+    return [...session.catalog.length ? [models2] : [], ...efforts.length ? [reasoning] : [], mode, ...this.host.configOptions?.(session) ?? []];
   }
   state(session) {
     return {
@@ -1392,7 +1799,7 @@ class Agent {
     if (cwd !== normalize(this.host.root) && !this.host.filesystemFor) throw new Error(`This agent serves ${this.host.root} only`);
     return cwd;
   }
-  /** The host catalog or `GET /v1/models`, with `model` first when the list lacks it. */
+  /** The host catalog or `listModels`, with `model` first when the list lacks it. */
   async models(model) {
     const listed = this.host.catalog ? Promise.resolve().then(() => this.host.catalog()) : this.catalog ??= listModels(this.service(), this.host.endpoint());
     const catalog = await listed.catch(() => {
@@ -1483,10 +1890,12 @@ class Agent {
       void this.end(session, "clear");
     }
   }
+  /** A reasoning level the new model lacks falls back to the model default. */
   setModel(sessionId, modelId) {
     const session = this.session(sessionId);
     if (!session.catalog.some((model) => model.id === modelId)) throw new Error("This model is not in the model list");
     session.model = modelId;
+    if (!this.efforts(session).includes(session.effort)) session.effort = "default";
     this.host.saveModel?.(modelId);
     return { configOptions: this.options(session) };
   }
@@ -1506,7 +1915,8 @@ class Agent {
       return { configOptions: this.options(session) };
     }
     if (configId !== "reasoning" && await this.host.setConfigOption?.(session, configId, value2)) return { configOptions: this.options(session) };
-    if (configId !== "reasoning" || !EFFORTS.includes(value2)) throw new Error("Unknown agent setting");
+    if (configId !== "reasoning") throw new Error("Unknown agent setting");
+    if (value2 !== "default" && !this.efforts(session).includes(value2)) throw new Error("This model does not support that reasoning level");
     session.effort = value2;
     return { configOptions: this.options(session) };
   }
@@ -1559,8 +1969,11 @@ class Agent {
     const endpoint = this.host.endpoint();
     let text = promptText(blocks);
     const submit = await turn.hook("UserPromptSubmit", { prompt: text });
-    if (submit.block) throw new Error(submit.reason || "A hook blocked this prompt");
     if (turn.halt) return turn.halted();
+    if (submit.block) {
+      turn.notice(submit.reason || "A hook blocked this prompt");
+      return { stopReason: "end_turn" };
+    }
     if (submit.additionalContext) text += `
 
 ${submit.additionalContext.slice(0, CONTEXT_LIMIT$1)}`;
@@ -1615,7 +2028,11 @@ ${submit.additionalContext.slice(0, CONTEXT_LIMIT$1)}`;
     const key = JSON.stringify(available);
     if (key === (session.commands ?? "[]")) return;
     session.commands = key;
-    this.host.update(session.id, { sessionUpdate: "available_commands_update", availableCommands: available });
+    try {
+      this.host.update(session.id, { sessionUpdate: "available_commands_update", availableCommands: available });
+    } catch {
+      session.commands = void 0;
+    }
   }
 }
 const CLAUDE_TOOL_NAMES = {
@@ -1852,8 +2269,8 @@ function createHookRunner(options) {
       if (sources.some((source) => isObject$1(source.config) && source.config.disableAllHooks === true)) return {};
       const tool = TOOL_EVENTS.has(event) && typeof input2.tool_name === "string" ? input2.tool_name : void 0;
       const names = tool ? [tool, ...CLAUDE_TOOL_NAMES[tool] ?? []] : void 0;
-      const field = MATCH_FIELD[event];
-      const values = names ?? (field && typeof input2[field] === "string" ? [input2[field]] : void 0);
+      const field2 = MATCH_FIELD[event];
+      const values = names ?? (field2 && typeof input2[field2] === "string" ? [input2[field2]] : void 0);
       const selected = /* @__PURE__ */ new Map();
       for (const handler2 of sources.flatMap(handlersOf)) {
         if (handler2.event !== event || values && !matchesHook(handler2.matcher, values) || options.skip?.(handler2)) continue;
@@ -3204,11 +3621,11 @@ function headerParams(schema) {
   const walk = (node, path2) => {
     for (const [key, property] of Object.entries(node?.properties ?? {})) {
       if (!property || typeof property !== "object") continue;
-      const header = property["x-mcp-header"];
-      if (header !== void 0) {
-        if (typeof header !== "string" || !HEADER_TOKEN.test(header) || !PRIMITIVES.has(property.type) || seen.has(header.toLowerCase())) return false;
-        seen.add(header.toLowerCase());
-        found.push({ path: [...path2, key], header });
+      const header2 = property["x-mcp-header"];
+      if (header2 !== void 0) {
+        if (typeof header2 !== "string" || !HEADER_TOKEN.test(header2) || !PRIMITIVES.has(property.type) || seen.has(header2.toLowerCase())) return false;
+        seen.add(header2.toLowerCase());
+        found.push({ path: [...path2, key], header: header2 });
       }
       if (property.type === "object" && !walk(property, [...path2, key])) return false;
     }
@@ -3218,11 +3635,11 @@ function headerParams(schema) {
 }
 function paramHeaders(params, args) {
   const headers = {};
-  for (const { path: path2, header } of params) {
+  for (const { path: path2, header: header2 } of params) {
     let value2 = args;
     for (const key of path2) value2 = value2 && typeof value2 === "object" ? value2[key] : void 0;
-    if (typeof value2 === "string") headers[`Mcp-Param-${header}`] = headerValue(value2);
-    else if (typeof value2 === "number" || typeof value2 === "boolean") headers[`Mcp-Param-${header}`] = String(value2);
+    if (typeof value2 === "string") headers[`Mcp-Param-${header2}`] = headerValue(value2);
+    else if (typeof value2 === "number" || typeof value2 === "boolean") headers[`Mcp-Param-${header2}`] = String(value2);
   }
   return headers;
 }
@@ -3556,7 +3973,9 @@ function httpModels(options) {
       }
       if (!response.ok) {
         const body = await bodyText(response);
-        throw httpError(response.status, options.describe ? options.describe(response.status, body) : body);
+        const error = httpError(response.status, options.describe ? options.describe(response.status, body) : body);
+        const after = retryAfterMs({ headers: response.headers });
+        throw after === void 0 ? error : Object.assign(error, { retryAfterMs: after });
       }
       yield* textChunks(response.body);
     },
@@ -3667,12 +4086,12 @@ const json = (part) => {
 async function verifyIdToken(token, check) {
   const parts = token.split(".");
   if (parts.length !== 3) throw new Error("The ID token is malformed");
-  const header = json(parts[0]);
+  const header2 = json(parts[0]);
   const claims = json(parts[1]);
-  if (header?.alg !== "RS256") throw new Error(`The ID token uses an unsupported algorithm: ${header?.alg}`);
+  if (header2?.alg !== "RS256") throw new Error(`The ID token uses an unsupported algorithm: ${header2?.alg}`);
   const signed = new TextEncoder().encode(`${parts[0]}.${parts[1]}`);
   const signature = fromBase64url(parts[2]);
-  const matches = (keys) => keys.filter((key) => key.kty === "RSA" && (!key.use || key.use === "sig") && (!key.alg || key.alg === "RS256") && (header.kid === void 0 || key.kid === header.kid));
+  const matches = (keys) => keys.filter((key) => key.kty === "RSA" && (!key.use || key.use === "sig") && (!key.alg || key.alg === "RS256") && (header2.kid === void 0 || key.kid === header2.kid));
   let candidates = matches(await check.jwks.keys(false));
   if (!candidates.length) candidates = matches(await check.jwks.keys(true));
   if (!candidates.length) throw new Error("No signing key matches the ID token");
@@ -4011,11 +4430,15 @@ const providerSpec = (id2) => PROVIDERS.find((spec) => spec.id === id2);
 const apiKeySlot = (provider2, baseUrl) => provider2 === "openai-compatible" ? `apikey:openai-compatible ${new URL(baseUrl ?? "").origin}` : `apikey:${provider2}`;
 function planModels(body) {
   if (!Array.isArray(body?.models)) throw new Error("The ChatGPT model list has no models array");
-  return body.models.filter((model) => typeof model?.slug === "string" && model.slug && model.visibility === "list" && model.supported_in_api !== false).map((model) => ({
-    id: model.slug,
-    name: typeof model.display_name === "string" ? model.display_name : model.slug,
-    ...Number.isSafeInteger(model.context_window) && model.context_window > 0 ? { contextWindow: model.context_window } : {}
-  }));
+  return body.models.filter((model) => typeof model?.slug === "string" && model.slug && model.visibility === "list" && model.supported_in_api !== false).map((model) => {
+    const efforts = listedEfforts(model);
+    return {
+      id: model.slug,
+      name: typeof model.display_name === "string" ? model.display_name : model.slug,
+      ...Number.isSafeInteger(model.context_window) && model.context_window > 0 ? { contextWindow: model.context_window } : {},
+      ...efforts ? { efforts } : {}
+    };
+  });
 }
 function provider(selection, host) {
   const spec = providerSpec(selection.provider);
@@ -4373,7 +4796,7 @@ class FileCatalogCache {
   }
 }
 function agentVersion() {
-  return "0.11.0";
+  return "0.11.2";
 }
 const clone = (message2) => JSON.parse(JSON.stringify(message2));
 class MemoryConnection {
@@ -4868,13 +5291,13 @@ async function firstLine$2(file2) {
     await handle.close();
   }
 }
-const summary = (header) => header?.type === "session" && typeof header.id === "string" && typeof header.cwd === "string" ? {
-  id: header.id,
-  cwd: header.cwd,
-  title: String(header.title ?? ""),
-  model: String(header.model ?? ""),
-  meta: header.meta && typeof header.meta === "object" ? header.meta : {},
-  updatedAt: String(header.updatedAt ?? "")
+const summary = (header2) => header2?.type === "session" && typeof header2.id === "string" && typeof header2.cwd === "string" ? {
+  id: header2.id,
+  cwd: header2.cwd,
+  title: String(header2.title ?? ""),
+  model: String(header2.model ?? ""),
+  meta: header2.meta && typeof header2.meta === "object" ? header2.meta : {},
+  updatedAt: String(header2.updatedAt ?? "")
 } : void 0;
 class JsonlSessionStore {
   constructor(dir) {
@@ -4888,8 +5311,8 @@ class JsonlSessionStore {
   async save(record) {
     if (!VALID_ID.test(record.id)) throw new Error("Invalid session ID");
     const file2 = this.fileFor(record);
-    const { turns, ...header } = record;
-    const lines2 = [JSON.stringify({ type: "session", version: 1, ...header }), ...turns.map((turn) => JSON.stringify({ type: "turn", turn }))];
+    const { turns, ...header2 } = record;
+    const lines2 = [JSON.stringify({ type: "session", version: 1, ...header2 }), ...turns.map((turn) => JSON.stringify({ type: "turn", turn }))];
     await writeFileAtomic(file2, `${lines2.join("\n")}
 `, 384);
     const previous = this.files.get(record.id);
@@ -6292,7 +6715,8 @@ function nodeHost(setup, link) {
       config.saveSettings({ providers: { ...providers, [provider2.id]: { ...providers[provider2.id], model } } }).catch((error) => log?.(`Could not save the model: ${error.message}`));
     },
     get capabilities() {
-      return { fs: true, terminal: true, diagnostics: !!link.capabilities()._meta?.oxbit?.diagnostics, mcp: { http: true, sse: true } };
+      const client = link.capabilities();
+      return { fs: true, terminal: true, diagnostics: !!client._meta?.oxbit?.diagnostics, mcp: { http: true, sse: true }, childSessions: !!client.subagents };
     },
     filesystem: filesystemFor(root),
     filesystemFor,
@@ -6302,7 +6726,8 @@ function nodeHost(setup, link) {
     generateTitles: setup.generateTitles,
     configOptions: compactOptions2.configOptions,
     setConfigOption: (_session, configId, value2) => compactOptions2.setConfigOption(configId, value2),
-    extensions
+    extensions,
+    subagents: {}
   };
   const dispose = async () => {
     local.dispose();
@@ -6447,7 +6872,13 @@ ${USAGE}`);
     const settings = createSettingsManager(deps);
     const setup = (generateTitles, quiet = false) => ({ root: io.cwd, config, generateTitles, log: quiet ? void 0 : log, provider: provider2, settings });
     if (command === "acp") {
-      await serveStdio({ input: io.stdin, output: io.stdout, factory: agentFactory(setup(true)), log });
+      const rejected = (error) => log(`Unhandled rejection: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+      process.on("unhandledRejection", rejected);
+      try {
+        await serveStdio({ input: io.stdin, output: io.stdout, factory: agentFactory(setup(true)), log });
+      } finally {
+        process.off("unhandledRejection", rejected);
+      }
       return 0;
     }
     const sessionId = await resumeId(config, values, io.cwd);
@@ -6468,7 +6899,7 @@ ${USAGE}`);
       }
     }
     if (!io.stdout.isTTY) throw new UsageError("stdout is not a terminal. Use -p <prompt> for one reply or `oxbit-agent acp` for ACP");
-    const [tui, memory] = await Promise.all([import("./assets/index-T_6HaJx-.js"), import("./assets/memory-Bdy8hvTl.js")]);
+    const [tui, memory] = await Promise.all([import("./assets/index-hc_7c2Gx.js"), import("./assets/memory-Bdy8hvTl.js")]);
     const label = () => ({ provider: provider2.runtime.label, usingChatGPTPlan: provider2.runtime.method === "chatgpt" });
     const panels = createSettingsManager({ ...deps, rebuild: async (id2) => {
       await config.reload();