flavor-code 1.3.10 → 1.3.11

package/dist/{app-YSBW7GXH.js → app-L52CTVNR.js}

@@ -16,7 +16,7 @@ import {
   redactErrorText,
   transcriptReducer,
   withTimeout
-} from "./chunk-Y3DPUAEJ.js";
+} from "./chunk-IGFN2DM5.js";
 import "./chunk-IG4Z23CL.js";
 import {
   Box_default,
@@ -1257,7 +1257,7 @@ function slashCandidatePresentation(selected) {
     matchStyle: { color: "ansi:cyan", bold: true }
   };
 }
-function buildSlashCandidates(commands, plugins, skills) {
+function buildSlashCandidates(commands, plugins, skills, tools = []) {
   const candidates = /* @__PURE__ */ new Map();
   for (const command of commands) {
     candidates.set(command.name, { name: command.name, kind: "command", description: command.description });
@@ -1267,6 +1267,11 @@ function buildSlashCandidates(commands, plugins, skills) {
       candidates.set(plugin.name, plugin.description === void 0 ? { name: plugin.name, kind: "plugin" } : { name: plugin.name, kind: "plugin", description: plugin.description });
     }
   }
+  for (const tool of tools) {
+    if (!candidates.has(tool.name)) {
+      candidates.set(tool.name, tool.description === void 0 ? { name: tool.name, kind: "tool" } : { name: tool.name, kind: "tool", description: tool.description });
+    }
+  }
   for (const skill of skills) {
     if (!candidates.has(skill.name)) {
       candidates.set(skill.name, {
@@ -1850,7 +1855,8 @@ function appRuntimeOptions(props, output, onApprovalChange) {
       ...props.palAlias === void 0 ? {} : { alias: props.palAlias }
     },
     output,
-    onApprovalChange
+    onApprovalChange,
+    onToolsChange: onApprovalChange
   };
 }
 function App({ workspace, home, resumeSession, instanceId, palAlias }) {
@@ -1954,13 +1960,23 @@ function App({ workspace, home, resumeSession, instanceId, palAlias }) {
       }
       dispatch({ type: "restore", state: created.restoredTranscript });
       runtimeRef.current = created;
-      setSlashCandidates(buildSlashCandidates(BUILTIN_SLASH_CANDIDATES, created.services.pluginCommands(), []));
+      setSlashCandidates(buildSlashCandidates(
+        BUILTIN_SLASH_CANDIDATES,
+        created.services.pluginCommands(),
+        [],
+        created.services.managedToolCommands()
+      ));
       setRuntime(created);
       await created.session.start();
       try {
         const skills = await created.services.skills();
         if (!disposed) {
-          setSlashCandidates(buildSlashCandidates(BUILTIN_SLASH_CANDIDATES, created.services.pluginCommands(), skills));
+          setSlashCandidates(buildSlashCandidates(
+            BUILTIN_SLASH_CANDIDATES,
+            created.services.pluginCommands(),
+            skills,
+            created.services.managedToolCommands()
+          ));
         }
       } catch {
       }
@@ -1975,6 +1991,28 @@ function App({ workspace, home, resumeSession, instanceId, palAlias }) {
 `));
     };
   }, [workspace, home, resumeSession, instanceId, palAlias]);
+  useEffect3(() => {
+    if (runtime === void 0) return;
+    let disposed = false;
+    void runtime.services.skills().then((skills) => {
+      if (!disposed) setSlashCandidates(buildSlashCandidates(
+        BUILTIN_SLASH_CANDIDATES,
+        runtime.services.pluginCommands(),
+        skills,
+        runtime.services.managedToolCommands()
+      ));
+    }).catch(() => {
+      if (!disposed) setSlashCandidates(buildSlashCandidates(
+        BUILTIN_SLASH_CANDIDATES,
+        runtime.services.pluginCommands(),
+        [],
+        runtime.services.managedToolCommands()
+      ));
+    });
+    return () => {
+      disposed = true;
+    };
+  }, [runtime, revision]);
   useEffect3(() => installSigintHandler(process, interrupt), [interrupt]);
   useEffect3(() => {
     if (runtime?.services.ideContext === void 0) {
@@ -2347,7 +2385,6 @@ function App({ workspace, home, resumeSession, instanceId, palAlias }) {
       setDismissedMentionInput(void 0);
     }
   });
-  void revision;
   if (runtime === void 0) return /* @__PURE__ */ jsx5(
     StartingLayout,
     {

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

@@ -2996,7 +2996,8 @@ var MVP_COMMANDS = [
   "fork",
   "pals",
   "chat",
-  "co-work"
+  "co-work",
+  "tool"
 ];
 var COMMAND_DESCRIPTIONS = {
   model: "Switch the active model",
@@ -3034,16 +3035,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 +3074,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 +3310,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 +3582,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 +3689,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") {
@@ -6536,9 +6562,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 +6638,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 +6710,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 +6764,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 +6784,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 = [
@@ -7153,19 +7255,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 +7268,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,
@@ -7654,12 +7750,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 +9496,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, [
@@ -17795,7 +17904,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 +20968,7 @@ async function createProductionRuntime(options) {
       managedTools.push(tool);
     }
     if (harnessCreated) harness.replaceMainTools(tools);
+    options.onToolsChange?.();
   };
   tools.push(...createManagedToolManagementTools({
     store: managedToolStore,
@@ -22188,6 +22298,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() {

package/dist/{chunk-T2ARW6CZ.js → chunk-JZ5FVBET.js}

@@ -4,7 +4,7 @@ import {
   message,
   redactErrorText,
   redactSecrets
-} from "./chunk-Y3DPUAEJ.js";
+} from "./chunk-IGFN2DM5.js";
 
 // src/rpc/server.ts
 import { createInterface } from "readline";

package/dist/cli.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module"; const require = createRequire(impor
 import {
   FlavorRpcServer,
   TraceRecorder
-} from "./chunk-T2ARW6CZ.js";
+} from "./chunk-JZ5FVBET.js";
 import {
   staticTaskLines
 } from "./chunk-KKIBYDJI.js";
@@ -23,7 +23,7 @@ import {
   packageVersion,
   redactErrorText,
   runPalBroker
-} from "./chunk-Y3DPUAEJ.js";
+} from "./chunk-IGFN2DM5.js";
 import {
   McpServerConfigSchema,
   McpServerNameSchema,
@@ -877,7 +877,7 @@ async function runInteractiveCli(props) {
   const [{ render, AlternateScreen }, { createElement }, { App }] = await Promise.all([
     import("./claude-ink-ORUA7GWG.js"),
     import("react"),
-    import("./app-YSBW7GXH.js")
+    import("./app-L52CTVNR.js")
   ]);
   const instance = await render(createElement(
     AlternateScreen,