llmist 0.8.0 → 1.1.0

package/dist/cli.js

@@ -21,8 +21,12 @@ import {
   init_messages,
   init_model_shortcuts,
   init_registry,
-  resolveModel
-} from "./chunk-62M4TDAK.js";
+  init_schema_to_json,
+  init_schema_validator,
+  resolveModel,
+  schemaToJSONSchema,
+  validateGadgetSchema
+} from "./chunk-VXPZQZF5.js";
 
 // src/cli/constants.ts
 var CLI_NAME = "llmist";
@@ -30,11 +34,11 @@ var CLI_DESCRIPTION = "Command line utilities for llmist agents and direct LLM a
 var COMMANDS = {
   complete: "complete",
   agent: "agent",
-  models: "models"
+  models: "models",
+  gadget: "gadget"
 };
 var LOG_LEVELS = ["silly", "trace", "debug", "info", "warn", "error", "fatal"];
 var DEFAULT_MODEL = "openai:gpt-5-nano";
-var DEFAULT_PARAMETER_FORMAT = "toml";
 var OPTION_FLAGS = {
   model: "-m, --model <identifier>",
   systemPrompt: "-s, --system <prompt>",
@@ -42,10 +46,11 @@ var OPTION_FLAGS = {
   maxTokens: "--max-tokens <count>",
   maxIterations: "-i, --max-iterations <count>",
   gadgetModule: "-g, --gadget <module>",
-  parameterFormat: "--parameter-format <format>",
   logLevel: "--log-level <level>",
   logFile: "--log-file <path>",
   logReset: "--log-reset",
+  logLlmRequests: "--log-llm-requests [dir]",
+  logLlmResponses: "--log-llm-responses [dir]",
   noBuiltins: "--no-builtins",
   noBuiltinInteraction: "--no-builtin-interaction",
   quiet: "-q, --quiet"
@@ -57,10 +62,11 @@ var OPTION_DESCRIPTIONS = {
   maxTokens: "Maximum number of output tokens requested from the model.",
   maxIterations: "Maximum number of agent loop iterations before exiting.",
   gadgetModule: "Path or module specifier for a gadget export. Repeat to register multiple gadgets.",
-  parameterFormat: "Format for gadget parameter schemas: 'json', 'yaml', 'toml', or 'auto'.",
   logLevel: "Log level: silly, trace, debug, info, warn, error, fatal.",
   logFile: "Path to log file. When set, logs are written to file instead of stderr.",
   logReset: "Reset (truncate) the log file at session start instead of appending.",
+  logLlmRequests: "Save raw LLM requests as plain text. Optional dir, defaults to ~/.llmist/logs/requests/",
+  logLlmResponses: "Save raw LLM responses as plain text. Optional dir, defaults to ~/.llmist/logs/responses/",
   noBuiltins: "Disable built-in gadgets (AskUser, TellUser).",
   noBuiltinInteraction: "Disable interactive gadgets (AskUser) while keeping TellUser.",
   quiet: "Suppress all output except content (text and TellUser messages)."
@@ -68,12 +74,12 @@ var OPTION_DESCRIPTIONS = {
 var SUMMARY_PREFIX = "[llmist]";
 
 // src/cli/program.ts
-import { Command, InvalidArgumentError as InvalidArgumentError3 } from "commander";
+import { Command, InvalidArgumentError as InvalidArgumentError2 } from "commander";
 
 // package.json
 var package_default = {
   name: "llmist",
-  version: "0.7.0",
+  version: "1.0.0",
   description: "Universal TypeScript LLM client with streaming-first agent framework. Works with any model - no structured outputs or native tool calling required. Implements its own flexible grammar for function calling.",
   type: "module",
   main: "dist/index.cjs",
@@ -375,8 +381,33 @@ async function loadGadgets(specifiers, cwd, importer = (specifier) => import(spe
   return gadgets;
 }
 
-// src/cli/option-helpers.ts
-import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
+// src/cli/llm-logging.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_LLM_LOG_DIR = join(homedir(), ".llmist", "logs");
+function resolveLogDir(option, subdir) {
+  if (option === true) {
+    return join(DEFAULT_LLM_LOG_DIR, subdir);
+  }
+  if (typeof option === "string") {
+    return option;
+  }
+  return void 0;
+}
+function formatLlmRequest(messages) {
+  const lines = [];
+  for (const msg of messages) {
+    lines.push(`=== ${msg.role.toUpperCase()} ===`);
+    lines.push(msg.content ?? "");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function writeLogFile(dir, filename, content) {
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, filename), content, "utf-8");
+}
 
 // src/cli/utils.ts
 init_constants();
@@ -420,9 +451,29 @@ function ensureMarkedConfigured() {
 }
 function renderMarkdown(text) {
   ensureMarkedConfigured();
-  const rendered = marked.parse(text);
+  let rendered = marked.parse(text);
+  rendered = rendered.replace(/\*\*(.+?)\*\*/g, (_, content) => chalk.bold(content)).replace(/(?<!\*)\*(\S[^*]*)\*(?!\*)/g, (_, content) => chalk.italic(content));
   return rendered.trimEnd();
 }
+function createRainbowSeparator() {
+  const colors = [chalk.red, chalk.yellow, chalk.green, chalk.cyan, chalk.blue, chalk.magenta];
+  const char = "\u2500";
+  const width = process.stdout.columns || 80;
+  let result = "";
+  for (let i = 0; i < width; i++) {
+    result += colors[i % colors.length](char);
+  }
+  return result;
+}
+function renderMarkdownWithSeparators(text) {
+  const rendered = renderMarkdown(text);
+  const separator = createRainbowSeparator();
+  return `
+${separator}
+${rendered}
+${separator}
+`;
+}
 function formatTokens(tokens) {
   return tokens >= 1e3 ? `${(tokens / 1e3).toFixed(1)}k` : `${tokens}`;
 }
@@ -542,7 +593,7 @@ function formatGadgetSummary(result) {
   const summaryLine = `${icon} ${gadgetLabel}${paramsLabel} ${chalk.dim("\u2192")} ${outputLabel} ${timeLabel}`;
   if (result.gadgetName === "TellUser" && result.parameters?.message) {
     const message = String(result.parameters.message);
-    const rendered = renderMarkdown(message);
+    const rendered = renderMarkdownWithSeparators(message);
     return `${summaryLine}
 ${rendered}`;
   }
@@ -849,7 +900,7 @@ var StreamProgress = class {
     }
     this.isRunning = false;
     if (this.hasRendered) {
-      this.target.write("\r\x1B[K");
+      this.target.write("\r\x1B[K\x1B[0G");
       this.hasRendered = false;
     }
   }
@@ -942,16 +993,6 @@ async function executeAction(action, env) {
 }
 
 // src/cli/option-helpers.ts
-var PARAMETER_FORMAT_VALUES = ["json", "yaml", "toml", "auto"];
-function parseParameterFormat(value) {
-  const normalized = value.toLowerCase();
-  if (!PARAMETER_FORMAT_VALUES.includes(normalized)) {
-    throw new InvalidArgumentError2(
-      `Parameter format must be one of: ${PARAMETER_FORMAT_VALUES.join(", ")}`
-    );
-  }
-  return normalized;
-}
 function addCompleteOptions(cmd, defaults) {
   return cmd.option(OPTION_FLAGS.model, OPTION_DESCRIPTIONS.model, defaults?.model ?? DEFAULT_MODEL).option(OPTION_FLAGS.systemPrompt, OPTION_DESCRIPTIONS.systemPrompt, defaults?.system).option(
     OPTION_FLAGS.temperature,
@@ -963,7 +1004,7 @@ function addCompleteOptions(cmd, defaults) {
     OPTION_DESCRIPTIONS.maxTokens,
     createNumericParser({ label: "Max tokens", integer: true, min: 1 }),
     defaults?.["max-tokens"]
-  ).option(OPTION_FLAGS.quiet, OPTION_DESCRIPTIONS.quiet, defaults?.quiet);
+  ).option(OPTION_FLAGS.quiet, OPTION_DESCRIPTIONS.quiet, defaults?.quiet).option(OPTION_FLAGS.logLlmRequests, OPTION_DESCRIPTIONS.logLlmRequests, defaults?.["log-llm-requests"]).option(OPTION_FLAGS.logLlmResponses, OPTION_DESCRIPTIONS.logLlmResponses, defaults?.["log-llm-responses"]);
 }
 function addAgentOptions(cmd, defaults) {
   const gadgetAccumulator = (value, previous = []) => [
@@ -983,16 +1024,11 @@ function addAgentOptions(cmd, defaults) {
     defaults?.["max-iterations"]
   ).option(OPTION_FLAGS.gadgetModule, OPTION_DESCRIPTIONS.gadgetModule, gadgetAccumulator, [
     ...defaultGadgets
-  ]).option(
-    OPTION_FLAGS.parameterFormat,
-    OPTION_DESCRIPTIONS.parameterFormat,
-    parseParameterFormat,
-    defaults?.["parameter-format"] ?? DEFAULT_PARAMETER_FORMAT
-  ).option(OPTION_FLAGS.noBuiltins, OPTION_DESCRIPTIONS.noBuiltins, defaults?.builtins !== false).option(
+  ]).option(OPTION_FLAGS.noBuiltins, OPTION_DESCRIPTIONS.noBuiltins, defaults?.builtins !== false).option(
     OPTION_FLAGS.noBuiltinInteraction,
     OPTION_DESCRIPTIONS.noBuiltinInteraction,
     defaults?.["builtin-interaction"] !== false
-  ).option(OPTION_FLAGS.quiet, OPTION_DESCRIPTIONS.quiet, defaults?.quiet);
+  ).option(OPTION_FLAGS.quiet, OPTION_DESCRIPTIONS.quiet, defaults?.quiet).option(OPTION_FLAGS.logLlmRequests, OPTION_DESCRIPTIONS.logLlmRequests, defaults?.["log-llm-requests"]).option(OPTION_FLAGS.logLlmResponses, OPTION_DESCRIPTIONS.logLlmResponses, defaults?.["log-llm-responses"]);
 }
 function configToCompleteOptions(config) {
   const result = {};
@@ -1001,6 +1037,8 @@ function configToCompleteOptions(config) {
   if (config.temperature !== void 0) result.temperature = config.temperature;
   if (config["max-tokens"] !== void 0) result.maxTokens = config["max-tokens"];
   if (config.quiet !== void 0) result.quiet = config.quiet;
+  if (config["log-llm-requests"] !== void 0) result.logLlmRequests = config["log-llm-requests"];
+  if (config["log-llm-responses"] !== void 0) result.logLlmResponses = config["log-llm-responses"];
   return result;
 }
 function configToAgentOptions(config) {
@@ -1010,7 +1048,6 @@ function configToAgentOptions(config) {
   if (config.temperature !== void 0) result.temperature = config.temperature;
   if (config["max-iterations"] !== void 0) result.maxIterations = config["max-iterations"];
   if (config.gadget !== void 0) result.gadget = config.gadget;
-  if (config["parameter-format"] !== void 0) result.parameterFormat = config["parameter-format"];
   if (config.builtins !== void 0) result.builtins = config.builtins;
   if (config["builtin-interaction"] !== void 0)
     result.builtinInteraction = config["builtin-interaction"];
@@ -1018,7 +1055,11 @@ function configToAgentOptions(config) {
     result.gadgetStartPrefix = config["gadget-start-prefix"];
   if (config["gadget-end-prefix"] !== void 0)
     result.gadgetEndPrefix = config["gadget-end-prefix"];
+  if (config["gadget-arg-prefix"] !== void 0)
+    result.gadgetArgPrefix = config["gadget-arg-prefix"];
   if (config.quiet !== void 0) result.quiet = config.quiet;
+  if (config["log-llm-requests"] !== void 0) result.logLlmRequests = config["log-llm-requests"];
+  if (config["log-llm-responses"] !== void 0) result.logLlmResponses = config["log-llm-responses"];
   return result;
 }
 
@@ -1042,7 +1083,7 @@ function createHumanInputHandler(env, progress) {
     const rl = createInterface({ input: env.stdin, output: env.stdout });
     try {
       const questionLine = question.trim() ? `
-${renderMarkdown(question.trim())}` : "";
+${renderMarkdownWithSeparators(question.trim())}` : "";
       let isFirst = true;
       while (true) {
         const statsPrompt = progress.formatPrompt();
@@ -1085,6 +1126,9 @@ async function executeAgent(promptArg, options, env) {
   const progress = new StreamProgress(env.stderr, stderrTTY, client.modelRegistry);
   let usage;
   let iterations = 0;
+  const llmRequestsDir = resolveLogDir(options.logLlmRequests, "requests");
+  const llmResponsesDir = resolveLogDir(options.logLlmResponses, "responses");
+  let llmCallCounter = 0;
   const countMessagesTokens = async (model, messages) => {
     try {
       return await client.countTokens(model, messages);
@@ -1107,12 +1151,18 @@ async function executeAgent(promptArg, options, env) {
       // onLLMCallStart: Start progress indicator for each LLM call
       // This showcases how to react to agent lifecycle events
       onLLMCallStart: async (context) => {
+        llmCallCounter++;
         const inputTokens = await countMessagesTokens(
           context.options.model,
           context.options.messages
         );
         progress.startCall(context.options.model, inputTokens);
         progress.setInputTokens(inputTokens, false);
+        if (llmRequestsDir) {
+          const filename = `${Date.now()}_call_${llmCallCounter}.request.txt`;
+          const content = formatLlmRequest(context.options.messages);
+          await writeLogFile(llmRequestsDir, filename, content);
+        }
       },
       // onStreamChunk: Real-time updates as LLM generates tokens
       // This enables responsive UIs that show progress during generation
@@ -1175,6 +1225,10 @@ async function executeAgent(promptArg, options, env) {
 `);
           }
         }
+        if (llmResponsesDir) {
+          const filename = `${Date.now()}_call_${llmCallCounter}.response.txt`;
+          await writeLogFile(llmResponsesDir, filename, context.rawResponse);
+        }
       }
     },
     // SHOWCASE: Controller-based approval gating for dangerous gadgets
@@ -1239,13 +1293,15 @@ Command rejected by user with message: "${response}"`
   if (gadgets.length > 0) {
     builder.withGadgets(...gadgets);
   }
-  builder.withParameterFormat(options.parameterFormat);
   if (options.gadgetStartPrefix) {
     builder.withGadgetStartPrefix(options.gadgetStartPrefix);
   }
   if (options.gadgetEndPrefix) {
     builder.withGadgetEndPrefix(options.gadgetEndPrefix);
   }
+  if (options.gadgetArgPrefix) {
+    builder.withGadgetArgPrefix(options.gadgetArgPrefix);
+  }
   builder.withSyntheticGadgetCall(
     "TellUser",
     {
@@ -1262,17 +1318,25 @@ Command rejected by user with message: "${response}"`
     resultMapping: (text) => `\u2139\uFE0F  ${text}`
   });
   const agent = builder.ask(prompt);
+  let textBuffer = "";
+  const flushTextBuffer = () => {
+    if (textBuffer) {
+      const output = options.quiet ? textBuffer : renderMarkdownWithSeparators(textBuffer);
+      printer.write(output);
+      textBuffer = "";
+    }
+  };
   for await (const event of agent.run()) {
     if (event.type === "text") {
       progress.pause();
-      printer.write(event.content);
+      textBuffer += event.content;
     } else if (event.type === "gadget_result") {
+      flushTextBuffer();
       progress.pause();
       if (options.quiet) {
         if (event.result.gadgetName === "TellUser" && event.result.parameters?.message) {
           const message = String(event.result.parameters.message);
-          const rendered = renderMarkdown(message);
-          env.stdout.write(`${rendered}
+          env.stdout.write(`${message}
 `);
         }
       } else {
@@ -1282,6 +1346,7 @@ Command rejected by user with message: "${response}"`
       }
     }
   }
+  flushTextBuffer();
   progress.complete();
   printer.ensureNewline();
   if (!options.quiet && iterations > 1) {
@@ -1320,9 +1385,18 @@ async function executeComplete(promptArg, options, env) {
     builder.addSystem(options.system);
   }
   builder.addUser(prompt);
+  const messages = builder.build();
+  const llmRequestsDir = resolveLogDir(options.logLlmRequests, "requests");
+  const llmResponsesDir = resolveLogDir(options.logLlmResponses, "responses");
+  const timestamp = Date.now();
+  if (llmRequestsDir) {
+    const filename = `${timestamp}_complete.request.txt`;
+    const content = formatLlmRequest(messages);
+    await writeLogFile(llmRequestsDir, filename, content);
+  }
   const stream = client.stream({
     model,
-    messages: builder.build(),
+    messages,
     temperature: options.temperature,
     maxTokens: options.maxTokens
   });
@@ -1333,7 +1407,7 @@ async function executeComplete(promptArg, options, env) {
   progress.startCall(model, estimatedInputTokens);
   let finishReason;
   let usage;
-  let totalChars = 0;
+  let accumulatedResponse = "";
   for await (const chunk of stream) {
     if (chunk.usage) {
       usage = chunk.usage;
@@ -1346,8 +1420,8 @@ async function executeComplete(promptArg, options, env) {
     }
     if (chunk.text) {
       progress.pause();
-      totalChars += chunk.text.length;
-      progress.update(totalChars);
+      accumulatedResponse += chunk.text;
+      progress.update(accumulatedResponse.length);
       printer.write(chunk.text);
     }
     if (chunk.finishReason !== void 0) {
@@ -1357,6 +1431,10 @@ async function executeComplete(promptArg, options, env) {
   progress.endCall(usage);
   progress.complete();
   printer.ensureNewline();
+  if (llmResponsesDir) {
+    const filename = `${timestamp}_complete.response.txt`;
+    await writeLogFile(llmResponsesDir, filename, accumulatedResponse);
+  }
   if (stderrTTY && !options.quiet) {
     const summary = renderSummary({ finishReason, usage, cost: progress.getTotalCost() });
     if (summary) {
@@ -1375,8 +1453,8 @@ function registerCompleteCommand(program, env, config) {
 
 // src/cli/config.ts
 import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
 import { load as parseToml } from "js-toml";
 
 // src/cli/templates.ts
@@ -1471,6 +1549,8 @@ var COMPLETE_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "log-level",
   "log-file",
   "log-reset",
+  "log-llm-requests",
+  "log-llm-responses",
   "type"
   // Allowed for inheritance compatibility, ignored for built-in commands
 ]);
@@ -1480,16 +1560,18 @@ var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "temperature",
   "max-iterations",
   "gadget",
-  "parameter-format",
   "builtins",
   "builtin-interaction",
   "gadget-start-prefix",
   "gadget-end-prefix",
+  "gadget-arg-prefix",
   "quiet",
   "inherits",
   "log-level",
   "log-file",
   "log-reset",
+  "log-llm-requests",
+  "log-llm-responses",
   "type"
   // Allowed for inheritance compatibility, ignored for built-in commands
 ]);
@@ -1499,9 +1581,8 @@ var CUSTOM_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "type",
   "description"
 ]);
-var VALID_PARAMETER_FORMATS = ["json", "yaml", "toml", "auto"];
 function getConfigPath() {
-  return join(homedir(), ".llmist", "cli.toml");
+  return join2(homedir2(), ".llmist", "cli.toml");
 }
 var ConfigError = class extends Error {
   constructor(message, path2) {
@@ -1635,6 +1716,20 @@ function validateCompleteConfig(raw, section) {
   if ("quiet" in rawObj) {
     result.quiet = validateBoolean(rawObj.quiet, "quiet", section);
   }
+  if ("log-llm-requests" in rawObj) {
+    result["log-llm-requests"] = validateStringOrBoolean(
+      rawObj["log-llm-requests"],
+      "log-llm-requests",
+      section
+    );
+  }
+  if ("log-llm-responses" in rawObj) {
+    result["log-llm-responses"] = validateStringOrBoolean(
+      rawObj["log-llm-responses"],
+      "log-llm-responses",
+      section
+    );
+  }
   return result;
 }
 function validateAgentConfig(raw, section) {
@@ -1660,15 +1755,6 @@ function validateAgentConfig(raw, section) {
   if ("gadget" in rawObj) {
     result.gadget = validateStringArray(rawObj.gadget, "gadget", section);
   }
-  if ("parameter-format" in rawObj) {
-    const format = validateString(rawObj["parameter-format"], "parameter-format", section);
-    if (!VALID_PARAMETER_FORMATS.includes(format)) {
-      throw new ConfigError(
-        `[${section}].parameter-format must be one of: ${VALID_PARAMETER_FORMATS.join(", ")}`
-      );
-    }
-    result["parameter-format"] = format;
-  }
   if ("builtins" in rawObj) {
     result.builtins = validateBoolean(rawObj.builtins, "builtins", section);
   }
@@ -1693,11 +1779,38 @@ function validateAgentConfig(raw, section) {
       section
     );
   }
+  if ("gadget-arg-prefix" in rawObj) {
+    result["gadget-arg-prefix"] = validateString(
+      rawObj["gadget-arg-prefix"],
+      "gadget-arg-prefix",
+      section
+    );
+  }
   if ("quiet" in rawObj) {
     result.quiet = validateBoolean(rawObj.quiet, "quiet", section);
   }
+  if ("log-llm-requests" in rawObj) {
+    result["log-llm-requests"] = validateStringOrBoolean(
+      rawObj["log-llm-requests"],
+      "log-llm-requests",
+      section
+    );
+  }
+  if ("log-llm-responses" in rawObj) {
+    result["log-llm-responses"] = validateStringOrBoolean(
+      rawObj["log-llm-responses"],
+      "log-llm-responses",
+      section
+    );
+  }
   return result;
 }
+function validateStringOrBoolean(value, field, section) {
+  if (typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  throw new ConfigError(`[${section}].${field} must be a string or boolean`);
+}
 function validateCustomConfig(raw, section) {
   if (typeof raw !== "object" || raw === null) {
     throw new ConfigError(`[${section}] must be a table`);
@@ -1732,15 +1845,6 @@ function validateCustomConfig(raw, section) {
   if ("gadget" in rawObj) {
     result.gadget = validateStringArray(rawObj.gadget, "gadget", section);
   }
-  if ("parameter-format" in rawObj) {
-    const format = validateString(rawObj["parameter-format"], "parameter-format", section);
-    if (!VALID_PARAMETER_FORMATS.includes(format)) {
-      throw new ConfigError(
-        `[${section}].parameter-format must be one of: ${VALID_PARAMETER_FORMATS.join(", ")}`
-      );
-    }
-    result["parameter-format"] = format;
-  }
   if ("builtins" in rawObj) {
     result.builtins = validateBoolean(rawObj.builtins, "builtins", section);
   }
@@ -1765,6 +1869,13 @@ function validateCustomConfig(raw, section) {
       section
     );
   }
+  if ("gadget-arg-prefix" in rawObj) {
+    result["gadget-arg-prefix"] = validateString(
+      rawObj["gadget-arg-prefix"],
+      "gadget-arg-prefix",
+      section
+    );
+  }
   if ("max-tokens" in rawObj) {
     result["max-tokens"] = validateNumber(rawObj["max-tokens"], "max-tokens", section, {
       integer: true,
@@ -1955,8 +2066,439 @@ function resolveInheritance(config, configPath) {
   return resolved;
 }
 
-// src/cli/models-command.ts
+// src/cli/gadget-command.ts
+init_schema_to_json();
+init_schema_validator();
+import chalk5 from "chalk";
+
+// src/cli/gadget-prompts.ts
+init_schema_to_json();
+import { createInterface as createInterface2 } from "node:readline/promises";
 import chalk4 from "chalk";
+async function promptForParameters(schema, ctx) {
+  if (!schema) {
+    return {};
+  }
+  const jsonSchema = schemaToJSONSchema(schema, { target: "draft-7" });
+  if (!jsonSchema.properties || Object.keys(jsonSchema.properties).length === 0) {
+    return {};
+  }
+  const rl = createInterface2({ input: ctx.stdin, output: ctx.stdout });
+  const params = {};
+  try {
+    for (const [key, prop] of Object.entries(jsonSchema.properties)) {
+      const value = await promptForField(rl, key, prop, jsonSchema.required ?? []);
+      if (value !== void 0) {
+        params[key] = value;
+      }
+    }
+  } finally {
+    rl.close();
+  }
+  const result = schema.safeParse(params);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`Invalid parameters:
+${issues}`);
+  }
+  return result.data;
+}
+async function promptForField(rl, key, prop, required) {
+  const isRequired = required.includes(key);
+  const typeHint = formatTypeHint(prop);
+  const defaultHint = prop.default !== void 0 ? chalk4.dim(` [default: ${JSON.stringify(prop.default)}]`) : "";
+  const requiredMarker = isRequired ? chalk4.red("*") : "";
+  let prompt = `
+${chalk4.cyan.bold(key)}${requiredMarker}`;
+  if (prop.description) {
+    prompt += chalk4.dim(` - ${prop.description}`);
+  }
+  prompt += `
+  ${typeHint}${defaultHint}
+  ${chalk4.green(">")} `;
+  const answer = await rl.question(prompt);
+  const trimmed = answer.trim();
+  if (!trimmed) {
+    if (prop.default !== void 0) {
+      return void 0;
+    }
+    if (!isRequired) {
+      return void 0;
+    }
+    throw new Error(`Parameter '${key}' is required.`);
+  }
+  return parseValue(trimmed, prop, key);
+}
+function formatTypeHint(prop) {
+  if (prop.enum) {
+    return chalk4.yellow(`(${prop.enum.join(" | ")})`);
+  }
+  if (prop.type === "array") {
+    const items = prop.items;
+    if (items?.enum) {
+      return chalk4.yellow(`(${items.enum.join(" | ")})[] comma-separated`);
+    }
+    const itemType = items?.type ?? "any";
+    return chalk4.yellow(`(${itemType}[]) comma-separated`);
+  }
+  if (prop.type === "object" && prop.properties) {
+    return chalk4.yellow("(object) enter as JSON");
+  }
+  return chalk4.yellow(`(${prop.type ?? "any"})`);
+}
+function parseValue(input, prop, key) {
+  const type = prop.type;
+  if (type === "number" || type === "integer") {
+    const num = Number(input);
+    if (Number.isNaN(num)) {
+      throw new Error(`Invalid number for '${key}': ${input}`);
+    }
+    if (type === "integer" && !Number.isInteger(num)) {
+      throw new Error(`Expected integer for '${key}', got: ${input}`);
+    }
+    return num;
+  }
+  if (type === "boolean") {
+    const lower = input.toLowerCase();
+    if (["true", "yes", "1", "y"].includes(lower)) return true;
+    if (["false", "no", "0", "n"].includes(lower)) return false;
+    throw new Error(`Invalid boolean for '${key}': ${input} (use true/false, yes/no, 1/0)`);
+  }
+  if (type === "array") {
+    const items = input.split(",").map((s) => s.trim()).filter(Boolean);
+    const itemType = prop.items?.type;
+    if (itemType === "number" || itemType === "integer") {
+      return items.map((item) => {
+        const num = Number(item);
+        if (Number.isNaN(num)) throw new Error(`Invalid number in '${key}' array: ${item}`);
+        return num;
+      });
+    }
+    if (itemType === "boolean") {
+      return items.map((item) => {
+        const lower = item.toLowerCase();
+        if (["true", "yes", "1", "y"].includes(lower)) return true;
+        if (["false", "no", "0", "n"].includes(lower)) return false;
+        throw new Error(`Invalid boolean in '${key}' array: ${item}`);
+      });
+    }
+    return items;
+  }
+  if (type === "object") {
+    try {
+      return JSON.parse(input);
+    } catch {
+      throw new Error(`Invalid JSON for '${key}': ${input}`);
+    }
+  }
+  return input;
+}
+async function readStdinJson(stdin) {
+  const chunks = [];
+  for await (const chunk of stdin) {
+    if (typeof chunk === "string") {
+      chunks.push(chunk);
+    } else {
+      chunks.push(chunk.toString("utf8"));
+    }
+  }
+  const content = chunks.join("").trim();
+  if (!content) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("Stdin must contain a JSON object, not an array or primitive.");
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON from stdin: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+// src/cli/gadget-command.ts
+async function selectGadget(file, nameOption, cwd) {
+  const gadgets = await loadGadgets([file], cwd);
+  if (gadgets.length === 0) {
+    throw new Error(
+      `No gadgets found in '${file}'.
+Ensure the file exports a Gadget class or instance.`
+    );
+  }
+  if (gadgets.length === 1) {
+    const gadget = gadgets[0];
+    const name = gadget.name ?? gadget.constructor.name;
+    return { gadget, name };
+  }
+  const names = gadgets.map((g) => g.name ?? g.constructor.name);
+  if (!nameOption) {
+    throw new Error(
+      `File '${file}' exports ${gadgets.length} gadgets.
+Use --name to select one:
+` + names.map((n) => `  - ${n}`).join("\n")
+    );
+  }
+  const found = gadgets.find((g) => (g.name ?? g.constructor.name) === nameOption);
+  if (!found) {
+    throw new Error(
+      `Gadget '${nameOption}' not found in '${file}'.
+Available gadgets:
+` + names.map((n) => `  - ${n}`).join("\n")
+    );
+  }
+  return { gadget: found, name: nameOption };
+}
+async function executeGadgetRun(file, options, env) {
+  const cwd = process.cwd();
+  const { gadget, name } = await selectGadget(file, options.name, cwd);
+  env.stderr.write(chalk5.cyan.bold(`
+\u{1F527} Running gadget: ${name}
+`));
+  let params;
+  if (env.isTTY) {
+    params = await promptForParameters(gadget.parameterSchema, {
+      stdin: env.stdin,
+      stdout: env.stderr
+      // Prompts go to stderr to keep stdout clean
+    });
+  } else {
+    env.stderr.write(chalk5.dim("Reading parameters from stdin...\n"));
+    const stdinParams = await readStdinJson(env.stdin);
+    if (gadget.parameterSchema) {
+      const result2 = gadget.parameterSchema.safeParse(stdinParams);
+      if (!result2.success) {
+        const issues = result2.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+        throw new Error(`Invalid parameters:
+${issues}`);
+      }
+      params = result2.data;
+    } else {
+      params = stdinParams;
+    }
+  }
+  env.stderr.write(chalk5.dim("\nExecuting...\n"));
+  const startTime = Date.now();
+  let result;
+  try {
+    if (gadget.timeoutMs && gadget.timeoutMs > 0) {
+      result = await Promise.race([
+        Promise.resolve(gadget.execute(params)),
+        new Promise(
+          (_, reject) => setTimeout(
+            () => reject(new Error(`Gadget timed out after ${gadget.timeoutMs}ms`)),
+            gadget.timeoutMs
+          )
+        )
+      ]);
+    } else {
+      result = await Promise.resolve(gadget.execute(params));
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Execution failed: ${message}`);
+  }
+  const elapsed = Date.now() - startTime;
+  env.stderr.write(chalk5.green(`
+\u2713 Completed in ${elapsed}ms
+
+`));
+  formatOutput(result, options, env.stdout);
+}
+function formatOutput(result, options, stdout) {
+  if (options.raw) {
+    stdout.write(result);
+    if (!result.endsWith("\n")) stdout.write("\n");
+    return;
+  }
+  if (options.json || looksLikeJson(result)) {
+    try {
+      const parsed = JSON.parse(result);
+      stdout.write(JSON.stringify(parsed, null, 2) + "\n");
+      return;
+    } catch {
+    }
+  }
+  stdout.write(result);
+  if (!result.endsWith("\n")) stdout.write("\n");
+}
+function looksLikeJson(str) {
+  const trimmed = str.trim();
+  return trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+async function executeGadgetInfo(file, options, env) {
+  const cwd = process.cwd();
+  const { gadget, name } = await selectGadget(file, options.name, cwd);
+  if (options.json) {
+    const info = buildGadgetInfo(gadget, name);
+    env.stdout.write(JSON.stringify(info, null, 2) + "\n");
+    return;
+  }
+  env.stdout.write("\n");
+  env.stdout.write(chalk5.cyan.bold(`${name}
+`));
+  env.stdout.write(chalk5.cyan("\u2550".repeat(name.length)) + "\n\n");
+  env.stdout.write(chalk5.bold("Description:\n"));
+  env.stdout.write(`  ${gadget.description}
+
+`);
+  if (gadget.parameterSchema) {
+    env.stdout.write(chalk5.bold("Parameters:\n"));
+    const jsonSchema = schemaToJSONSchema(gadget.parameterSchema, { target: "draft-7" });
+    env.stdout.write(formatSchemaAsText(jsonSchema, "  ") + "\n\n");
+  } else {
+    env.stdout.write(chalk5.dim("No parameters required.\n\n"));
+  }
+  if (gadget.timeoutMs) {
+    env.stdout.write(chalk5.bold("Timeout:\n"));
+    env.stdout.write(`  ${gadget.timeoutMs}ms
+
+`);
+  }
+  if (gadget.examples && gadget.examples.length > 0) {
+    env.stdout.write(chalk5.bold("Examples:\n"));
+    for (const example of gadget.examples) {
+      if (example.comment) {
+        env.stdout.write(chalk5.dim(`  # ${example.comment}
+`));
+      }
+      env.stdout.write(`  Input: ${chalk5.cyan(JSON.stringify(example.params))}
+`);
+      if (example.output !== void 0) {
+        env.stdout.write(`  Output: ${chalk5.green(example.output)}
+`);
+      }
+      env.stdout.write("\n");
+    }
+  }
+}
+function buildGadgetInfo(gadget, name) {
+  const info = {
+    name,
+    description: gadget.description
+  };
+  if (gadget.parameterSchema) {
+    info.schema = schemaToJSONSchema(gadget.parameterSchema, { target: "draft-7" });
+  }
+  if (gadget.timeoutMs) {
+    info.timeoutMs = gadget.timeoutMs;
+  }
+  if (gadget.examples && gadget.examples.length > 0) {
+    info.examples = gadget.examples;
+  }
+  return info;
+}
+function formatSchemaAsText(schema, indent = "") {
+  const lines = [];
+  const properties = schema.properties || {};
+  const required = schema.required || [];
+  for (const [key, prop] of Object.entries(properties)) {
+    const type = prop.type;
+    const description = prop.description;
+    const isRequired = required.includes(key);
+    const enumValues = prop.enum;
+    const defaultValue = prop.default;
+    let line = `${indent}${chalk5.cyan(key)}`;
+    if (isRequired) {
+      line += chalk5.red("*");
+    }
+    if (type === "array") {
+      const items = prop.items;
+      const itemType = items?.type || "any";
+      line += chalk5.dim(` (${itemType}[])`);
+    } else if (type === "object" && prop.properties) {
+      line += chalk5.dim(" (object)");
+    } else {
+      line += chalk5.dim(` (${type})`);
+    }
+    if (defaultValue !== void 0) {
+      line += chalk5.dim(` [default: ${JSON.stringify(defaultValue)}]`);
+    }
+    if (description) {
+      line += `: ${description}`;
+    }
+    if (enumValues) {
+      line += chalk5.yellow(` - one of: ${enumValues.join(", ")}`);
+    }
+    lines.push(line);
+    if (type === "object" && prop.properties) {
+      lines.push(formatSchemaAsText(prop, indent + "  "));
+    }
+  }
+  return lines.join("\n");
+}
+async function executeGadgetValidate(file, env) {
+  const cwd = process.cwd();
+  try {
+    const gadgets = await loadGadgets([file], cwd);
+    if (gadgets.length === 0) {
+      throw new Error(
+        "No gadgets exported from file.\nA valid gadget must have:\n  - execute() method\n  - description property\n  - parameterSchema (optional)"
+      );
+    }
+    const issues = [];
+    for (const gadget of gadgets) {
+      const name = gadget.name ?? gadget.constructor.name;
+      if (!gadget.description) {
+        issues.push(`${name}: Missing 'description' property.`);
+      }
+      if (gadget.parameterSchema) {
+        try {
+          validateGadgetSchema(gadget.parameterSchema, name);
+        } catch (schemaError) {
+          const message = schemaError instanceof Error ? schemaError.message : String(schemaError);
+          issues.push(`${name}: ${message}`);
+        }
+      }
+      if (typeof gadget.execute !== "function") {
+        issues.push(`${name}: Missing 'execute()' method.`);
+      }
+    }
+    if (issues.length > 0) {
+      throw new Error(`Validation issues:
+${issues.map((i) => `  - ${i}`).join("\n")}`);
+    }
+    env.stdout.write(chalk5.green.bold("\n\u2713 Valid\n\n"));
+    env.stdout.write(chalk5.bold("Gadgets found:\n"));
+    for (const gadget of gadgets) {
+      const name = gadget.name ?? gadget.constructor.name;
+      const schemaInfo = gadget.parameterSchema ? chalk5.cyan("(with schema)") : chalk5.dim("(no schema)");
+      env.stdout.write(`  ${chalk5.bold(name)} ${schemaInfo}
+`);
+      env.stdout.write(chalk5.dim(`    ${gadget.description}
+`));
+    }
+    env.stdout.write("\n");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    env.stdout.write(chalk5.red.bold(`
+\u2717 Invalid
+
+`));
+    env.stdout.write(`${message}
+
+`);
+    env.setExitCode(1);
+  }
+}
+function registerGadgetCommand(program, env) {
+  const gadgetCmd = program.command("gadget").description("Test and inspect gadgets outside the agent loop.");
+  gadgetCmd.command("run <file>").description("Execute a gadget with interactive prompts or stdin JSON.").option("--name <gadget>", "Select gadget by name (required if file exports multiple)").option("--json", "Format output as pretty-printed JSON").option("--raw", "Output result as raw string without formatting").action(
+    (file, options) => executeAction(() => executeGadgetRun(file, options, env), env)
+  );
+  gadgetCmd.command("info <file>").description("Display gadget description, schema, and examples.").option("--name <gadget>", "Select gadget by name (required if file exports multiple)").option("--json", "Output as JSON instead of formatted text").action(
+    (file, options) => executeAction(() => executeGadgetInfo(file, options, env), env)
+  );
+  gadgetCmd.command("validate <file>").description("Check if file exports valid gadget(s).").action(
+    (file) => executeAction(() => executeGadgetValidate(file, env), env)
+  );
+}
+
+// src/cli/models-command.ts
+import chalk6 from "chalk";
 init_model_shortcuts();
 async function handleModelsCommand(options, env) {
   const client = env.createClient();
@@ -1976,13 +2518,13 @@ function renderTable(models, verbose, stream) {
     }
     grouped.get(provider).push(model);
   }
-  stream.write(chalk4.bold.cyan("\nAvailable Models\n"));
-  stream.write(chalk4.cyan("=".repeat(80)) + "\n\n");
+  stream.write(chalk6.bold.cyan("\nAvailable Models\n"));
+  stream.write(chalk6.cyan("=".repeat(80)) + "\n\n");
   const providers = Array.from(grouped.keys()).sort();
   for (const provider of providers) {
     const providerModels = grouped.get(provider);
     const providerName = provider.charAt(0).toUpperCase() + provider.slice(1);
-    stream.write(chalk4.bold.yellow(`${providerName} Models
+    stream.write(chalk6.bold.yellow(`${providerName} Models
 `));
     if (verbose) {
       renderVerboseTable(providerModels, stream);
@@ -1991,11 +2533,11 @@ function renderTable(models, verbose, stream) {
     }
     stream.write("\n");
   }
-  stream.write(chalk4.bold.magenta("Model Shortcuts\n"));
-  stream.write(chalk4.dim("\u2500".repeat(80)) + "\n");
+  stream.write(chalk6.bold.magenta("Model Shortcuts\n"));
+  stream.write(chalk6.dim("\u2500".repeat(80)) + "\n");
   const shortcuts = Object.entries(MODEL_ALIASES).sort((a, b) => a[0].localeCompare(b[0]));
   for (const [shortcut, fullName] of shortcuts) {
-    stream.write(chalk4.cyan(`  ${shortcut.padEnd(15)}`) + chalk4.dim(" \u2192 ") + chalk4.white(fullName) + "\n");
+    stream.write(chalk6.cyan(`  ${shortcut.padEnd(15)}`) + chalk6.dim(" \u2192 ") + chalk6.white(fullName) + "\n");
   }
   stream.write("\n");
 }
@@ -2005,45 +2547,45 @@ function renderCompactTable(models, stream) {
   const contextWidth = 13;
   const inputWidth = 10;
   const outputWidth = 10;
-  stream.write(chalk4.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream.write(chalk6.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
   stream.write(
-    chalk4.bold(
+    chalk6.bold(
       "Model ID".padEnd(idWidth) + "  " + "Display Name".padEnd(nameWidth) + "  " + "Context".padEnd(contextWidth) + "  " + "Input".padEnd(inputWidth) + "  " + "Output".padEnd(outputWidth)
     ) + "\n"
   );
-  stream.write(chalk4.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream.write(chalk6.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
   for (const model of models) {
     const contextFormatted = formatTokens2(model.contextWindow);
     const inputPrice = `$${model.pricing.input.toFixed(2)}`;
     const outputPrice = `$${model.pricing.output.toFixed(2)}`;
     stream.write(
-      chalk4.green(model.modelId.padEnd(idWidth)) + "  " + chalk4.white(model.displayName.padEnd(nameWidth)) + "  " + chalk4.yellow(contextFormatted.padEnd(contextWidth)) + "  " + chalk4.cyan(inputPrice.padEnd(inputWidth)) + "  " + chalk4.cyan(outputPrice.padEnd(outputWidth)) + "\n"
+      chalk6.green(model.modelId.padEnd(idWidth)) + "  " + chalk6.white(model.displayName.padEnd(nameWidth)) + "  " + chalk6.yellow(contextFormatted.padEnd(contextWidth)) + "  " + chalk6.cyan(inputPrice.padEnd(inputWidth)) + "  " + chalk6.cyan(outputPrice.padEnd(outputWidth)) + "\n"
     );
   }
-  stream.write(chalk4.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
-  stream.write(chalk4.dim(`  * Prices are per 1M tokens
+  stream.write(chalk6.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream.write(chalk6.dim(`  * Prices are per 1M tokens
 `));
 }
 function renderVerboseTable(models, stream) {
   for (const model of models) {
-    stream.write(chalk4.bold.green(`
+    stream.write(chalk6.bold.green(`
   ${model.modelId}
 `));
-    stream.write(chalk4.dim("  " + "\u2500".repeat(60)) + "\n");
-    stream.write(`  ${chalk4.dim("Name:")}         ${chalk4.white(model.displayName)}
+    stream.write(chalk6.dim("  " + "\u2500".repeat(60)) + "\n");
+    stream.write(`  ${chalk6.dim("Name:")}         ${chalk6.white(model.displayName)}
 `);
-    stream.write(`  ${chalk4.dim("Context:")}      ${chalk4.yellow(formatTokens2(model.contextWindow))}
+    stream.write(`  ${chalk6.dim("Context:")}      ${chalk6.yellow(formatTokens2(model.contextWindow))}
 `);
-    stream.write(`  ${chalk4.dim("Max Output:")}   ${chalk4.yellow(formatTokens2(model.maxOutputTokens))}
+    stream.write(`  ${chalk6.dim("Max Output:")}   ${chalk6.yellow(formatTokens2(model.maxOutputTokens))}
 `);
-    stream.write(`  ${chalk4.dim("Pricing:")}      ${chalk4.cyan(`$${model.pricing.input.toFixed(2)} input`)} ${chalk4.dim("/")} ${chalk4.cyan(`$${model.pricing.output.toFixed(2)} output`)} ${chalk4.dim("(per 1M tokens)")}
+    stream.write(`  ${chalk6.dim("Pricing:")}      ${chalk6.cyan(`$${model.pricing.input.toFixed(2)} input`)} ${chalk6.dim("/")} ${chalk6.cyan(`$${model.pricing.output.toFixed(2)} output`)} ${chalk6.dim("(per 1M tokens)")}
 `);
     if (model.pricing.cachedInput !== void 0) {
-      stream.write(`  ${chalk4.dim("Cached Input:")} ${chalk4.cyan(`$${model.pricing.cachedInput.toFixed(2)} per 1M tokens`)}
+      stream.write(`  ${chalk6.dim("Cached Input:")} ${chalk6.cyan(`$${model.pricing.cachedInput.toFixed(2)} per 1M tokens`)}
 `);
     }
     if (model.knowledgeCutoff) {
-      stream.write(`  ${chalk4.dim("Knowledge:")}    ${model.knowledgeCutoff}
+      stream.write(`  ${chalk6.dim("Knowledge:")}    ${model.knowledgeCutoff}
 `);
     }
     const features = [];
@@ -2054,20 +2596,20 @@ function renderVerboseTable(models, stream) {
     if (model.features.structuredOutputs) features.push("structured-outputs");
     if (model.features.fineTuning) features.push("fine-tuning");
     if (features.length > 0) {
-      stream.write(`  ${chalk4.dim("Features:")}     ${chalk4.blue(features.join(", "))}
+      stream.write(`  ${chalk6.dim("Features:")}     ${chalk6.blue(features.join(", "))}
 `);
     }
     if (model.metadata) {
       if (model.metadata.family) {
-        stream.write(`  ${chalk4.dim("Family:")}       ${model.metadata.family}
+        stream.write(`  ${chalk6.dim("Family:")}       ${model.metadata.family}
 `);
       }
       if (model.metadata.releaseDate) {
-        stream.write(`  ${chalk4.dim("Released:")}     ${model.metadata.releaseDate}
+        stream.write(`  ${chalk6.dim("Released:")}     ${model.metadata.releaseDate}
 `);
       }
       if (model.metadata.notes) {
-        stream.write(`  ${chalk4.dim("Notes:")}        ${chalk4.italic(model.metadata.notes)}
+        stream.write(`  ${chalk6.dim("Notes:")}        ${chalk6.italic(model.metadata.notes)}
 `);
       }
     }
@@ -2119,7 +2661,7 @@ function registerModelsCommand(program, env) {
 init_client();
 init_logger();
 import readline from "node:readline";
-import chalk5 from "chalk";
+import chalk7 from "chalk";
 var LOG_LEVEL_MAP = {
   silly: 0,
   trace: 1,
@@ -2166,14 +2708,14 @@ function createPromptFunction(stdin, stdout) {
         output: stdout
       });
       stdout.write("\n");
-      stdout.write(`${chalk5.cyan("\u2500".repeat(60))}
+      stdout.write(`${chalk7.cyan("\u2500".repeat(60))}
 `);
-      stdout.write(chalk5.cyan.bold("\u{1F916} Agent asks:\n"));
+      stdout.write(chalk7.cyan.bold("\u{1F916} Agent asks:\n"));
       stdout.write(`${question}
 `);
-      stdout.write(`${chalk5.cyan("\u2500".repeat(60))}
+      stdout.write(`${chalk7.cyan("\u2500".repeat(60))}
 `);
-      rl.question(chalk5.green.bold("You: "), (answer) => {
+      rl.question(chalk7.green.bold("You: "), (answer) => {
         rl.close();
         resolve(answer);
       });
@@ -2250,7 +2792,7 @@ function registerCustomCommand(program, name, config, env) {
 function parseLogLevel(value) {
   const normalized = value.toLowerCase();
   if (!LOG_LEVELS.includes(normalized)) {
-    throw new InvalidArgumentError3(`Log level must be one of: ${LOG_LEVELS.join(", ")}`);
+    throw new InvalidArgumentError2(`Log level must be one of: ${LOG_LEVELS.join(", ")}`);
   }
   return normalized;
 }
@@ -2263,6 +2805,7 @@ function createProgram(env, config) {
   registerCompleteCommand(program, env, config?.complete);
   registerAgentCommand(program, env, config?.agent);
   registerModelsCommand(program, env);
+  registerGadgetCommand(program, env);
   if (config) {
     const customNames = getCustomCommandNames(config);
     for (const name of customNames) {