flavor-code 1.3.10 → 1.3.12

package/dist/{chunk-Y3DPUAEJ.js → chunk-QC5OYQTB.js}

@@ -12,7 +12,7 @@ import {
   redactConfig,
   setProjectMcpServerDisabled,
   updateProtectedFile
-} from "./chunk-IG4Z23CL.js";
+} from "./chunk-JFKRX2KG.js";
 import {
   AuditLogger,
   appendUsageLog,
@@ -1082,6 +1082,231 @@ function packageVersion() {
   throw new Error("package.json with a version field was not found");
 }
 
+// src/ui/char-width.ts
+function charWidth(codePoint) {
+  if (codePoint === 8203 || // ZERO WIDTH SPACE
+  codePoint === 8204 || // ZERO WIDTH NON-JOINER
+  codePoint === 8205 || // ZERO WIDTH JOINER
+  codePoint === 65279 || // BOM / ZERO WIDTH NO-BREAK SPACE
+  codePoint >= 768 && codePoint <= 879 || // Combining Diacritical Marks
+  codePoint >= 1155 && codePoint <= 1161 || // Cyrillic combining marks
+  codePoint >= 1425 && codePoint <= 1469 || // Hebrew combining marks
+  codePoint >= 1552 && codePoint <= 1562 || // Arabic combining marks
+  codePoint >= 1611 && codePoint <= 1631 || // Arabic combining marks
+  codePoint >= 1648 && codePoint <= 1648 || // Arabic combining marks
+  codePoint >= 1750 && codePoint <= 1756 || // Arabic combining marks
+  codePoint >= 1759 && codePoint <= 1764 || // Arabic combining marks
+  codePoint >= 1767 && codePoint <= 1768 || // Arabic combining marks
+  codePoint >= 1770 && codePoint <= 1773 || // Arabic combining marks
+  codePoint >= 1809 && codePoint <= 1809 || // Syriac combining marks
+  codePoint >= 1840 && codePoint <= 1866 || // Syriac combining marks
+  codePoint >= 1958 && codePoint <= 1968 || // Thaana combining marks
+  codePoint >= 2304 && codePoint <= 2306 || // Devanagari combining marks
+  codePoint >= 2362 && codePoint <= 2362 || // Devanagari combining marks
+  codePoint >= 2364 && codePoint <= 2364 || // Devanagari combining marks
+  codePoint >= 2369 && codePoint <= 2376 || // Devanagari combining marks
+  codePoint >= 2381 && codePoint <= 2381 || // Devanagari combining marks
+  codePoint >= 2385 && codePoint <= 2391 || // Devanagari combining marks
+  codePoint >= 2402 && codePoint <= 2403 || // Devanagari combining marks
+  codePoint >= 2433 && codePoint <= 2433 || // Bengali combining marks
+  codePoint >= 2492 && codePoint <= 2492 || // Bengali combining marks
+  codePoint >= 2497 && codePoint <= 2500 || // Bengali combining marks
+  codePoint >= 2509 && codePoint <= 2509 || // Bengali combining marks
+  codePoint >= 2530 && codePoint <= 2531 || // Bengali combining marks
+  codePoint >= 2561 && codePoint <= 2562 || // Gurmukhi combining marks
+  codePoint >= 2620 && codePoint <= 2620 || // Gurmukhi combining marks
+  codePoint >= 2625 && codePoint <= 2626 || // Gurmukhi combining marks
+  codePoint >= 2631 && codePoint <= 2632 || // Gurmukhi combining marks
+  codePoint >= 2635 && codePoint <= 2637 || // Gurmukhi combining marks
+  codePoint >= 2672 && codePoint <= 2673 || // Gurmukhi combining marks
+  codePoint >= 2689 && codePoint <= 2690 || // Gujarati combining marks
+  codePoint >= 2748 && codePoint <= 2748 || // Gujarati combining marks
+  codePoint >= 2753 && codePoint <= 2757 || // Gujarati combining marks
+  codePoint >= 2759 && codePoint <= 2760 || // Gujarati combining marks
+  codePoint >= 2765 && codePoint <= 2765 || // Gujarati combining marks
+  codePoint >= 2786 && codePoint <= 2787 || // Gujarati combining marks
+  codePoint >= 2817 && codePoint <= 2817 || // Oriya combining marks
+  codePoint >= 2876 && codePoint <= 2876 || // Oriya combining marks
+  codePoint >= 2879 && codePoint <= 2879 || // Oriya combining marks
+  codePoint >= 2881 && codePoint <= 2883 || // Oriya combining marks
+  codePoint >= 2893 && codePoint <= 2893 || // Oriya combining marks
+  codePoint >= 2902 && codePoint <= 2902 || // Oriya combining marks
+  codePoint >= 2946 && codePoint <= 2946 || // Tamil combining marks
+  codePoint >= 3008 && codePoint <= 3008 || // Tamil combining marks
+  codePoint >= 3021 && codePoint <= 3021 || // Tamil combining marks
+  codePoint >= 3134 && codePoint <= 3136 || // Telugu combining marks
+  codePoint >= 3142 && codePoint <= 3144 || // Telugu combining marks
+  codePoint >= 3146 && codePoint <= 3149 || // Telugu combining marks
+  codePoint >= 3157 && codePoint <= 3158 || // Telugu combining marks
+  codePoint >= 3260 && codePoint <= 3260 || // Kannada combining marks
+  codePoint >= 3263 && codePoint <= 3263 || // Kannada combining marks
+  codePoint >= 3270 && codePoint <= 3270 || // Kannada combining marks
+  codePoint >= 3276 && codePoint <= 3277 || // Kannada combining marks
+  codePoint >= 3298 && codePoint <= 3299 || // Kannada combining marks
+  codePoint >= 3393 && codePoint <= 3395 || // Malayalam combining marks
+  codePoint >= 3405 && codePoint <= 3405 || // Malayalam combining marks
+  codePoint >= 3530 && codePoint <= 3530 || // Sinhala combining marks
+  codePoint >= 3538 && codePoint <= 3540 || // Sinhala combining marks
+  codePoint >= 3542 && codePoint <= 3542 || // Sinhala combining marks
+  codePoint >= 3633 && codePoint <= 3633 || // Thai combining marks
+  codePoint >= 3636 && codePoint <= 3642 || // Thai combining marks
+  codePoint >= 3655 && codePoint <= 3662 || // Thai combining marks
+  codePoint >= 3761 && codePoint <= 3761 || // Lao combining marks
+  codePoint >= 3764 && codePoint <= 3769 || // Lao combining marks
+  codePoint >= 3771 && codePoint <= 3772 || // Lao combining marks
+  codePoint >= 3784 && codePoint <= 3789 || // Lao combining marks
+  codePoint >= 3864 && codePoint <= 3865 || // Tibetan combining marks
+  codePoint >= 3893 && codePoint <= 3893 || // Tibetan combining marks
+  codePoint >= 3895 && codePoint <= 3895 || // Tibetan combining marks
+  codePoint >= 3897 && codePoint <= 3897 || // Tibetan combining marks
+  codePoint >= 3953 && codePoint <= 3966 || // Tibetan combining marks
+  codePoint >= 3968 && codePoint <= 3972 || // Tibetan combining marks
+  codePoint >= 3974 && codePoint <= 3975 || // Tibetan combining marks
+  codePoint >= 3984 && codePoint <= 3991 || // Tibetan combining marks
+  codePoint >= 3993 && codePoint <= 4028 || // Tibetan combining marks
+  codePoint >= 4038 && codePoint <= 4038 || // Tibetan combining marks
+  codePoint >= 4146 && codePoint <= 4151 || // Myanmar combining marks
+  codePoint >= 4153 && codePoint <= 4154 || // Myanmar combining marks
+  codePoint >= 4157 && codePoint <= 4158 || // Myanmar combining marks
+  codePoint >= 4184 && codePoint <= 4185 || // Myanmar combining marks
+  codePoint >= 4190 && codePoint <= 4192 || // Myanmar combining marks
+  codePoint >= 4209 && codePoint <= 4212 || // Myanmar combining marks
+  codePoint >= 4226 && codePoint <= 4226 || // Myanmar combining marks
+  codePoint >= 4229 && codePoint <= 4230 || // Myanmar combining marks
+  codePoint >= 4237 && codePoint <= 4237 || // Myanmar combining marks
+  codePoint >= 4957 && codePoint <= 4959 || // Ethiopic combining marks
+  codePoint >= 5906 && codePoint <= 5908 || // Tagalog combining marks
+  codePoint >= 5938 && codePoint <= 5940 || // Hanunoo combining marks
+  codePoint >= 5970 && codePoint <= 5971 || // Buhid combining marks
+  codePoint >= 6002 && codePoint <= 6003 || // Tagbanwa combining marks
+  codePoint >= 6068 && codePoint <= 6069 || // Khmer combining marks
+  codePoint >= 6071 && codePoint <= 6077 || // Khmer combining marks
+  codePoint >= 6086 && codePoint <= 6086 || // Khmer combining marks
+  codePoint >= 6089 && codePoint <= 6099 || // Khmer combining marks
+  codePoint >= 6109 && codePoint <= 6109 || // Khmer combining marks
+  codePoint >= 6155 && codePoint <= 6157 || // Mongolian combining marks
+  codePoint >= 6313 && codePoint <= 6313 || // Mongolian combining marks
+  codePoint >= 6432 && codePoint <= 6434 || // Limbu combining marks
+  codePoint >= 6439 && codePoint <= 6440 || // Limbu combining marks
+  codePoint >= 6450 && codePoint <= 6450 || // Limbu combining marks
+  codePoint >= 6457 && codePoint <= 6459 || // Limbu combining marks
+  codePoint >= 6679 && codePoint <= 6680 || // Buginese combining marks
+  codePoint >= 6912 && codePoint <= 6915 || // Balinese combining marks
+  codePoint >= 6964 && codePoint <= 6964 || // Balinese combining marks
+  codePoint >= 6966 && codePoint <= 6970 || // Balinese combining marks
+  codePoint >= 6972 && codePoint <= 6972 || // Balinese combining marks
+  codePoint >= 6978 && codePoint <= 6978 || // Balinese combining marks
+  codePoint >= 7019 && codePoint <= 7027 || // Balinese combining marks
+  codePoint >= 7616 && codePoint <= 7679 || // Combining Diacritical Marks Supplement
+  codePoint >= 8400 && codePoint <= 8432 || // Combining Diacritical Marks for Symbols
+  codePoint >= 11503 && codePoint <= 11505 || // Coptic combining marks
+  codePoint >= 11647 && codePoint <= 11647 || // Tifinagh combining marks
+  codePoint >= 11744 && codePoint <= 11775 || // Cyrillic Extended-A combining marks
+  codePoint >= 42607 && codePoint <= 42610 || // Cyrillic Extended-B combining marks
+  codePoint >= 42612 && codePoint <= 42621 || // Cyrillic Extended-B combining marks
+  codePoint >= 42654 && codePoint <= 42655 || // Cyrillic Extended-B combining marks
+  codePoint >= 42736 && codePoint <= 42737 || // Bamum combining marks
+  codePoint >= 43010 && codePoint <= 43010 || // Syloti Nagri combining marks
+  codePoint >= 43014 && codePoint <= 43014 || // Syloti Nagri combining marks
+  codePoint >= 43019 && codePoint <= 43019 || // Syloti Nagri combining marks
+  codePoint >= 43045 && codePoint <= 43046 || // Syloti Nagri combining marks
+  codePoint >= 43204 && codePoint <= 43204 || // Saurashtra combining marks
+  codePoint >= 43232 && codePoint <= 43249 || // Devanagari Extended combining marks
+  codePoint >= 43302 && codePoint <= 43309 || // Kayah Li combining marks
+  codePoint >= 43335 && codePoint <= 43345 || // Rejang combining marks
+  codePoint >= 43392 && codePoint <= 43394 || // Javanese combining marks
+  codePoint >= 43443 && codePoint <= 43443 || // Javanese combining marks
+  codePoint >= 43446 && codePoint <= 43449 || // Javanese combining marks
+  codePoint >= 43452 && codePoint <= 43452 || // Javanese combining marks
+  codePoint >= 43561 && codePoint <= 43566 || // Cham combining marks
+  codePoint >= 43569 && codePoint <= 43570 || // Cham combining marks
+  codePoint >= 43573 && codePoint <= 43574 || // Cham combining marks
+  codePoint >= 43587 && codePoint <= 43587 || // Cham combining marks
+  codePoint >= 43596 && codePoint <= 43596 || // Cham combining marks
+  codePoint >= 43696 && codePoint <= 43696 || // Tai Viet combining marks
+  codePoint >= 43698 && codePoint <= 43700 || // Tai Viet combining marks
+  codePoint >= 43703 && codePoint <= 43704 || // Tai Viet combining marks
+  codePoint >= 43710 && codePoint <= 43711 || // Tai Viet combining marks
+  codePoint >= 43713 && codePoint <= 43713 || // Tai Viet combining marks
+  codePoint >= 44005 && codePoint <= 44005 || // Meetei Mayek combining marks
+  codePoint >= 44008 && codePoint <= 44008 || // Meetei Mayek combining marks
+  codePoint >= 44013 && codePoint <= 44013 || // Meetei Mayek combining marks
+  codePoint >= 64286 && codePoint <= 64286 || // Hebrew combining marks
+  codePoint >= 65024 && codePoint <= 65039 || // Variation Selectors
+  codePoint >= 65056 && codePoint <= 65071 || // Combining Half Marks
+  codePoint >= 917760 && codePoint <= 917999) {
+    return 0;
+  }
+  if (codePoint >= 4352 && codePoint <= 4447 || // Hangul Jamo
+  codePoint >= 9001 && codePoint <= 9002 || // Left/Right-pointing angle bracket
+  codePoint >= 11904 && codePoint <= 12350 || // CJK Radicals Supplement, Kangxi Radicals, CJK Symbols
+  codePoint >= 12352 && codePoint <= 13247 || // Hiragana, Katakana, Bopomofo, Hangul Compatibility, Kanbun, CJK Strokes, Enclosed CJK
+  codePoint >= 13312 && codePoint <= 19903 || // CJK Unified Ideographs Extension A
+  codePoint >= 19968 && codePoint <= 42191 || // CJK Unified Ideographs, Yi Syllables, Yi Radicals
+  codePoint >= 43360 && codePoint <= 43388 || // Hangul Jamo Extended-A
+  codePoint >= 44032 && codePoint <= 55203 || // Hangul Syllables
+  codePoint >= 63744 && codePoint <= 64255 || // CJK Compatibility Ideographs
+  codePoint >= 65040 && codePoint <= 65049 || // Vertical forms
+  codePoint >= 65072 && codePoint <= 65135 || // CJK Compatibility Forms, Small Form Variants
+  codePoint >= 65281 && codePoint <= 65376 || // Fullwidth Forms
+  codePoint >= 65504 && codePoint <= 65510 || // Fullwidth Signs
+  codePoint >= 110592 && codePoint <= 111359 || // Kana Supplement, Kana Extended-A, Small Kana Extension
+  codePoint >= 126980 && codePoint <= 126980 || // Mahjong tile
+  codePoint >= 127183 && codePoint <= 127183 || // Playing card
+  codePoint >= 127232 && codePoint <= 129535 || // Enclosed Alphanumeric Supplement, Emoticons, Transport, etc.
+  codePoint >= 129536 && codePoint <= 129647 || // Chess Symbols
+  codePoint >= 129648 && codePoint <= 129791 || // Symbols and Pictographs Extended-A
+  codePoint >= 131072 && codePoint <= 196605 || // CJK Unified Ideographs Extension B–G, CJK Compatibility Supplement
+  codePoint >= 196608 && codePoint <= 262141) {
+    return 2;
+  }
+  return 1;
+}
+
+// src/ui/thinking-line.ts
+var THINKING_SCROLL_CELLS_PER_SEC = 16;
+var THINKING_EASE = 0.18;
+var THINKING_MAX_STEP_MS = 250;
+var THINKING_MAX_STORED_CHARS = 4e3;
+function normalizeThinkingText(text) {
+  return text.replace(/\s+/gu, " ").trim();
+}
+function thinkingDisplayWidth(text) {
+  let width = 0;
+  for (const character of text) width += charWidth(character.codePointAt(0) ?? 32);
+  return width;
+}
+function sliceThinkingByWidth(text, startCell, cellCount) {
+  let out = "";
+  let cell = 0;
+  for (const character of text) {
+    const w = charWidth(character.codePointAt(0) ?? 32);
+    if (cell + w > startCell && cell < startCell + cellCount) out += character;
+    cell += w;
+    if (cell >= startCell + cellCount) break;
+  }
+  return out;
+}
+function thinkingWindow(text, previousStart, options) {
+  const normalized = normalizeThinkingText(text);
+  const width = Math.max(1, Math.floor(options.width));
+  const total = thinkingDisplayWidth(normalized);
+  if (total <= width) return { text: normalized, start: 0 };
+  const maxStart = total - width;
+  const from = Math.min(Math.max(0, previousStart), maxStart);
+  const cellsPerSecond = options.cellsPerSecond ?? THINKING_SCROLL_CELLS_PER_SEC;
+  const ease = options.ease ?? THINKING_EASE;
+  const dt = Math.max(0, Math.min(options.dtMs, THINKING_MAX_STEP_MS));
+  const lag = maxStart - from;
+  const step = Math.max(cellsPerSecond * dt / 1e3, lag * ease);
+  const start = Math.min(maxStart, Math.floor(from + step));
+  return { text: sliceThinkingByWidth(normalized, start, width), start };
+}
+function appendThinkingText(previous, delta) {
+  const next = (previous ?? "") + delta;
+  return next.length > THINKING_MAX_STORED_CHARS ? next.slice(-THINKING_MAX_STORED_CHARS) : next;
+}
+
 // src/ui/transcript.ts
 function createTranscriptState() {
   return { completed: [], nextId: 1 };
@@ -1178,6 +1403,9 @@ function transcriptReducer(state, action) {
   if (event.type === "text") {
     return { ...state, active: addText(withoutModelActivity(state.active), event.text) };
   }
+  if (event.type === "thinking") {
+    return { ...state, active: attachThinking(state.active, event.text) };
+  }
   if (event.type === "tool-start") return upsertStatus({ ...state, active: withoutModelActivity(state.active) }, {
     kind: "status",
     id: `tool:${event.id}`,
@@ -1478,6 +1706,18 @@ function finishActive(state) {
     ...state.taskSnapshot === void 0 ? {} : { taskSnapshot: state.taskSnapshot }
   };
 }
+function attachThinking(turn, text) {
+  const blocks = [...turn.blocks];
+  const index = blocks.findIndex((block2) => block2.kind === "status" && block2.activity === "model" && block2.state === "running");
+  if (index < 0) return turn;
+  const block = blocks[index];
+  if (block === void 0 || block.kind !== "status") return turn;
+  blocks[index] = {
+    ...block,
+    thinkingText: appendThinkingText(block.thinkingText, text)
+  };
+  return { ...turn, blocks };
+}
 function withoutModelActivity(turn, id) {
   const blocks = turn.blocks.filter((block) => block.kind !== "status" || block.activity !== "model" || id !== void 0 && block.id !== id);
   if (blocks.length === turn.blocks.length) return turn;
@@ -2996,7 +3236,8 @@ var MVP_COMMANDS = [
   "fork",
   "pals",
   "chat",
-  "co-work"
+  "co-work",
+  "tool"
 ];
 var COMMAND_DESCRIPTIONS = {
   model: "Switch the active model",
@@ -3034,16 +3275,24 @@ var COMMAND_DESCRIPTIONS = {
   fork: "Continue context from a prior session node",
   pals: "List, rename, or inspect active Flavor pals",
   chat: "Send a task to another Flavor pal",
-  "co-work": "Coordinate a shared goal with another Flavor pal"
+  "co-work": "Coordinate a shared goal with another Flavor pal",
+  tool: "Run a registered managed tool with a JSON object"
 };
-function parseSlashCommand(input, dynamicCommands = [], skillCommands = []) {
+function parseSlashCommand(input, dynamicCommands = [], skillCommands = [], managedTools = []) {
   const trimmed = input.trim();
   if (!trimmed.startsWith("/")) return null;
-  const [rawName = "", ...args] = trimmed.slice(1).split(/\s+/);
+  const match = /^(\S+)(?:\s+([\s\S]*))?$/u.exec(trimmed.slice(1));
+  const rawName = match?.[1] ?? "";
+  const rawArguments = match?.[2] ?? "";
+  const args = rawArguments.length === 0 ? [] : rawArguments.split(/\s+/u);
   const name = rawName.toLowerCase();
   if (!MVP_COMMANDS.includes(name) && dynamicCommands.includes(name)) {
     return { name: "plugin", command: name, args };
   }
+  if (!MVP_COMMANDS.includes(name)) {
+    const managedTool = managedTools.find((tool) => tool.toLowerCase() === name);
+    if (managedTool !== void 0) return { name: "managed-tool", tool: managedTool, input: rawArguments };
+  }
   if (!MVP_COMMANDS.includes(name) && skillCommands.includes(name)) {
     return { name: "skill", skill: name, prompt: args.join(" ") };
   }
@@ -3065,6 +3314,15 @@ function parseSlashCommand(input, dynamicCommands = [], skillCommands = []) {
     }
     return { name, mode: normalized };
   }
+  if (name === "tool") {
+    const [requested] = args;
+    const managedTool = requested === void 0 ? void 0 : managedTools.find((candidate) => candidate.toLowerCase() === requested.toLowerCase());
+    if (managedTool === void 0) {
+      return { name: "invalid", command: name, message: "Use /tool <registered-tool> [JSON object]." };
+    }
+    const inputStart = rawArguments.search(/\s/u);
+    return { name: "managed-tool", tool: managedTool, input: inputStart < 0 ? "" : rawArguments.slice(inputStart).trimStart() };
+  }
   if (name === "audit") {
     const toolFilter = args.length > 0 ? args.join(" ") : void 0;
     return { name, toolFilter };
@@ -3292,6 +3550,7 @@ var HELP = [
   "/review [focus]                         review uncommitted changes before committing",
   "/evolve <signals|suggest|improve <id>|verify <name>|reload <name>|test|revert <name>|done <id>>  self-improvement loop",
   "/mcp [status|tools|reconnect|enable|disable]  manage MCP servers",
+  "/tool <registered-tool> [JSON object]      run a registered tool (or use /<tool-name>)",
   "/ide                                     show VS Code connection and cursor/selection",
   "/pals [--verbose|rename <alias>|info <alias-or-uuid>]",
   "/chat <alias-or-uuid> <goal>             send a task that starts on the receiving pal",
@@ -3563,7 +3822,12 @@ var FlavorSession = class {
         } catch {
         }
       }
-      const command = parseSlashCommand(prompt, this.#services.pluginCommands().map(({ name }) => name), skillNames);
+      const command = parseSlashCommand(
+        prompt,
+        this.#services.pluginCommands().map(({ name }) => name),
+        skillNames,
+        this.#services.managedToolCommands().map(({ name }) => name)
+      );
       if (command !== null) await this.#dispatch(command, controller.signal);
       else for await (const event of this.#services.run(prompt, controller.signal, {
         getSteeringMessages: () => this.#drainMessages("steer", true).map((item) => item.text),
@@ -3665,6 +3929,8 @@ var FlavorSession = class {
       this.#notice(`Main permissions set to ${command.mode}. Child approvals use bubble mode unless plan mode is active.`);
     } else if (command.name === "plugin") {
       this.#notice(format(await this.#services.runPluginCommand(command.command, command.args, signal)));
+    } else if (command.name === "managed-tool") {
+      this.#notice(format(await this.#services.runManagedTool(command.tool, command.input, signal)));
     } else if (command.name === "skill") {
       for await (const event of this.#services.runSkill(command.skill, command.prompt, signal)) this.#services.output(event);
     } else if (command.name === "loop") {
@@ -6315,7 +6581,12 @@ function providerValidMessages(input) {
       const calls = original.toolCalls.filter((call) => call.id && call.name && availableResults.has(call.id));
       calls.forEach((call) => announced.add(call.id));
       if (!original.content && calls.length === 0) continue;
-      output.push({ role: "assistant", content: original.content, ...calls.length === 0 ? {} : { toolCalls: calls.map((call) => ({ ...call })) } });
+      output.push({
+        role: "assistant",
+        content: original.content,
+        ...calls.length === 0 ? {} : { toolCalls: calls.map((call) => ({ ...call })) },
+        ...original.thinkingBlocks === void 0 ? {} : { thinkingBlocks: original.thinkingBlocks.map((block) => ({ ...block })) }
+      });
       continue;
     }
     if (original.role === "tool") {
@@ -6536,9 +6807,10 @@ function withStructuredOutput(options) {
       throw new Error("Structured output retry delays must be non-negative integers");
     }
   }
-  const tool = modelToolFromZod(options.name, options.description, options.schema);
+  const generatedTool = options.modelInputSchema === void 0 ? modelToolFromZod(options.name, options.description, options.schema) : { name: options.name, description: options.description, inputSchema: options.modelInputSchema };
+  const tool = options.modelStrict === void 0 ? generatedTool : { ...generatedTool, strict: options.modelStrict };
   const maxAttempts = retry.maxRetries + 1;
-  const jsonSchema = tool.inputSchema;
+  const validationSchema = jsonSchemaFromZod(options.schema);
   const model = {
     async *stream(request) {
       let candidate;
@@ -6611,7 +6883,7 @@ function withStructuredOutput(options) {
             }
           }
           if (candidateCount === 1 && candidate !== null && typeof candidate === "object") {
-            candidate = coerceByJsonSchema(candidate, jsonSchema);
+            candidate = coerceByJsonSchema(candidate, validationSchema);
           }
           if (candidateCount !== 1) {
             attemptError = {
@@ -6683,7 +6955,13 @@ function withStructuredOutput(options) {
   return model;
 }
 function strictJsonSchema(schema) {
-  return ensureStrictSchema(z7.toJSONSchema(schema));
+  return strictJsonSchemaObject(jsonSchemaFromZod(schema));
+}
+function jsonSchemaFromZod(schema) {
+  return z7.toJSONSchema(schema);
+}
+function strictJsonSchemaObject(schema) {
+  return ensureStrictSchema(schema);
 }
 function extractJsonObject(text) {
   const trimmed = text.trim();
@@ -6731,6 +7009,7 @@ function coerceByJsonSchema(value, schema) {
   const node = schema;
   const branches = [
     ...Array.isArray(node.anyOf) ? node.anyOf : [],
+    ...Array.isArray(node.oneOf) ? node.oneOf : [],
     ...Array.isArray(node.allOf) ? node.allOf : []
   ].filter((branch) => branch !== null && typeof branch === "object");
   const types = [];
@@ -6750,40 +7029,108 @@ function coerceByJsonSchema(value, schema) {
     if (lowered === "true") return true;
     if (lowered === "false") return false;
   }
+  if (types.includes("object") && !types.includes("string") && typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+          return coerceByJsonSchema(parsed, node);
+        }
+      } catch {
+      }
+    }
+  }
+  if (types.includes("array") && !Array.isArray(value) && value !== null && value !== void 0 && !types.some((type) => matchesJsonSchemaType(value, type))) {
+    const arraySchema = [node, ...branches].find((candidate) => {
+      const type = candidate.type;
+      return type === "array" || Array.isArray(type) && type.includes("array");
+    });
+    if (typeof value === "string" && value.trim().startsWith("[")) {
+      try {
+        const parsed = JSON.parse(value.trim());
+        if (Array.isArray(parsed)) return coerceByJsonSchema(parsed, arraySchema ?? node);
+      } catch {
+      }
+    }
+    return [arraySchema?.items === void 0 ? value : coerceByJsonSchema(value, arraySchema.items)];
+  }
   if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-    const properties = node.properties ?? branches.find((branch) => branch.properties)?.properties;
+    const objectSchema = [node, ...branches].find((candidate) => candidate.type === "object" || candidate.properties !== void 0);
+    const properties = objectSchema?.properties;
     if (properties !== void 0) {
       const output = {};
+      const required2 = new Set(Array.isArray(objectSchema?.required) ? objectSchema.required : []);
       for (const [key, child] of Object.entries(value)) {
-        output[key] = properties[key] !== void 0 ? coerceByJsonSchema(child, properties[key]) : child;
+        const childSchema = properties[key];
+        if (child === null && childSchema !== void 0 && !required2.has(key) && !jsonSchemaAllowsNull(childSchema)) {
+          continue;
+        }
+        output[key] = childSchema !== void 0 ? coerceByJsonSchema(child, childSchema) : child;
       }
       return output;
     }
   }
-  if (types.includes("array") && Array.isArray(value) && node.items !== void 0) {
-    return value.map((item) => coerceByJsonSchema(item, node.items));
+  if (types.includes("array") && Array.isArray(value)) {
+    const arraySchema = [node, ...branches].find((candidate) => {
+      const type = candidate.type;
+      return type === "array" || Array.isArray(type) && type.includes("array");
+    });
+    if (arraySchema?.items !== void 0) {
+      return value.map((item) => coerceByJsonSchema(item, arraySchema.items));
+    }
   }
   return value;
 }
+function matchesJsonSchemaType(value, type) {
+  if (type === "null") return value === null;
+  if (type === "array") return Array.isArray(value);
+  if (type === "object") return value !== null && typeof value === "object" && !Array.isArray(value);
+  if (type === "integer") return typeof value === "number" && Number.isInteger(value);
+  if (type === "number") return typeof value === "number";
+  return typeof value === type;
+}
+function jsonSchemaAllowsNull(schema) {
+  if (schema === null || typeof schema !== "object") return false;
+  const node = schema;
+  if (node.type === "null" || Array.isArray(node.type) && node.type.includes("null")) return true;
+  return [node.anyOf, node.oneOf].some((branches) => Array.isArray(branches) && branches.some((branch) => jsonSchemaAllowsNull(branch)));
+}
 function modelToolFromZod(name, description, schema) {
   return { name, description, inputSchema: strictJsonSchema(schema) };
 }
 function ensureStrictSchema(schema) {
+  const output = { ...schema };
+  for (const keyword of ["anyOf", "oneOf", "allOf", "prefixItems"]) {
+    const branches = schema[keyword];
+    if (Array.isArray(branches)) {
+      output[keyword] = branches.map((branch) => typeof branch === "object" && branch !== null ? ensureStrictSchema(branch) : branch);
+    }
+  }
+  if (typeof schema.items === "object" && schema.items !== null) {
+    output.items = ensureStrictSchema(schema.items);
+  }
+  for (const keyword of ["$defs", "definitions"]) {
+    const definitions = schema[keyword];
+    if (typeof definitions === "object" && definitions !== null && !Array.isArray(definitions)) {
+      output[keyword] = Object.fromEntries(Object.entries(definitions).map(([key, definition]) => [
+        key,
+        typeof definition === "object" && definition !== null ? ensureStrictSchema(definition) : definition
+      ]));
+    }
+  }
   if (schema.type !== "object" || typeof schema.properties !== "object" || schema.properties === null) {
-    return schema;
+    return output;
   }
-  const required2 = Array.isArray(schema.required) ? [...schema.required] : [];
-  const requiredSet = new Set(required2);
+  const requiredSet = new Set(Array.isArray(schema.required) ? schema.required : []);
   const properties = {};
   for (const [key, value] of Object.entries(schema.properties)) {
     const child = typeof value === "object" && value !== null ? ensureStrictSchema(value) : value;
-    if (requiredSet.has(key)) properties[key] = child;
-    else {
-      properties[key] = { anyOf: [child, { type: "null" }] };
-      requiredSet.add(key);
-    }
+    if (requiredSet.has(key) || jsonSchemaAllowsNull(child)) properties[key] = child;
+    else properties[key] = { anyOf: [child, { type: "null" }] };
+    requiredSet.add(key);
   }
-  return { ...schema, additionalProperties: false, required: [...requiredSet], properties };
+  return { ...output, additionalProperties: false, required: [...requiredSet], properties };
 }
 function repairMessages(messages, tool, original, candidate, error) {
   const details = [
@@ -6962,6 +7309,7 @@ var AgentLoop = class {
       }
       let assistantText = "";
       const collectedToolCalls = [];
+      const collectedThinking = [];
       let completed = false;
       let reactiveRetried = false;
       let attempt = 1;
@@ -6999,6 +7347,7 @@ var AgentLoop = class {
         }
         assistantText = "";
         collectedToolCalls.length = 0;
+        collectedThinking.length = 0;
         completed = false;
         let terminalError;
         let providerError = false;
@@ -7019,6 +7368,10 @@ var AgentLoop = class {
               assistantText += event.text;
               accumulatedText += event.text;
               yield event;
+            } else if (event.type === "thinking") {
+              yield event;
+            } else if (event.type === "thinking-block") {
+              collectedThinking.push({ text: event.text, ...event.signature === void 0 ? {} : { signature: event.signature } });
             } else if (event.type === "tool-call") {
               collectedToolCalls.push({ kind: "valid", id: event.id, name: event.name, input: event.input });
             } else if (event.type === "invalid-tool-call") {
@@ -7153,19 +7506,11 @@ var AgentLoop = class {
           });
           continue;
         }
-        const validation = collected.kind === "valid" ? this.#options.runtime.validate(collected) : { ok: false, error: collected.error };
+        const validation = collected.kind === "valid" ? this.#options.runtime.normalize(collected) : { ok: false, error: collected.error };
         if (validation.ok) {
           toolCalls.push({ id: collected.id, name: collected.name, input: validation.input });
           continue;
         }
-        if (collected.kind === "valid") {
-          const coerced = coerceByJsonSchema(collected.input, strictJsonSchema(definition.inputSchema));
-          const revalidation = this.#options.runtime.validate({ ...collected, input: coerced });
-          if (revalidation.ok) {
-            toolCalls.push({ id: collected.id, name: collected.name, input: revalidation.input });
-            continue;
-          }
-        }
         const repairModelId = this.#options.fallbackModelId ?? this.#options.modelId;
         const invalidOutput = collected.kind === "invalid" ? collected.rawInput : serializeToolInput(collected.input);
         const structured = withStructuredOutput({
@@ -7174,6 +7519,8 @@ var AgentLoop = class {
           name: definition.name,
           description: definition.description,
           schema: definition.inputSchema,
+          ...definition.modelInputSchema === void 0 ? {} : { modelInputSchema: definition.modelInputSchema },
+          ...definition.modelStrict === void 0 ? {} : { modelStrict: definition.modelStrict },
           beforeAttempt: async ({ attempt: repairAttempt, maxAttempts: repairMaxAttempts, messageCount }) => {
             const before = await this.#options.hooks.emit({
               version: 1,
@@ -7372,7 +7719,8 @@ var AgentLoop = class {
       const assistantMessage = {
         role: "assistant",
         content: assistantText,
-        toolCalls: toolCalls.map(({ id, name, input }) => ({ id, name, input }))
+        toolCalls: toolCalls.map(({ id, name, input }) => ({ id, name, input })),
+        ...collectedThinking.length === 0 ? {} : { thinkingBlocks: collectedThinking.map((block) => ({ ...block })) }
       };
       this.#options.context.appendMany([assistantMessage, ...stagedMessages]);
       for (const { call, result } of stagedResults) {
@@ -7654,12 +8002,24 @@ var ToolRuntime = class {
       throw error;
     }
   }
+  /**
+   * Validates a call and applies the same conservative provider-argument
+   * normalization used by the agent loop before falling back to repair.
+   */
+  normalize(call) {
+    const validation = this.validate(call);
+    if (validation.ok || validation.error.code === "unknown_tool") return validation;
+    const tool = this.#tools.get(call.name);
+    if (tool === void 0) return validation;
+    const input = coerceByJsonSchema(call.input, jsonSchemaFromZod(tool.inputSchema));
+    return this.validate({ ...call, input });
+  }
   async #execute(call, context) {
     const tool = this.#tools.get(call.name);
     if (tool === void 0) return { ok: false, error: { code: "unknown_tool", message: `Unknown tool: ${call.name}` } };
     const signal = context.signal ?? new AbortController().signal;
     const toolCallId = call.id ?? randomUUID7();
-    const validation = this.validate(call);
+    const validation = this.normalize(call);
     if (!validation.ok) {
       return this.#fail(toolCallId, call.name, call.input, context.agent, validation.error.code, validation.error.message);
     }
@@ -9388,6 +9748,7 @@ var PluginHost = class {
             description: contribution.description,
             inputSchema: z13.unknown(),
             ...contribution.modelInputSchema === void 0 ? {} : { modelInputSchema: contribution.modelInputSchema },
+            ...contribution.modelInputSchema === void 0 ? {} : { modelStrict: false },
             ...contribution.readOnly === void 0 ? {} : { readOnly: contribution.readOnly },
             paths: () => [],
             execute: (input, _signal, toolContext) => session.invoke("tool", contribution.name, [
@@ -12616,6 +12977,7 @@ var CLAUDE_CLIENT_HEADERS = {
   "x-app": "cli"
 };
 var DEFAULT_MAX_OUTPUT_TOKENS = 32768;
+var DEFAULT_THINKING_BUDGET = 8192;
 var MAX_CACHE_MARKERS = 4;
 function collectCacheMarkers(system, messages) {
   const markers = [];
@@ -12674,9 +13036,26 @@ function formatCacheUsage(model, snapshot4, shape) {
     ...shape === void 0 ? {} : { requestMessages: shape.messages, requestMarkers: shape.markers }
   });
 }
+function stripThinkingBlocks(messages) {
+  for (const message2 of messages) {
+    if (message2.role !== "assistant" || !Array.isArray(message2.content)) continue;
+    const blocks = message2.content;
+    if (!blocks.some((block) => block?.type === "thinking")) continue;
+    message2.content = blocks.filter((block) => block?.type !== "thinking");
+  }
+}
+function isThinkingParamRejected(error) {
+  const status = error?.status;
+  if (status !== void 0 && status !== 400) return false;
+  const message2 = error instanceof Error ? error.message : String(error ?? "");
+  return /\bthinking\b/iu.test(message2) && /(budget_tokens|expected|not supported|unsupported|unknown|invalid|extra inputs|unrecognized)/iu.test(message2);
+}
 var AnthropicModelAdapter = class {
   client;
   maxOutputTokens;
+  thinkingBudget;
+  /** Set once an endpoint rejects the `thinking` parameter; later requests stop sending it. */
+  #thinkingRejected = false;
   debugUsage;
   constructor(options) {
     const maxOutputTokens = options.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
@@ -12684,6 +13063,7 @@ var AnthropicModelAdapter = class {
       throw new Error("maxOutputTokens must be a positive integer");
     }
     this.maxOutputTokens = maxOutputTokens;
+    this.thinkingBudget = options.thinkingBudget ?? DEFAULT_THINKING_BUDGET;
     this.debugUsage = options.debugUsage ?? isEnvTruthy(process.env.FLAVOR_DEBUG_USAGE);
     this.client = options.client ?? new Anthropic({
       ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
@@ -12691,6 +13071,16 @@ var AnthropicModelAdapter = class {
       ...options.headers === void 0 ? {} : { defaultHeaders: options.headers }
     });
   }
+  /**
+   * Extended-thinking request parameter when enabled, otherwise undefined.
+   * Anthropic requires the budget to fit inside max_tokens with a 1024 floor.
+   */
+  #thinkingParam() {
+    if (this.#thinkingRejected || this.thinkingBudget <= 0) return void 0;
+    const budget = Math.min(this.thinkingBudget, this.maxOutputTokens - 1);
+    if (budget < 1024) return void 0;
+    return { type: "enabled", budget_tokens: budget };
+  }
   #logUsage(request, snapshot4, shape) {
     const line = formatCacheUsage(request.model, snapshot4, shape);
     if (this.debugUsage) {
@@ -12746,7 +13136,13 @@ var AnthropicModelAdapter = class {
           }
           messages.push({ role: "user", content: results });
         } else if (message2.role === "assistant" && message2.toolCalls?.length) {
+          const echoThinking = this.#thinkingRejected ? [] : (message2.thinkingBlocks ?? []).filter((block) => block.signature !== void 0);
           const content = [
+            ...echoThinking.map((block) => ({
+              type: "thinking",
+              thinking: block.text,
+              signature: block.signature
+            })),
             ...modelContentText(message2.content) ? [{ type: "text", text: modelContentText(message2.content) }] : [],
             ...message2.toolCalls.map((call) => ({
               type: "tool_use",
@@ -12808,18 +13204,56 @@ var AnthropicModelAdapter = class {
         stream: true,
         messages,
         ...system ? { system } : {},
+        ...(() => {
+          const thinking = this.#thinkingParam();
+          return thinking === void 0 ? {} : { thinking };
+        })(),
         tools: [...request.tools].sort((a, b) => a.name.localeCompare(b.name)).map((tool) => ({
           name: tool.name,
           description: tool.description,
           input_schema: { ...tool.inputSchema, type: "object" }
         }))
       };
-      const stream = await this.client.messages.create(body, { signal: request.signal });
+      let stream;
+      try {
+        stream = await this.client.messages.create(body, { signal: request.signal });
+      } catch (error) {
+        if (this.thinkingBudget > 0 && !this.#thinkingRejected && isThinkingParamRejected(error)) {
+          this.#thinkingRejected = true;
+          delete body.thinking;
+          stripThinkingBlocks(body.messages);
+          stream = await this.client.messages.create(body, { signal: request.signal });
+        } else {
+          throw error;
+        }
+      }
+      const thinkingBuffers = /* @__PURE__ */ new Map();
       for await (const event of stream) {
         if (event.type === "message_start") {
           hasUsage = event.message?.usage !== void 0;
           inputTokens = updateInputUsage(inputUsage, event.message?.usage);
           outputTokens = event.message?.usage?.output_tokens ?? outputTokens;
+        } else if (event.type === "content_block_start" && event.content_block?.type === "thinking" && event.index !== void 0) {
+          thinkingBuffers.set(event.index, { text: "" });
+        } else if (event.type === "content_block_delta" && event.delta?.type === "thinking_delta") {
+          if (event.index !== void 0 && event.delta.thinking) {
+            const pending = thinkingBuffers.get(event.index);
+            if (pending) pending.text += event.delta.thinking;
+          }
+          if (event.delta.thinking) yield { type: "thinking", text: event.delta.thinking };
+        } else if (event.type === "content_block_delta" && event.delta?.type === "signature_delta" && event.index !== void 0) {
+          const pending = thinkingBuffers.get(event.index);
+          if (pending) pending.signature = (pending.signature ?? "") + (event.delta.signature ?? "");
+        } else if (event.type === "content_block_stop" && event.index !== void 0 && thinkingBuffers.has(event.index)) {
+          const pending = thinkingBuffers.get(event.index);
+          if (pending.text.length > 0 || pending.signature !== void 0) {
+            yield {
+              type: "thinking-block",
+              text: pending.text,
+              ...pending.signature === void 0 ? {} : { signature: pending.signature }
+            };
+          }
+          thinkingBuffers.delete(event.index);
         } else if (event.type === "content_block_start" && event.content_block?.type === "tool_use" && event.index !== void 0 && event.content_block.id && event.content_block.name) {
           pendingTools.set(event.index, {
             id: event.content_block.id,
@@ -13022,12 +13456,14 @@ function formatOpenAIUsage(model, breakdown) {
 var OpenAIModelAdapter = class {
   client;
   debugUsage;
+  thinkingEffort;
   constructor(options) {
     this.client = options.client ?? new OpenAI({
       ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
       ...options.baseURL === void 0 ? {} : { baseURL: options.baseURL }
     });
     this.debugUsage = options.debugUsage ?? isEnvTruthy(process.env.FLAVOR_DEBUG_USAGE);
+    this.thinkingEffort = options.thinkingEffort;
   }
   #logUsage(model, breakdown) {
     if (breakdown === void 0) return;
@@ -13049,6 +13485,7 @@ var OpenAIModelAdapter = class {
       const body = {
         model: request.model,
         input: (await Promise.all(request.messages.map(toInput))).flat(),
+        ...this.thinkingEffort === void 0 ? {} : { reasoning: { effort: this.thinkingEffort } },
         tools: [...request.tools].sort((a, b) => a.name.localeCompare(b.name)).map((tool) => ({
           type: "function",
           name: tool.name,
@@ -13081,6 +13518,8 @@ var OpenAIModelAdapter = class {
           }
         } else if (event.type === "response.output_text.delta" && event.delta) {
           yield { type: "text", text: event.delta };
+        } else if ((event.type === "response.reasoning_summary_text.delta" || event.type === "response.reasoning_text.delta") && event.delta) {
+          yield { type: "thinking", text: event.delta };
         } else if (event.type === "response.function_call_arguments.done" && event.output_index !== void 0 && event.name) {
           const callId = callIds.get(event.output_index);
           if (callId && !emittedCalls.has(event.output_index)) {
@@ -17795,7 +18234,7 @@ function compileDefinition(record, scope2, workspace) {
     name: record.name,
     description: record.description,
     inputSchema,
-    modelInputSchema: record.inputSchema,
+    modelInputSchema: strictJsonSchemaObject(record.inputSchema),
     modelStrict: true,
     ...record.agents === void 0 ? {} : { agents: record.agents },
     paths: () => [],
@@ -20859,6 +21298,7 @@ async function createProductionRuntime(options) {
       managedTools.push(tool);
     }
     if (harnessCreated) harness.replaceMainTools(tools);
+    options.onToolsChange?.();
   };
   tools.push(...createManagedToolManagementTools({
     store: managedToolStore,
@@ -22188,6 +22628,25 @@ ${renderMemoryDocument(entries)}`;
         signal.throwIfAborted();
         return awaitWithSignal(Promise.resolve(handler(args, { workspace, signal })), signal);
       },
+      managedToolCommands: () => managedTools.map(({ name, description }) => ({ name, description })).sort((left, right) => left.name.localeCompare(right.name)),
+      runManagedTool: async (name, rawInput, signal) => {
+        const tool = managedTools.find((candidate) => sameToolName(candidate.name, name));
+        if (tool === void 0) throw new Error(`Registered tool "${name}" is no longer available.`);
+        signal.throwIfAborted();
+        const input = normalizeToolCallInput(rawInput);
+        const call = { name: tool.name, input };
+        const validation = harness.main.runtime.normalize(call);
+        if (!validation.ok) throw new Error(`Invalid input for registered tool "${tool.name}": ${validation.error.message}`);
+        harness.main.runtime.beginTurn();
+        const result = await harness.main.runtime.execute(
+          { name: tool.name, input: validation.input },
+          { agent: "main", ownerId: "main", signal }
+        );
+        if (!result.ok) {
+          throw new Error(`Registered tool "${tool.name}" failed (${result.error?.code ?? "unknown"}): ${result.error?.message ?? "Unknown error"}`);
+        }
+        return result.output !== void 0 ? result.output : result.content;
+      },
       output: emitOutput,
       questions,
       async login() {
@@ -22238,8 +22697,12 @@ ${renderMemoryDocument(entries)}`;
           };
           registry.register(next.providerId, next.apiType === "anthropic" ? new AnthropicModelAdapter({
             ...adapterOptions,
+            ...providerConfig?.thinkingBudget === void 0 ? {} : { thinkingBudget: providerConfig.thinkingBudget },
             ...providerConfig?.claudeClient === true ? { headers: CLAUDE_CLIENT_HEADERS } : {}
-          }) : new OpenAIModelAdapter(adapterOptions));
+          }) : new OpenAIModelAdapter({
+            ...adapterOptions,
+            ...providerConfig?.thinkingEffort === void 0 ? {} : { thinkingEffort: providerConfig.thinkingEffort }
+          }));
           effectiveLlm = next;
           mainModel = `${next.providerId}:${next.defaultModel}`;
           childModel = `${next.providerId}:${next.cheapModel}`;
@@ -22825,8 +23288,12 @@ async function registerConfiguredAdapters(providers, registry, environment, diag
       };
       const adapter = apiProtocol === "anthropic" ? new AnthropicModelAdapter({
         ...adapterOptions,
+        ...runtimeProvider.thinkingBudget === void 0 ? {} : { thinkingBudget: runtimeProvider.thinkingBudget },
         ...runtimeProvider.claudeClient === true ? { headers: CLAUDE_CLIENT_HEADERS } : {}
-      }) : new OpenAIModelAdapter(adapterOptions);
+      }) : new OpenAIModelAdapter({
+        ...adapterOptions,
+        ...runtimeProvider.thinkingEffort === void 0 ? {} : { thinkingEffort: runtimeProvider.thinkingEffort }
+      });
       const cacheProfile = resolveCacheProfile({ apiType: apiProtocol, baseURL: runtimeProvider.baseURL });
       if (apiProtocol === "openai" && isDashScopeBaseURL(runtimeProvider.baseURL)) {
         diagnostics.push(
@@ -23191,6 +23658,8 @@ export {
   executeShell,
   packageVersion,
   SkillRegistry,
+  charWidth,
+  thinkingWindow,
   createTranscriptState,
   transcriptReducer,
   WorkspaceCheckpointStore,