llmist 0.4.0 → 0.5.0

package/dist/cli.cjs

@@ -368,6 +368,7 @@ var init_prompt_config = __esm({
       criticalUsage: "INVOKE gadgets using the markers - do not describe what you want to do.",
       formatDescriptionYaml: "Parameters in YAML format (one per line)",
       formatDescriptionJson: "Parameters in JSON format (valid JSON object)",
+      formatDescriptionToml: "Parameters in TOML format (key = value pairs, use triple-quotes for multiline)",
       rules: () => [
         "Output ONLY plain text with the exact markers - never use function/tool calling",
         "You can invoke multiple gadgets in a single response",
@@ -375,6 +376,7 @@ var init_prompt_config = __esm({
       ],
       schemaLabelJson: "\n\nInput Schema (JSON):",
       schemaLabelYaml: "\n\nInput Schema (YAML):",
+      schemaLabelToml: "\n\nInput Schema (TOML):",
       customExamples: null
     };
   }
@@ -395,6 +397,15 @@ var init_messages = __esm({
       constructor(promptConfig) {
         this.promptConfig = promptConfig ?? {};
       }
+      /**
+       * Set custom prefixes for gadget markers.
+       * Used to configure history builder to match system prompt markers.
+       */
+      withPrefixes(startPrefix, endPrefix) {
+        this.startPrefix = startPrefix;
+        this.endPrefix = endPrefix;
+        return this;
+      }
       addSystem(content, metadata) {
         this.messages.push({ role: "system", content, metadata });
         return this;
@@ -432,7 +443,14 @@ var init_messages = __esm({
         for (const gadget of gadgets) {
           const gadgetName = gadget.name ?? gadget.constructor.name;
           const instruction = gadget.getInstruction(parameterFormat);
-          const schemaMarker = parameterFormat === "yaml" ? "\n\nInput Schema (YAML):" : "\n\nInput Schema (JSON):";
+          const schemaMarkers = {
+            yaml: "\n\nInput Schema (YAML):",
+            json: "\n\nInput Schema (JSON):",
+            toml: "\n\nInput Schema (TOML):",
+            auto: "\n\nInput Schema (JSON):"
+            // auto defaults to JSON schema display
+          };
+          const schemaMarker = schemaMarkers[parameterFormat];
           const schemaIndex = instruction.indexOf(schemaMarker);
           const description = (schemaIndex !== -1 ? instruction.substring(0, schemaIndex) : instruction).trim();
           const schema = schemaIndex !== -1 ? instruction.substring(schemaIndex + schemaMarker.length).trim() : "";
@@ -452,15 +470,26 @@ ${schema}`);
       }
       buildUsageSection(parameterFormat, context) {
         const parts = [];
-        const formatDescription = parameterFormat === "yaml" ? resolvePromptTemplate(
-          this.promptConfig.formatDescriptionYaml,
-          DEFAULT_PROMPTS.formatDescriptionYaml,
-          context
-        ) : resolvePromptTemplate(
-          this.promptConfig.formatDescriptionJson,
-          DEFAULT_PROMPTS.formatDescriptionJson,
-          context
-        );
+        const formatDescriptionMap = {
+          yaml: {
+            config: this.promptConfig.formatDescriptionYaml,
+            defaultValue: DEFAULT_PROMPTS.formatDescriptionYaml
+          },
+          json: {
+            config: this.promptConfig.formatDescriptionJson,
+            defaultValue: DEFAULT_PROMPTS.formatDescriptionJson
+          },
+          toml: {
+            config: this.promptConfig.formatDescriptionToml,
+            defaultValue: DEFAULT_PROMPTS.formatDescriptionToml
+          },
+          auto: {
+            config: this.promptConfig.formatDescriptionJson,
+            defaultValue: DEFAULT_PROMPTS.formatDescriptionJson
+          }
+        };
+        const { config, defaultValue } = formatDescriptionMap[parameterFormat];
+        const formatDescription = resolvePromptTemplate(config, defaultValue, context);
         parts.push("\n\nHOW TO INVOKE GADGETS");
         parts.push("\n=====================\n");
         const criticalUsage = resolvePromptTemplate(
@@ -488,38 +517,110 @@ CRITICAL: ${criticalUsage}
           return this.promptConfig.customExamples(context);
         }
         const parts = [];
-        const singleExample = parameterFormat === "yaml" ? `${this.startPrefix}translate
+        const singleExamples = {
+          yaml: `${this.startPrefix}translate
 from: English
 to: Polish
-content: Paris is the capital of France.
-${this.endPrefix}` : `${this.startPrefix}translate
-{"from": "English", "to": "Polish", "content": "Paris is the capital of France."}
-${this.endPrefix}`;
+content: "Paris is the capital of France: a beautiful city."
+${this.endPrefix}`,
+          json: `${this.startPrefix}translate
+{"from": "English", "to": "Polish", "content": "Paris is the capital of France: a beautiful city."}
+${this.endPrefix}`,
+          toml: `${this.startPrefix}translate
+from = "English"
+to = "Polish"
+content = "Paris is the capital of France: a beautiful city."
+${this.endPrefix}`,
+          auto: `${this.startPrefix}translate
+{"from": "English", "to": "Polish", "content": "Paris is the capital of France: a beautiful city."}
+${this.endPrefix}`
+        };
         parts.push(`
 
 EXAMPLE (Single Gadget):
 
-${singleExample}`);
-        const multipleExample = parameterFormat === "yaml" ? `${this.startPrefix}translate
+${singleExamples[parameterFormat]}`);
+        const multipleExamples = {
+          yaml: `${this.startPrefix}translate
 from: English
 to: Polish
-content: Paris is the capital of France.
+content: "Paris is the capital of France: a beautiful city."
 ${this.endPrefix}
 ${this.startPrefix}analyze
 type: economic_analysis
 matter: "Polish Economy"
-question: Polish arms exports 2025.
-${this.endPrefix}` : `${this.startPrefix}translate
-{"from": "English", "to": "Polish", "content": "Paris is the capital of France."}
+question: |
+  Analyze the following:
+  - Polish arms exports 2025
+  - Economic implications
+${this.endPrefix}`,
+          json: `${this.startPrefix}translate
+{"from": "English", "to": "Polish", "content": "Paris is the capital of France: a beautiful city."}
+${this.endPrefix}
+${this.startPrefix}analyze
+{"type": "economic_analysis", "matter": "Polish Economy", "question": "Analyze the following: Polish arms exports 2025, economic implications"}
+${this.endPrefix}`,
+          toml: `${this.startPrefix}translate
+from = "English"
+to = "Polish"
+content = "Paris is the capital of France: a beautiful city."
+${this.endPrefix}
+${this.startPrefix}analyze
+type = "economic_analysis"
+matter = "Polish Economy"
+question = """
+Analyze the following:
+- Polish arms exports 2025
+- Economic implications
+"""
+${this.endPrefix}`,
+          auto: `${this.startPrefix}translate
+{"from": "English", "to": "Polish", "content": "Paris is the capital of France: a beautiful city."}
 ${this.endPrefix}
 ${this.startPrefix}analyze
-{"type": "economic_analysis", "matter": "Polish Economy", "question": "Polish arms exports 2025."}
-${this.endPrefix}`;
+{"type": "economic_analysis", "matter": "Polish Economy", "question": "Analyze the following: Polish arms exports 2025, economic implications"}
+${this.endPrefix}`
+        };
         parts.push(`
 
 EXAMPLE (Multiple Gadgets):
 
-${multipleExample}`);
+${multipleExamples[parameterFormat]}`);
+        if (parameterFormat === "yaml") {
+          parts.push(`
+
+YAML MULTILINE SYNTAX:
+For string values with special characters (colons, dashes, quotes) or multiple lines,
+use the pipe (|) syntax. ALL content lines MUST be indented with 2 spaces:
+
+CORRECT - all lines indented:
+question: |
+  Which option do you prefer?
+  - Option A: fast processing
+  - Option B: thorough analysis
+  Please choose one.
+
+WRONG - inconsistent indentation breaks YAML:
+question: |
+  Which option do you prefer?
+  - Option A: fast
+Please choose one.    <-- ERROR: not indented, breaks out of the block`);
+        } else if (parameterFormat === "toml") {
+          parts.push(`
+
+TOML MULTILINE SYNTAX:
+For string values with multiple lines or special characters, use triple-quotes ("""):
+
+filePath = "README.md"
+content = """
+# Project Title
+
+This content can contain:
+- Markdown lists
+- Special characters: # : -
+- Multiple paragraphs
+"""`);
+        }
         return parts.join("");
       }
       buildRulesSection(context) {
@@ -563,6 +664,16 @@ ${this.endPrefix}`
             return `${key}: ${JSON.stringify(value)}`;
           }).join("\n");
         }
+        if (format === "toml") {
+          return Object.entries(parameters).map(([key, value]) => {
+            if (typeof value === "string" && value.includes("\n")) {
+              return `${key} = """
+${value}
+"""`;
+            }
+            return `${key} = ${JSON.stringify(value)}`;
+          }).join("\n");
+        }
         return JSON.stringify(parameters);
       }
       build() {
@@ -664,11 +775,14 @@ var init_conversation_manager = __esm({
       initialMessages;
       historyBuilder;
       parameterFormat;
-      constructor(baseMessages, initialMessages, parameterFormat = "json") {
+      constructor(baseMessages, initialMessages, options = {}) {
         this.baseMessages = baseMessages;
         this.initialMessages = initialMessages;
-        this.parameterFormat = parameterFormat;
+        this.parameterFormat = options.parameterFormat ?? "json";
         this.historyBuilder = new LLMMessageBuilder();
+        if (options.startPrefix && options.endPrefix) {
+          this.historyBuilder.withPrefixes(options.startPrefix, options.endPrefix);
+        }
       }
       addUserMessage(content) {
         this.historyBuilder.addUser(content);
@@ -1139,11 +1253,109 @@ var init_executor = __esm({
 });
 
 // src/gadgets/parser.ts
-var yaml, globalInvocationCounter, StreamParser;
+function preprocessYaml(yamlStr) {
+  const lines = yamlStr.split("\n");
+  const result = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const match = line.match(/^(\s*)([\w-]+):\s+(.+)$/);
+    if (match) {
+      const [, indent, key, value] = match;
+      if (value === "|" || value === ">" || value === "|-" || value === ">-") {
+        result.push(line);
+        i++;
+        const keyIndentLen2 = indent.length;
+        const blockLines = [];
+        let minContentIndent = Infinity;
+        while (i < lines.length) {
+          const blockLine = lines[i];
+          const blockIndentMatch = blockLine.match(/^(\s*)/);
+          const blockIndentLen = blockIndentMatch ? blockIndentMatch[1].length : 0;
+          if (blockLine.trim() === "") {
+            blockLines.push({ content: "", originalIndent: 0 });
+            i++;
+            continue;
+          }
+          if (blockIndentLen > keyIndentLen2) {
+            const content = blockLine.substring(blockIndentLen);
+            blockLines.push({ content, originalIndent: blockIndentLen });
+            if (content.trim().length > 0) {
+              minContentIndent = Math.min(minContentIndent, blockIndentLen);
+            }
+            i++;
+          } else {
+            break;
+          }
+        }
+        const targetIndent = keyIndentLen2 + 2;
+        for (const blockLine of blockLines) {
+          if (blockLine.content === "") {
+            result.push("");
+          } else {
+            result.push(" ".repeat(targetIndent) + blockLine.content);
+          }
+        }
+        continue;
+      }
+      if (value.startsWith('"') || value.startsWith("'") || value === "true" || value === "false" || /^-?\d+(\.\d+)?$/.test(value)) {
+        result.push(line);
+        i++;
+        continue;
+      }
+      const keyIndentLen = indent.length;
+      const continuationLines = [];
+      let j = i + 1;
+      while (j < lines.length) {
+        const nextLine = lines[j];
+        if (nextLine.trim() === "") {
+          continuationLines.push(nextLine);
+          j++;
+          continue;
+        }
+        const nextIndentMatch = nextLine.match(/^(\s*)/);
+        const nextIndentLen = nextIndentMatch ? nextIndentMatch[1].length : 0;
+        if (nextIndentLen > keyIndentLen) {
+          continuationLines.push(nextLine);
+          j++;
+        } else {
+          break;
+        }
+      }
+      if (continuationLines.length > 0 && continuationLines.some((l) => l.trim().length > 0)) {
+        result.push(`${indent}${key}: |`);
+        result.push(`${indent}  ${value}`);
+        for (const contLine of continuationLines) {
+          if (contLine.trim() === "") {
+            result.push("");
+          } else {
+            const contIndentMatch = contLine.match(/^(\s*)/);
+            const contIndent = contIndentMatch ? contIndentMatch[1] : "";
+            const contContent = contLine.substring(contIndent.length);
+            result.push(`${indent}  ${contContent}`);
+          }
+        }
+        i = j;
+        continue;
+      }
+      if (value.includes(": ") || value.endsWith(":")) {
+        const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+        result.push(`${indent}${key}: "${escaped}"`);
+        i++;
+        continue;
+      }
+    }
+    result.push(line);
+    i++;
+  }
+  return result.join("\n");
+}
+var yaml, import_js_toml, globalInvocationCounter, StreamParser;
 var init_parser = __esm({
   "src/gadgets/parser.ts"() {
     "use strict";
     yaml = __toESM(require("js-yaml"), 1);
+    import_js_toml = require("js-toml");
     init_constants();
     globalInvocationCounter = 0;
     StreamParser = class {
@@ -1165,6 +1377,17 @@ var init_parser = __esm({
         this.lastReportedTextLength = index;
         return segment.trim().length > 0 ? segment : void 0;
       }
+      /**
+       * Parse gadget name, handling both old format (name:invocationId) and new format (just name).
+       * For new format, generates a unique invocation ID.
+       */
+      parseGadgetName(gadgetName) {
+        if (gadgetName.includes(":")) {
+          const parts = gadgetName.split(":");
+          return { actualName: parts[0], invocationId: parts[1] };
+        }
+        return { actualName: gadgetName, invocationId: `gadget_${++globalInvocationCounter}` };
+      }
       /**
        * Parse parameter string according to configured format
        */
@@ -1178,20 +1401,31 @@ var init_parser = __esm({
         }
         if (this.parameterFormat === "yaml") {
           try {
-            return { parameters: yaml.load(raw) };
+            return { parameters: yaml.load(preprocessYaml(raw)) };
           } catch (error) {
             return { parseError: error instanceof Error ? error.message : "Failed to parse YAML" };
           }
         }
+        if (this.parameterFormat === "toml") {
+          try {
+            return { parameters: (0, import_js_toml.load)(raw) };
+          } catch (error) {
+            return { parseError: error instanceof Error ? error.message : "Failed to parse TOML" };
+          }
+        }
         try {
           return { parameters: JSON.parse(raw) };
         } catch {
           try {
-            return { parameters: yaml.load(raw) };
-          } catch (error) {
-            return {
-              parseError: error instanceof Error ? error.message : "Failed to parse as JSON or YAML"
-            };
+            return { parameters: (0, import_js_toml.load)(raw) };
+          } catch {
+            try {
+              return { parameters: yaml.load(preprocessYaml(raw)) };
+            } catch (error) {
+              return {
+                parseError: error instanceof Error ? error.message : "Failed to parse as JSON, TOML, or YAML"
+              };
+            }
           }
         }
       }
@@ -1210,16 +1444,7 @@ var init_parser = __esm({
           const metadataEndIndex = this.buffer.indexOf("\n", metadataStartIndex);
           if (metadataEndIndex === -1) break;
           const gadgetName = this.buffer.substring(metadataStartIndex, metadataEndIndex).trim();
-          let invocationId;
-          let actualGadgetName;
-          if (gadgetName.includes(":")) {
-            const parts = gadgetName.split(":");
-            actualGadgetName = parts[0];
-            invocationId = parts[1];
-          } else {
-            actualGadgetName = gadgetName;
-            invocationId = `gadget_${++globalInvocationCounter}`;
-          }
+          const { actualName: actualGadgetName, invocationId } = this.parseGadgetName(gadgetName);
           const contentStartIndex = metadataEndIndex + 1;
           let partEndIndex;
           let endMarkerLength = 0;
@@ -1229,23 +1454,29 @@ var init_parser = __esm({
             if (partEndIndex === -1) break;
             endMarkerLength = oldEndMarker.length;
           } else {
-            partEndIndex = contentStartIndex;
+            const nextStartPos = this.buffer.indexOf(this.startPrefix, contentStartIndex);
+            let validEndPos = -1;
+            let searchPos = contentStartIndex;
             while (true) {
-              const endPos = this.buffer.indexOf(this.endPrefix, partEndIndex);
-              if (endPos === -1) {
-                partEndIndex = -1;
-                break;
-              }
+              const endPos = this.buffer.indexOf(this.endPrefix, searchPos);
+              if (endPos === -1) break;
               const afterEnd = this.buffer.substring(endPos + this.endPrefix.length);
               if (afterEnd.startsWith("\n") || afterEnd.startsWith("\r") || afterEnd.startsWith(this.startPrefix) || afterEnd.length === 0) {
-                partEndIndex = endPos;
-                endMarkerLength = this.endPrefix.length;
+                validEndPos = endPos;
                 break;
               } else {
-                partEndIndex = endPos + this.endPrefix.length;
+                searchPos = endPos + this.endPrefix.length;
               }
             }
-            if (partEndIndex === -1) break;
+            if (nextStartPos !== -1 && (validEndPos === -1 || nextStartPos < validEndPos)) {
+              partEndIndex = nextStartPos;
+              endMarkerLength = 0;
+            } else if (validEndPos !== -1) {
+              partEndIndex = validEndPos;
+              endMarkerLength = this.endPrefix.length;
+            } else {
+              break;
+            }
           }
           const parametersRaw = this.buffer.substring(contentStartIndex, partEndIndex).trim();
           const { parameters, parseError } = this.parseParameters(parametersRaw);
@@ -1268,8 +1499,35 @@ var init_parser = __esm({
           this.lastReportedTextLength = 0;
         }
       }
-      // Finalize parsing and return remaining text
+      // Finalize parsing and return remaining text or incomplete gadgets
       *finalize() {
+        const startIndex = this.buffer.indexOf(this.startPrefix, this.lastReportedTextLength);
+        if (startIndex !== -1) {
+          const textBefore = this.takeTextUntil(startIndex);
+          if (textBefore !== void 0) {
+            yield { type: "text", content: textBefore };
+          }
+          const metadataStartIndex = startIndex + this.startPrefix.length;
+          const metadataEndIndex = this.buffer.indexOf("\n", metadataStartIndex);
+          if (metadataEndIndex !== -1) {
+            const gadgetName = this.buffer.substring(metadataStartIndex, metadataEndIndex).trim();
+            const { actualName: actualGadgetName, invocationId } = this.parseGadgetName(gadgetName);
+            const contentStartIndex = metadataEndIndex + 1;
+            const parametersRaw = this.buffer.substring(contentStartIndex).trim();
+            const { parameters, parseError } = this.parseParameters(parametersRaw);
+            yield {
+              type: "gadget_call",
+              call: {
+                gadgetName: actualGadgetName,
+                invocationId,
+                parametersYaml: parametersRaw,
+                parameters,
+                parseError
+              }
+            };
+            return;
+          }
+        }
         const remainingText = this.takeTextUntil(this.buffer.length);
         if (remainingText !== void 0) {
           yield { type: "text", content: remainingText };
@@ -1750,11 +2008,11 @@ var init_agent = __esm({
           role: message.role,
           content: message.content
         }));
-        this.conversation = new ConversationManager(
-          baseMessages,
-          initialMessages,
-          this.parameterFormat
-        );
+        this.conversation = new ConversationManager(baseMessages, initialMessages, {
+          parameterFormat: this.parameterFormat,
+          startPrefix: options.gadgetStartPrefix,
+          endPrefix: options.gadgetEndPrefix
+        });
         this.userPromptProvided = !!options.userPrompt;
         if (options.userPrompt) {
           this.conversation.addUserMessage(options.userPrompt);
@@ -2745,10 +3003,11 @@ var init_gemini = __esm({
         return GEMINI_MODELS;
       }
       buildRequestPayload(options, descriptor, _spec, messages) {
-        const { systemInstruction, contents } = this.extractSystemAndContents(messages);
+        const contents = this.convertMessagesToContents(messages);
         const generationConfig = this.buildGenerationConfig(options);
         const config = {
-          ...systemInstruction ? { systemInstruction: systemInstruction.parts.map((p) => p.text).join("\n") } : {},
+          // Note: systemInstruction removed - it doesn't work with countTokens()
+          // System messages are now included in contents as user+model exchanges
           ...generationConfig ? { ...generationConfig } : {},
           // Explicitly disable function calling to prevent UNEXPECTED_TOOL_CALL errors
           toolConfig: {
@@ -2769,31 +3028,37 @@ var init_gemini = __esm({
         const streamResponse = await client.models.generateContentStream(payload);
         return streamResponse;
       }
-      extractSystemAndContents(messages) {
-        const firstSystemIndex = messages.findIndex((message) => message.role === "system");
-        if (firstSystemIndex === -1) {
-          return {
-            systemInstruction: null,
-            contents: this.mergeConsecutiveMessages(messages)
-          };
+      /**
+       * Convert LLM messages to Gemini contents format.
+       *
+       * For Gemini, we convert system messages to user+model exchanges instead of
+       * using systemInstruction, because:
+       * 1. systemInstruction doesn't work with countTokens() API
+       * 2. This approach gives perfect token counting accuracy (0% error)
+       * 3. The model receives and follows system instructions identically
+       *
+       * System message: "You are a helpful assistant"
+       * Becomes:
+       * - User: "You are a helpful assistant"
+       * - Model: "Understood."
+       */
+      convertMessagesToContents(messages) {
+        const expandedMessages = [];
+        for (const message of messages) {
+          if (message.role === "system") {
+            expandedMessages.push({
+              role: "user",
+              content: message.content
+            });
+            expandedMessages.push({
+              role: "assistant",
+              content: "Understood."
+            });
+          } else {
+            expandedMessages.push(message);
+          }
         }
-        let systemBlockEnd = firstSystemIndex;
-        while (systemBlockEnd < messages.length && messages[systemBlockEnd].role === "system") {
-          systemBlockEnd++;
-        }
-        const systemMessages = messages.slice(firstSystemIndex, systemBlockEnd);
-        const nonSystemMessages = [
-          ...messages.slice(0, firstSystemIndex),
-          ...messages.slice(systemBlockEnd)
-        ];
-        const systemInstruction = {
-          role: "system",
-          parts: systemMessages.map((message) => ({ text: message.content }))
-        };
-        return {
-          systemInstruction,
-          contents: this.mergeConsecutiveMessages(nonSystemMessages)
-        };
+        return this.mergeConsecutiveMessages(expandedMessages);
       }
       mergeConsecutiveMessages(messages) {
         if (messages.length === 0) {
@@ -2882,8 +3147,8 @@ var init_gemini = __esm({
        *
        * This method provides accurate token estimation for Gemini models by:
        * - Using the SDK's countTokens() method
-       * - Properly extracting and handling system instructions
-       * - Transforming messages to Gemini's expected format
+       * - Converting system messages to user+model exchanges (same as in generation)
+       * - This gives perfect token counting accuracy (0% error vs actual usage)
        *
        * @param messages - The messages to count tokens for
        * @param descriptor - Model descriptor containing the model name
@@ -2902,16 +3167,14 @@ var init_gemini = __esm({
        */
       async countTokens(messages, descriptor, _spec) {
         const client = this.client;
-        const { systemInstruction, contents } = this.extractSystemAndContents(messages);
-        const request = {
-          model: descriptor.name,
-          contents: this.convertContentsForNewSDK(contents)
-        };
-        if (systemInstruction) {
-          request.systemInstruction = systemInstruction.parts.map((p) => p.text).join("\n");
-        }
+        const contents = this.convertMessagesToContents(messages);
         try {
-          const response = await client.models.countTokens(request);
+          const response = await client.models.countTokens({
+            model: descriptor.name,
+            contents: this.convertContentsForNewSDK(contents)
+            // Note: systemInstruction not used - it's not supported by countTokens()
+            // and would cause a 2100% token counting error
+          });
           return response.totalTokens ?? 0;
         } catch (error) {
           console.warn(
@@ -4270,7 +4533,7 @@ var COMMANDS = {
 };
 var LOG_LEVELS = ["silly", "trace", "debug", "info", "warn", "error", "fatal"];
 var DEFAULT_MODEL = "openai:gpt-5-nano";
-var DEFAULT_PARAMETER_FORMAT = "json";
+var DEFAULT_PARAMETER_FORMAT = "toml";
 var OPTION_FLAGS = {
   model: "-m, --model <identifier>",
   systemPrompt: "-s, --system <prompt>",
@@ -4291,7 +4554,7 @@ 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', or 'auto'.",
+  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.",
   noBuiltins: "Disable built-in gadgets (AskUser, TellUser).",
@@ -4305,7 +4568,7 @@ var import_commander3 = require("commander");
 // package.json
 var package_default = {
   name: "llmist",
-  version: "0.3.1",
+  version: "0.4.1",
   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",
@@ -4389,7 +4652,10 @@ var package_default = {
     "@google/genai": "^1.27.0",
     chalk: "^5.6.2",
     commander: "^12.1.0",
+    "js-toml": "^1.0.2",
     "js-yaml": "^4.1.0",
+    marked: "^17.0.1",
+    "marked-terminal": "^7.3.0",
     openai: "^6.0.0",
     tiktoken: "^1.0.22",
     tslog: "^4.10.2",
@@ -4402,6 +4668,7 @@ var package_default = {
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@types/js-yaml": "^4.0.9",
+    "@types/marked-terminal": "^6.1.1",
     "@types/node": "^20.12.7",
     "bun-types": "^1.3.2",
     dotenv: "^17.2.3",
@@ -4414,7 +4681,7 @@ var package_default = {
 
 // src/cli/agent-command.ts
 var import_promises = require("readline/promises");
-var import_commander2 = require("commander");
+var import_chalk3 = __toESM(require("chalk"), 1);
 init_builder();
 init_registry();
 init_constants2();
@@ -4504,6 +4771,83 @@ function mergeDescriptions(schema, jsonSchema) {
 
 // src/gadgets/gadget.ts
 init_schema_validator();
+function formatYamlValue(value, indent = "") {
+  if (typeof value === "string") {
+    const lines = value.split("\n");
+    if (lines.length === 1 && !value.includes(":") && !value.startsWith("-")) {
+      return value;
+    }
+    const indentedLines = lines.map((line) => `${indent}  ${line}`).join("\n");
+    return `|
+${indentedLines}`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null || value === void 0) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const items = value.map((item) => `${indent}- ${formatYamlValue(item, indent + "  ")}`);
+    return "\n" + items.join("\n");
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) return "{}";
+    const lines = entries.map(([k, v]) => {
+      const formattedValue = formatYamlValue(v, indent + "  ");
+      if (formattedValue.startsWith("\n") || formattedValue.startsWith("|")) {
+        return `${indent}${k}: ${formattedValue}`;
+      }
+      return `${indent}${k}: ${formattedValue}`;
+    });
+    return "\n" + lines.join("\n");
+  }
+  return yaml2.dump(value).trimEnd();
+}
+function formatParamsAsYaml(params) {
+  const lines = [];
+  for (const [key, value] of Object.entries(params)) {
+    const formattedValue = formatYamlValue(value, "");
+    if (formattedValue.startsWith("\n")) {
+      lines.push(`${key}:${formattedValue}`);
+    } else {
+      lines.push(`${key}: ${formattedValue}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatTomlValue(value) {
+  if (typeof value === "string") {
+    if (value.includes("\n")) {
+      return `"""
+${value}
+"""`;
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null || value === void 0) {
+    return '""';
+  }
+  if (Array.isArray(value)) {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return JSON.stringify(value);
+}
+function formatParamsAsToml(params) {
+  const lines = [];
+  for (const [key, value] of Object.entries(params)) {
+    lines.push(`${key} = ${formatTomlValue(value)}`);
+  }
+  return lines.join("\n");
+}
 var BaseGadget = class {
   /**
    * The name of the gadget. Used for identification when LLM calls it.
@@ -4523,6 +4867,14 @@ var BaseGadget = class {
    * Set to 0 or undefined to disable timeout for this gadget.
    */
   timeoutMs;
+  /**
+   * Optional usage examples to help LLMs understand proper invocation.
+   * Examples are rendered in getInstruction() alongside the schema.
+   *
+   * Note: Uses broader `unknown` type to allow typed examples from subclasses
+   * while maintaining runtime compatibility.
+   */
+  examples;
   /**
    * Auto-generated instruction text for the LLM.
    * Combines name, description, and parameter schema into a formatted instruction.
@@ -4535,7 +4887,7 @@ var BaseGadget = class {
    * Generate instruction text for the LLM with format-specific schema.
    * Combines name, description, and parameter schema into a formatted instruction.
    *
-   * @param format - Format for the schema representation ('json' | 'yaml' | 'auto')
+   * @param format - Format for the schema representation ('json' | 'yaml' | 'toml' | 'auto')
    * @returns Formatted instruction string
    */
   getInstruction(format = "json") {
@@ -4550,12 +4902,38 @@ var BaseGadget = class {
       if (format === "json" || format === "auto") {
         parts.push("\n\nInput Schema (JSON):");
         parts.push(JSON.stringify(jsonSchema, null, 2));
+      } else if (format === "toml") {
+        parts.push("\n\nInput Schema (TOML):");
+        parts.push(JSON.stringify(jsonSchema, null, 2));
       } else {
         const yamlSchema = yaml2.dump(jsonSchema).trimEnd();
         parts.push("\n\nInput Schema (YAML):");
         parts.push(yamlSchema);
       }
     }
+    if (this.examples && this.examples.length > 0) {
+      parts.push("\n\nExamples:");
+      this.examples.forEach((example, index) => {
+        if (index > 0) {
+          parts.push("");
+        }
+        if (example.comment) {
+          parts.push(`# ${example.comment}`);
+        }
+        parts.push("Input:");
+        if (format === "json" || format === "auto") {
+          parts.push(JSON.stringify(example.params, null, 2));
+        } else if (format === "toml") {
+          parts.push(formatParamsAsToml(example.params));
+        } else {
+          parts.push(formatParamsAsYaml(example.params));
+        }
+        if (example.output !== void 0) {
+          parts.push("Output:");
+          parts.push(example.output);
+        }
+      });
+    }
     return parts.join("\n");
   }
 };
@@ -4567,6 +4945,7 @@ function createGadget(config) {
     description = config.description;
     parameterSchema = config.schema;
     timeoutMs = config.timeoutMs;
+    examples = config.examples;
     execute(params) {
       return config.execute(params);
     }
@@ -4580,8 +4959,20 @@ var askUser = createGadget({
   name: "AskUser",
   description: "Ask the user a question when you need more information or clarification. The user's response will be provided back to you.",
   schema: import_zod.z.object({
-    question: import_zod.z.string().describe("The question to ask the user")
+    question: import_zod.z.string().describe("The question to ask the user in plain-text or Markdown")
   }),
+  examples: [
+    {
+      comment: "Ask for clarification about the task",
+      params: { question: "Which file would you like me to modify?" }
+    },
+    {
+      comment: "Ask user to choose between options",
+      params: {
+        question: "I found multiple matches. Which one should I use?\n- src/utils/helper.ts\n- src/lib/helper.ts"
+      }
+    }
+  ],
   execute: ({ question }) => {
     throw new HumanInputException(question);
   }
@@ -4590,10 +4981,28 @@ var tellUser = createGadget({
   name: "TellUser",
   description: "Tell the user something important. Set done=true when your work is complete and you want to end the conversation.",
   schema: import_zod.z.object({
-    message: import_zod.z.string().describe("The message to display to the user"),
-    done: import_zod.z.boolean().describe("Set to true to end the conversation, false to continue"),
+    message: import_zod.z.string().describe("The message to display to the user in Markdown"),
+    done: import_zod.z.boolean().default(false).describe("Set to true to end the conversation, false to continue"),
     type: import_zod.z.enum(["info", "success", "warning", "error"]).default("info").describe("Message type: info, success, warning, or error")
   }),
+  examples: [
+    {
+      comment: "Report successful completion and end the conversation",
+      params: {
+        message: "I've completed the refactoring. All tests pass.",
+        done: true,
+        type: "success"
+      }
+    },
+    {
+      comment: "Warn the user about something without ending",
+      params: {
+        message: "Found 3 files with potential issues. Continuing analysis...",
+        done: false,
+        type: "warning"
+      }
+    }
+  ],
   execute: ({ message, done, type }) => {
     const prefixes = {
       info: "\u2139\uFE0F  ",
@@ -4706,6 +5115,9 @@ async function loadGadgets(specifiers, cwd, importer = (specifier) => import(spe
   return gadgets;
 }
 
+// src/cli/option-helpers.ts
+var import_commander2 = require("commander");
+
 // src/cli/utils.ts
 var import_chalk2 = __toESM(require("chalk"), 1);
 var import_commander = require("commander");
@@ -4713,6 +5125,44 @@ init_constants2();
 
 // src/cli/ui/formatters.ts
 var import_chalk = __toESM(require("chalk"), 1);
+var import_marked = require("marked");
+var import_marked_terminal = require("marked-terminal");
+var markedConfigured = false;
+function ensureMarkedConfigured() {
+  if (!markedConfigured) {
+    import_chalk.default.level = process.env.NO_COLOR ? 0 : 3;
+    import_marked.marked.use(
+      (0, import_marked_terminal.markedTerminal)({
+        // Text styling
+        strong: import_chalk.default.bold,
+        em: import_chalk.default.italic,
+        del: import_chalk.default.dim.gray.strikethrough,
+        // Code styling
+        code: import_chalk.default.yellow,
+        codespan: import_chalk.default.yellow,
+        // Headings
+        heading: import_chalk.default.green.bold,
+        firstHeading: import_chalk.default.magenta.underline.bold,
+        // Links
+        link: import_chalk.default.blue,
+        href: import_chalk.default.blue.underline,
+        // Block elements
+        blockquote: import_chalk.default.gray.italic,
+        // List formatting - reduce indentation and add bullet styling
+        tab: 2,
+        // Reduce from default 4 to 2 spaces
+        listitem: import_chalk.default.reset
+        // Keep items readable (no dim)
+      })
+    );
+    markedConfigured = true;
+  }
+}
+function renderMarkdown(text) {
+  ensureMarkedConfigured();
+  const rendered = import_marked.marked.parse(text);
+  return rendered.trimEnd();
+}
 function formatTokens(tokens) {
   return tokens >= 1e3 ? `${(tokens / 1e3).toFixed(1)}k` : `${tokens}`;
 }
@@ -4731,7 +5181,14 @@ function formatCost(cost) {
 function renderSummary(metadata) {
   const parts = [];
   if (metadata.iterations !== void 0) {
-    parts.push(import_chalk.default.cyan(`#${metadata.iterations}`));
+    const iterPart = import_chalk.default.cyan(`#${metadata.iterations}`);
+    if (metadata.model) {
+      parts.push(`${iterPart} ${import_chalk.default.magenta(metadata.model)}`);
+    } else {
+      parts.push(iterPart);
+    }
+  } else if (metadata.model) {
+    parts.push(import_chalk.default.magenta(metadata.model));
   }
   if (metadata.usage) {
     const { inputTokens, outputTokens } = metadata.usage;
@@ -4752,22 +5209,128 @@ function renderSummary(metadata) {
   }
   return parts.join(import_chalk.default.dim(" | "));
 }
+function renderOverallSummary(metadata) {
+  const parts = [];
+  if (metadata.totalTokens !== void 0 && metadata.totalTokens > 0) {
+    parts.push(import_chalk.default.dim("total:") + import_chalk.default.magenta(` ${formatTokens(metadata.totalTokens)}`));
+  }
+  if (metadata.iterations !== void 0 && metadata.iterations > 0) {
+    parts.push(import_chalk.default.cyan(`#${metadata.iterations}`));
+  }
+  if (metadata.elapsedSeconds !== void 0 && metadata.elapsedSeconds > 0) {
+    parts.push(import_chalk.default.dim(`${metadata.elapsedSeconds}s`));
+  }
+  if (metadata.cost !== void 0 && metadata.cost > 0) {
+    parts.push(import_chalk.default.cyan(`$${formatCost(metadata.cost)}`));
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return parts.join(import_chalk.default.dim(" | "));
+}
+function formatParametersInline(params) {
+  if (!params || Object.keys(params).length === 0) {
+    return "";
+  }
+  return Object.entries(params).map(([key, value]) => {
+    let formatted;
+    if (typeof value === "string") {
+      formatted = value.length > 30 ? `${value.slice(0, 30)}\u2026` : value;
+    } else if (typeof value === "boolean" || typeof value === "number") {
+      formatted = String(value);
+    } else {
+      const json = JSON.stringify(value);
+      formatted = json.length > 30 ? `${json.slice(0, 30)}\u2026` : json;
+    }
+    return `${import_chalk.default.dim(key)}${import_chalk.default.dim("=")}${import_chalk.default.cyan(formatted)}`;
+  }).join(import_chalk.default.dim(", "));
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} bytes`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
 function formatGadgetSummary(result) {
   const gadgetLabel = import_chalk.default.magenta.bold(result.gadgetName);
   const timeLabel = import_chalk.default.dim(`${Math.round(result.executionTimeMs)}ms`);
+  const paramsStr = formatParametersInline(result.parameters);
+  const paramsLabel = paramsStr ? `${import_chalk.default.dim("(")}${paramsStr}${import_chalk.default.dim(")")}` : "";
   if (result.error) {
-    return `${import_chalk.default.red("\u2717")} ${gadgetLabel} ${import_chalk.default.red("error:")} ${result.error} ${timeLabel}`;
+    const errorMsg = result.error.length > 50 ? `${result.error.slice(0, 50)}\u2026` : result.error;
+    return `${import_chalk.default.red("\u2717")} ${gadgetLabel}${paramsLabel} ${import_chalk.default.red("error:")} ${errorMsg} ${timeLabel}`;
+  }
+  let outputLabel;
+  if (result.tokenCount !== void 0 && result.tokenCount > 0) {
+    outputLabel = import_chalk.default.green(`${formatTokens(result.tokenCount)} tokens`);
+  } else if (result.result) {
+    const outputBytes = Buffer.byteLength(result.result, "utf-8");
+    outputLabel = outputBytes > 0 ? import_chalk.default.green(formatBytes(outputBytes)) : import_chalk.default.dim("no output");
+  } else {
+    outputLabel = import_chalk.default.dim("no output");
   }
-  if (result.breaksLoop) {
-    return `${import_chalk.default.yellow("\u23F9")} ${gadgetLabel} ${import_chalk.default.yellow("finished:")} ${result.result} ${timeLabel}`;
+  const icon = result.breaksLoop ? import_chalk.default.yellow("\u23F9") : import_chalk.default.green("\u2713");
+  const summaryLine = `${icon} ${gadgetLabel}${paramsLabel} ${import_chalk.default.dim("\u2192")} ${outputLabel} ${timeLabel}`;
+  if (result.gadgetName === "TellUser" && result.parameters?.message) {
+    const message = String(result.parameters.message);
+    const rendered = renderMarkdown(message);
+    return `${summaryLine}
+${rendered}`;
   }
-  const maxLen = 80;
-  const shouldTruncate = result.gadgetName !== "TellUser";
-  const resultText = result.result ? shouldTruncate && result.result.length > maxLen ? `${result.result.slice(0, maxLen)}...` : result.result : "";
-  return `${import_chalk.default.green("\u2713")} ${gadgetLabel} ${import_chalk.default.dim("\u2192")} ${resultText} ${timeLabel}`;
+  return summaryLine;
 }
 
 // src/cli/utils.ts
+var RARE_EMOJI = [
+  "\u{1F531}",
+  "\u2697\uFE0F",
+  "\u{1F9FF}",
+  "\u{1F530}",
+  "\u269B\uFE0F",
+  "\u{1F3FA}",
+  "\u{1F9EB}",
+  "\u{1F52C}",
+  "\u2695\uFE0F",
+  "\u{1F5DD}\uFE0F",
+  "\u2696\uFE0F",
+  "\u{1F52E}",
+  "\u{1FAAC}",
+  "\u{1F9EC}",
+  "\u2699\uFE0F",
+  "\u{1F529}",
+  "\u{1FA9B}",
+  "\u26CF\uFE0F",
+  "\u{1FA83}",
+  "\u{1F3F9}",
+  "\u{1F6E1}\uFE0F",
+  "\u2694\uFE0F",
+  "\u{1F5E1}\uFE0F",
+  "\u{1FA93}",
+  "\u{1F5C3}\uFE0F",
+  "\u{1F4DC}",
+  "\u{1F4EF}",
+  "\u{1F3B4}",
+  "\u{1F004}",
+  "\u{1F3B2}"
+];
+function generateMarkers() {
+  const pick = (count) => {
+    const result = [];
+    const pool = [...RARE_EMOJI];
+    for (let i = 0; i < count && pool.length > 0; i++) {
+      const idx = Math.floor(Math.random() * pool.length);
+      result.push(pool.splice(idx, 1)[0]);
+    }
+    return result.join("");
+  };
+  return {
+    startPrefix: pick(5),
+    endPrefix: pick(5)
+  };
+}
 function createNumericParser({
   label,
   integer = false,
@@ -4934,6 +5497,13 @@ var StreamProgress = class {
     if (this.totalStartTime === 0) return 0;
     return Number(((Date.now() - this.totalStartTime) / 1e3).toFixed(1));
   }
+  /**
+   * Get elapsed time in seconds for the current call.
+   * @returns Elapsed time in seconds with 1 decimal place
+   */
+  getCallElapsedSeconds() {
+    return Number(((Date.now() - this.callStartTime) / 1e3).toFixed(1));
+  }
   /**
    * Starts the progress indicator animation after a brief delay.
    */
@@ -4968,7 +5538,12 @@ var StreamProgress = class {
     const elapsed = ((Date.now() - this.callStartTime) / 1e3).toFixed(1);
     const outTokens = this.callOutputTokensEstimated ? Math.round(this.callOutputChars / FALLBACK_CHARS_PER_TOKEN) : this.callOutputTokens;
     const parts = [];
-    parts.push(import_chalk2.default.cyan(`#${this.currentIteration}`));
+    const iterPart = import_chalk2.default.cyan(`#${this.currentIteration}`);
+    if (this.model) {
+      parts.push(`${iterPart} ${import_chalk2.default.magenta(this.model)}`);
+    } else {
+      parts.push(iterPart);
+    }
     if (this.callInputTokens > 0) {
       const prefix = this.callInputTokensEstimated ? "~" : "";
       parts.push(import_chalk2.default.dim("\u2191") + import_chalk2.default.yellow(` ${prefix}${formatTokens(this.callInputTokens)}`));
@@ -4981,7 +5556,7 @@ var StreamProgress = class {
     if (this.totalCost > 0) {
       parts.push(import_chalk2.default.cyan(`$${formatCost(this.totalCost)}`));
     }
-    this.target.write(`\r${import_chalk2.default.cyan(spinner)} ${parts.join(import_chalk2.default.dim(" | "))}`);
+    this.target.write(`\r${parts.join(import_chalk2.default.dim(" | "))} ${import_chalk2.default.cyan(spinner)}`);
   }
   renderCumulativeMode(spinner) {
     const elapsed = ((Date.now() - this.totalStartTime) / 1e3).toFixed(1);
@@ -4999,7 +5574,7 @@ var StreamProgress = class {
       parts.push(import_chalk2.default.dim("cost:") + import_chalk2.default.cyan(` $${formatCost(this.totalCost)}`));
     }
     parts.push(import_chalk2.default.dim(`${elapsed}s`));
-    this.target.write(`\r${import_chalk2.default.cyan(spinner)} ${parts.join(import_chalk2.default.dim(" | "))}`);
+    this.target.write(`\r${parts.join(import_chalk2.default.dim(" | "))} ${import_chalk2.default.cyan(spinner)}`);
   }
   /**
    * Pauses the progress indicator and clears the line.
@@ -5109,15 +5684,91 @@ async function executeAction(action, env) {
   }
 }
 
-// src/cli/agent-command.ts
-var PARAMETER_FORMAT_VALUES = ["json", "yaml", "auto"];
+// 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 import_commander2.InvalidArgumentError("Parameter format must be one of 'json', 'yaml', or 'auto'.");
+    throw new import_commander2.InvalidArgumentError(
+      `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,
+    OPTION_DESCRIPTIONS.temperature,
+    createNumericParser({ label: "Temperature", min: 0, max: 2 }),
+    defaults?.temperature
+  ).option(
+    OPTION_FLAGS.maxTokens,
+    OPTION_DESCRIPTIONS.maxTokens,
+    createNumericParser({ label: "Max tokens", integer: true, min: 1 }),
+    defaults?.["max-tokens"]
+  );
+}
+function addAgentOptions(cmd, defaults) {
+  const gadgetAccumulator = (value, previous = []) => [
+    ...previous,
+    value
+  ];
+  const defaultGadgets = defaults?.gadget ?? [];
+  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,
+    OPTION_DESCRIPTIONS.temperature,
+    createNumericParser({ label: "Temperature", min: 0, max: 2 }),
+    defaults?.temperature
+  ).option(
+    OPTION_FLAGS.maxIterations,
+    OPTION_DESCRIPTIONS.maxIterations,
+    createNumericParser({ label: "Max iterations", integer: true, min: 1 }),
+    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_FLAGS.noBuiltinInteraction,
+    OPTION_DESCRIPTIONS.noBuiltinInteraction,
+    defaults?.["builtin-interaction"] !== false
+  );
+}
+function configToCompleteOptions(config) {
+  const result = {};
+  if (config.model !== void 0) result.model = config.model;
+  if (config.system !== void 0) result.system = config.system;
+  if (config.temperature !== void 0) result.temperature = config.temperature;
+  if (config["max-tokens"] !== void 0) result.maxTokens = config["max-tokens"];
+  return result;
+}
+function configToAgentOptions(config) {
+  const result = {};
+  if (config.model !== void 0) result.model = config.model;
+  if (config.system !== void 0) result.system = config.system;
+  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"];
+  return result;
+}
+
+// src/cli/agent-command.ts
+async function promptApproval(env, prompt) {
+  const rl = (0, import_promises.createInterface)({ input: env.stdin, output: env.stderr });
+  try {
+    const answer = await rl.question(prompt);
+    return answer.toLowerCase().startsWith("y");
+  } finally {
+    rl.close();
+  }
+}
 function createHumanInputHandler(env, progress) {
   const stdout = env.stdout;
   if (!isInteractive(env.stdin) || typeof stdout.isTTY !== "boolean" || !stdout.isTTY) {
@@ -5128,7 +5779,7 @@ function createHumanInputHandler(env, progress) {
     const rl = (0, import_promises.createInterface)({ input: env.stdin, output: env.stdout });
     try {
       const questionLine = question.trim() ? `
-${question.trim()}` : "";
+${renderMarkdown(question.trim())}` : "";
       let isFirst = true;
       while (true) {
         const statsPrompt = progress.formatPrompt();
@@ -5146,7 +5797,7 @@ ${statsPrompt}` : statsPrompt;
     }
   };
 }
-async function handleAgentCommand(promptArg, options, env) {
+async function executeAgent(promptArg, options, env) {
   const prompt = await resolvePrompt(promptArg, env);
   const client = env.createClient();
   const registry = new GadgetRegistry();
@@ -5168,7 +5819,6 @@ async function handleAgentCommand(promptArg, options, env) {
   const printer = new StreamPrinter(env.stdout);
   const stderrTTY = env.stderr.isTTY === true;
   const progress = new StreamProgress(env.stderr, stderrTTY, client.modelRegistry);
-  let finishReason;
   let usage;
   let iterations = 0;
   const countMessagesTokens = async (model, messages) => {
@@ -5179,6 +5829,15 @@ async function handleAgentCommand(promptArg, options, env) {
       return Math.round(totalChars / FALLBACK_CHARS_PER_TOKEN);
     }
   };
+  const countGadgetOutputTokens = async (output) => {
+    if (!output) return void 0;
+    try {
+      const messages = [{ role: "assistant", content: output }];
+      return await client.countTokens(options.model, messages);
+    } catch {
+      return void 0;
+    }
+  };
   const builder = new AgentBuilder(client).withModel(options.model).withLogger(env.createLogger("llmist:cli:agent")).withHooks({
     observers: {
       // onLLMCallStart: Start progress indicator for each LLM call
@@ -5207,7 +5866,6 @@ async function handleAgentCommand(promptArg, options, env) {
       // onLLMCallComplete: Finalize metrics after each LLM call
       // This is where you'd typically log metrics or update dashboards
       onLLMCallComplete: async (context) => {
-        finishReason = context.finishReason;
         usage = context.usage;
         iterations = Math.max(iterations, context.iteration + 1);
         if (context.usage) {
@@ -5218,7 +5876,76 @@ async function handleAgentCommand(promptArg, options, env) {
             progress.setOutputTokens(context.usage.outputTokens, false);
           }
         }
+        let callCost;
+        if (context.usage && client.modelRegistry) {
+          try {
+            const modelName = options.model.includes(":") ? options.model.split(":")[1] : options.model;
+            const costResult = client.modelRegistry.estimateCost(
+              modelName,
+              context.usage.inputTokens,
+              context.usage.outputTokens
+            );
+            if (costResult) callCost = costResult.totalCost;
+          } catch {
+          }
+        }
+        const callElapsed = progress.getCallElapsedSeconds();
         progress.endCall(context.usage);
+        if (stderrTTY) {
+          const summary = renderSummary({
+            iterations: context.iteration + 1,
+            model: options.model,
+            usage: context.usage,
+            elapsedSeconds: callElapsed,
+            cost: callCost,
+            finishReason: context.finishReason
+          });
+          if (summary) {
+            env.stderr.write(`${summary}
+`);
+          }
+        }
+      }
+    },
+    // SHOWCASE: Controller-based approval gating for dangerous gadgets
+    //
+    // This demonstrates how to add safety layers WITHOUT modifying gadgets.
+    // The RunCommand gadget is simple - it just executes commands. The CLI
+    // adds the approval flow externally via beforeGadgetExecution controller.
+    //
+    // This pattern is composable: you can apply the same gating logic to
+    // any gadget (DeleteFile, SendEmail, etc.) without changing the gadgets.
+    controllers: {
+      beforeGadgetExecution: async (ctx) => {
+        if (ctx.gadgetName !== "RunCommand") {
+          return { action: "proceed" };
+        }
+        const stdinTTY = isInteractive(env.stdin);
+        const stderrTTY2 = env.stderr.isTTY === true;
+        if (!stdinTTY || !stderrTTY2) {
+          return {
+            action: "skip",
+            syntheticResult: "status=denied\n\nRunCommand requires interactive approval. Run in a terminal to approve commands."
+          };
+        }
+        const command = ctx.parameters.command;
+        progress.pause();
+        env.stderr.write(`
+${import_chalk3.default.yellow("\u{1F512} Execute:")} ${command}
+`);
+        const approved = await promptApproval(env, "   Approve? [y/n] ");
+        if (!approved) {
+          env.stderr.write(`   ${import_chalk3.default.red("\u2717 Denied")}
+
+`);
+          return {
+            action: "skip",
+            syntheticResult: "status=denied\n\nCommand denied by user. Ask what they'd like to do instead."
+          };
+        }
+        env.stderr.write(`   ${import_chalk3.default.green("\u2713 Approved")}
+`);
+        return { action: "proceed" };
       }
     }
   });
@@ -5239,6 +5966,10 @@ async function handleAgentCommand(promptArg, options, env) {
   if (gadgets.length > 0) {
     builder.withGadgets(...gadgets);
   }
+  builder.withParameterFormat(options.parameterFormat);
+  const markers = generateMarkers();
+  builder.withGadgetStartPrefix(markers.startPrefix);
+  builder.withGadgetEndPrefix(markers.endPrefix);
   const agent = builder.ask(prompt);
   for await (const event of agent.run()) {
     if (event.type === "text") {
@@ -5247,20 +5978,22 @@ async function handleAgentCommand(promptArg, options, env) {
     } else if (event.type === "gadget_result") {
       progress.pause();
       if (stderrTTY) {
-        env.stderr.write(`${formatGadgetSummary(event.result)}
+        const tokenCount = await countGadgetOutputTokens(event.result.result);
+        env.stderr.write(`${formatGadgetSummary({ ...event.result, tokenCount })}
 `);
       }
     }
   }
   progress.complete();
   printer.ensureNewline();
-  if (stderrTTY) {
-    const summary = renderSummary({
-      finishReason,
-      usage,
+  if (stderrTTY && iterations > 1) {
+    env.stderr.write(`${import_chalk3.default.dim("\u2500".repeat(40))}
+`);
+    const summary = renderOverallSummary({
+      totalTokens: usage?.totalTokens,
       iterations,
-      cost: progress.getTotalCost(),
-      elapsedSeconds: progress.getTotalElapsedSeconds()
+      elapsedSeconds: progress.getTotalElapsedSeconds(),
+      cost: progress.getTotalCost()
     });
     if (summary) {
       env.stderr.write(`${summary}
@@ -5268,27 +6001,11 @@ async function handleAgentCommand(promptArg, options, env) {
     }
   }
 }
-function registerAgentCommand(program, env) {
-  program.command(COMMANDS.agent).description("Run the llmist agent loop with optional gadgets.").argument("[prompt]", "Prompt for the agent loop. Falls back to stdin when available.").option(OPTION_FLAGS.model, OPTION_DESCRIPTIONS.model, DEFAULT_MODEL).option(OPTION_FLAGS.systemPrompt, OPTION_DESCRIPTIONS.systemPrompt).option(
-    OPTION_FLAGS.temperature,
-    OPTION_DESCRIPTIONS.temperature,
-    createNumericParser({ label: "Temperature", min: 0, max: 2 })
-  ).option(
-    OPTION_FLAGS.maxIterations,
-    OPTION_DESCRIPTIONS.maxIterations,
-    createNumericParser({ label: "Max iterations", integer: true, min: 1 })
-  ).option(
-    OPTION_FLAGS.gadgetModule,
-    OPTION_DESCRIPTIONS.gadgetModule,
-    (value, previous = []) => [...previous, value],
-    []
-  ).option(
-    OPTION_FLAGS.parameterFormat,
-    OPTION_DESCRIPTIONS.parameterFormat,
-    parseParameterFormat,
-    DEFAULT_PARAMETER_FORMAT
-  ).option(OPTION_FLAGS.noBuiltins, OPTION_DESCRIPTIONS.noBuiltins).option(OPTION_FLAGS.noBuiltinInteraction, OPTION_DESCRIPTIONS.noBuiltinInteraction).action(
-    (prompt, options) => executeAction(() => handleAgentCommand(prompt, options, env), env)
+function registerAgentCommand(program, env, config) {
+  const cmd = program.command(COMMANDS.agent).description("Run the llmist agent loop with optional gadgets.").argument("[prompt]", "Prompt for the agent loop. Falls back to stdin when available.");
+  addAgentOptions(cmd, config);
+  cmd.action(
+    (prompt, options) => executeAction(() => executeAgent(prompt, options, env), env)
   );
 }
 
@@ -5296,7 +6013,7 @@ function registerAgentCommand(program, env) {
 init_messages();
 init_model_shortcuts();
 init_constants2();
-async function handleCompleteCommand(promptArg, options, env) {
+async function executeComplete(promptArg, options, env) {
   const prompt = await resolvePrompt(promptArg, env);
   const client = env.createClient();
   const model = resolveModel(options.model);
@@ -5350,25 +6067,307 @@ async function handleCompleteCommand(promptArg, options, env) {
     }
   }
 }
-function registerCompleteCommand(program, env) {
-  program.command(COMMANDS.complete).description("Stream a single completion from a specified model.").argument("[prompt]", "Prompt to send to the LLM. If omitted, stdin is used when available.").option(OPTION_FLAGS.model, OPTION_DESCRIPTIONS.model, DEFAULT_MODEL).option(OPTION_FLAGS.systemPrompt, OPTION_DESCRIPTIONS.systemPrompt).option(
-    OPTION_FLAGS.temperature,
-    OPTION_DESCRIPTIONS.temperature,
-    createNumericParser({ label: "Temperature", min: 0, max: 2 })
-  ).option(
-    OPTION_FLAGS.maxTokens,
-    OPTION_DESCRIPTIONS.maxTokens,
-    createNumericParser({ label: "Max tokens", integer: true, min: 1 })
-  ).action(
-    (prompt, options) => executeAction(
-      () => handleCompleteCommand(prompt, options, env),
-      env
-    )
+function registerCompleteCommand(program, env, config) {
+  const cmd = program.command(COMMANDS.complete).description("Stream a single completion from a specified model.").argument("[prompt]", "Prompt to send to the LLM. If omitted, stdin is used when available.");
+  addCompleteOptions(cmd, config);
+  cmd.action(
+    (prompt, options) => executeAction(() => executeComplete(prompt, options, env), env)
   );
 }
 
+// src/cli/config.ts
+var import_node_fs3 = require("fs");
+var import_node_os = require("os");
+var import_node_path3 = require("path");
+var import_js_toml2 = require("js-toml");
+var GLOBAL_CONFIG_KEYS = /* @__PURE__ */ new Set(["log-level", "log-file"]);
+var VALID_LOG_LEVELS = ["silly", "trace", "debug", "info", "warn", "error", "fatal"];
+var COMPLETE_CONFIG_KEYS = /* @__PURE__ */ new Set(["model", "system", "temperature", "max-tokens"]);
+var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "model",
+  "system",
+  "temperature",
+  "max-iterations",
+  "gadget",
+  "parameter-format",
+  "builtins",
+  "builtin-interaction"
+]);
+var CUSTOM_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  ...COMPLETE_CONFIG_KEYS,
+  ...AGENT_CONFIG_KEYS,
+  "type",
+  "description"
+]);
+var VALID_PARAMETER_FORMATS = ["json", "yaml", "toml", "auto"];
+function getConfigPath() {
+  return (0, import_node_path3.join)((0, import_node_os.homedir)(), ".llmist", "cli.toml");
+}
+var ConfigError = class extends Error {
+  constructor(message, path2) {
+    super(path2 ? `${path2}: ${message}` : message);
+    this.path = path2;
+    this.name = "ConfigError";
+  }
+};
+function validateString(value, key, section) {
+  if (typeof value !== "string") {
+    throw new ConfigError(`[${section}].${key} must be a string`);
+  }
+  return value;
+}
+function validateNumber(value, key, section, opts) {
+  if (typeof value !== "number") {
+    throw new ConfigError(`[${section}].${key} must be a number`);
+  }
+  if (opts?.integer && !Number.isInteger(value)) {
+    throw new ConfigError(`[${section}].${key} must be an integer`);
+  }
+  if (opts?.min !== void 0 && value < opts.min) {
+    throw new ConfigError(`[${section}].${key} must be >= ${opts.min}`);
+  }
+  if (opts?.max !== void 0 && value > opts.max) {
+    throw new ConfigError(`[${section}].${key} must be <= ${opts.max}`);
+  }
+  return value;
+}
+function validateBoolean(value, key, section) {
+  if (typeof value !== "boolean") {
+    throw new ConfigError(`[${section}].${key} must be a boolean`);
+  }
+  return value;
+}
+function validateStringArray(value, key, section) {
+  if (!Array.isArray(value)) {
+    throw new ConfigError(`[${section}].${key} must be an array`);
+  }
+  for (let i = 0; i < value.length; i++) {
+    if (typeof value[i] !== "string") {
+      throw new ConfigError(`[${section}].${key}[${i}] must be a string`);
+    }
+  }
+  return value;
+}
+function validateBaseConfig(raw, section) {
+  const result = {};
+  if ("model" in raw) {
+    result.model = validateString(raw.model, "model", section);
+  }
+  if ("system" in raw) {
+    result.system = validateString(raw.system, "system", section);
+  }
+  if ("temperature" in raw) {
+    result.temperature = validateNumber(raw.temperature, "temperature", section, {
+      min: 0,
+      max: 2
+    });
+  }
+  return result;
+}
+function validateGlobalConfig(raw, section) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError(`[${section}] must be a table`);
+  }
+  const rawObj = raw;
+  for (const key of Object.keys(rawObj)) {
+    if (!GLOBAL_CONFIG_KEYS.has(key)) {
+      throw new ConfigError(`[${section}].${key} is not a valid option`);
+    }
+  }
+  const result = {};
+  if ("log-level" in rawObj) {
+    const level = validateString(rawObj["log-level"], "log-level", section);
+    if (!VALID_LOG_LEVELS.includes(level)) {
+      throw new ConfigError(
+        `[${section}].log-level must be one of: ${VALID_LOG_LEVELS.join(", ")}`
+      );
+    }
+    result["log-level"] = level;
+  }
+  if ("log-file" in rawObj) {
+    result["log-file"] = validateString(rawObj["log-file"], "log-file", section);
+  }
+  return result;
+}
+function validateCompleteConfig(raw, section) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError(`[${section}] must be a table`);
+  }
+  const rawObj = raw;
+  for (const key of Object.keys(rawObj)) {
+    if (!COMPLETE_CONFIG_KEYS.has(key)) {
+      throw new ConfigError(`[${section}].${key} is not a valid option`);
+    }
+  }
+  const result = { ...validateBaseConfig(rawObj, section) };
+  if ("max-tokens" in rawObj) {
+    result["max-tokens"] = validateNumber(rawObj["max-tokens"], "max-tokens", section, {
+      integer: true,
+      min: 1
+    });
+  }
+  return result;
+}
+function validateAgentConfig(raw, section) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError(`[${section}] must be a table`);
+  }
+  const rawObj = raw;
+  for (const key of Object.keys(rawObj)) {
+    if (!AGENT_CONFIG_KEYS.has(key)) {
+      throw new ConfigError(`[${section}].${key} is not a valid option`);
+    }
+  }
+  const result = { ...validateBaseConfig(rawObj, section) };
+  if ("max-iterations" in rawObj) {
+    result["max-iterations"] = validateNumber(rawObj["max-iterations"], "max-iterations", section, {
+      integer: true,
+      min: 1
+    });
+  }
+  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);
+  }
+  if ("builtin-interaction" in rawObj) {
+    result["builtin-interaction"] = validateBoolean(
+      rawObj["builtin-interaction"],
+      "builtin-interaction",
+      section
+    );
+  }
+  return result;
+}
+function validateCustomConfig(raw, section) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError(`[${section}] must be a table`);
+  }
+  const rawObj = raw;
+  for (const key of Object.keys(rawObj)) {
+    if (!CUSTOM_CONFIG_KEYS.has(key)) {
+      throw new ConfigError(`[${section}].${key} is not a valid option`);
+    }
+  }
+  let type = "agent";
+  if ("type" in rawObj) {
+    const typeValue = validateString(rawObj.type, "type", section);
+    if (typeValue !== "agent" && typeValue !== "complete") {
+      throw new ConfigError(`[${section}].type must be "agent" or "complete"`);
+    }
+    type = typeValue;
+  }
+  const result = {
+    ...validateBaseConfig(rawObj, section),
+    type
+  };
+  if ("description" in rawObj) {
+    result.description = validateString(rawObj.description, "description", section);
+  }
+  if ("max-iterations" in rawObj) {
+    result["max-iterations"] = validateNumber(rawObj["max-iterations"], "max-iterations", section, {
+      integer: true,
+      min: 1
+    });
+  }
+  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);
+  }
+  if ("builtin-interaction" in rawObj) {
+    result["builtin-interaction"] = validateBoolean(
+      rawObj["builtin-interaction"],
+      "builtin-interaction",
+      section
+    );
+  }
+  if ("max-tokens" in rawObj) {
+    result["max-tokens"] = validateNumber(rawObj["max-tokens"], "max-tokens", section, {
+      integer: true,
+      min: 1
+    });
+  }
+  return result;
+}
+function validateConfig(raw, configPath) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError("Config must be a TOML table", configPath);
+  }
+  const rawObj = raw;
+  const result = {};
+  for (const [key, value] of Object.entries(rawObj)) {
+    try {
+      if (key === "global") {
+        result.global = validateGlobalConfig(value, key);
+      } else if (key === "complete") {
+        result.complete = validateCompleteConfig(value, key);
+      } else if (key === "agent") {
+        result.agent = validateAgentConfig(value, key);
+      } else {
+        result[key] = validateCustomConfig(value, key);
+      }
+    } catch (error) {
+      if (error instanceof ConfigError) {
+        throw new ConfigError(error.message, configPath);
+      }
+      throw error;
+    }
+  }
+  return result;
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!(0, import_node_fs3.existsSync)(configPath)) {
+    return {};
+  }
+  let content;
+  try {
+    content = (0, import_node_fs3.readFileSync)(configPath, "utf-8");
+  } catch (error) {
+    throw new ConfigError(
+      `Failed to read config file: ${error instanceof Error ? error.message : "Unknown error"}`,
+      configPath
+    );
+  }
+  let raw;
+  try {
+    raw = (0, import_js_toml2.load)(content);
+  } catch (error) {
+    throw new ConfigError(
+      `Invalid TOML syntax: ${error instanceof Error ? error.message : "Unknown error"}`,
+      configPath
+    );
+  }
+  return validateConfig(raw, configPath);
+}
+function getCustomCommandNames(config) {
+  const reserved = /* @__PURE__ */ new Set(["global", "complete", "agent"]);
+  return Object.keys(config).filter((key) => !reserved.has(key));
+}
+
 // src/cli/models-command.ts
-var import_chalk3 = __toESM(require("chalk"), 1);
+var import_chalk4 = __toESM(require("chalk"), 1);
 init_model_shortcuts();
 async function handleModelsCommand(options, env) {
   const client = env.createClient();
@@ -5388,13 +6387,13 @@ function renderTable(models, verbose, stream2) {
     }
     grouped.get(provider).push(model);
   }
-  stream2.write(import_chalk3.default.bold.cyan("\nAvailable Models\n"));
-  stream2.write(import_chalk3.default.cyan("=".repeat(80)) + "\n\n");
+  stream2.write(import_chalk4.default.bold.cyan("\nAvailable Models\n"));
+  stream2.write(import_chalk4.default.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);
-    stream2.write(import_chalk3.default.bold.yellow(`${providerName} Models
+    stream2.write(import_chalk4.default.bold.yellow(`${providerName} Models
 `));
     if (verbose) {
       renderVerboseTable(providerModels, stream2);
@@ -5403,11 +6402,11 @@ function renderTable(models, verbose, stream2) {
     }
     stream2.write("\n");
   }
-  stream2.write(import_chalk3.default.bold.magenta("Model Shortcuts\n"));
-  stream2.write(import_chalk3.default.dim("\u2500".repeat(80)) + "\n");
+  stream2.write(import_chalk4.default.bold.magenta("Model Shortcuts\n"));
+  stream2.write(import_chalk4.default.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) {
-    stream2.write(import_chalk3.default.cyan(`  ${shortcut.padEnd(15)}`) + import_chalk3.default.dim(" \u2192 ") + import_chalk3.default.white(fullName) + "\n");
+    stream2.write(import_chalk4.default.cyan(`  ${shortcut.padEnd(15)}`) + import_chalk4.default.dim(" \u2192 ") + import_chalk4.default.white(fullName) + "\n");
   }
   stream2.write("\n");
 }
@@ -5417,45 +6416,45 @@ function renderCompactTable(models, stream2) {
   const contextWidth = 13;
   const inputWidth = 10;
   const outputWidth = 10;
-  stream2.write(import_chalk3.default.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream2.write(import_chalk4.default.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
   stream2.write(
-    import_chalk3.default.bold(
+    import_chalk4.default.bold(
       "Model ID".padEnd(idWidth) + "  " + "Display Name".padEnd(nameWidth) + "  " + "Context".padEnd(contextWidth) + "  " + "Input".padEnd(inputWidth) + "  " + "Output".padEnd(outputWidth)
     ) + "\n"
   );
-  stream2.write(import_chalk3.default.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream2.write(import_chalk4.default.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)}`;
     stream2.write(
-      import_chalk3.default.green(model.modelId.padEnd(idWidth)) + "  " + import_chalk3.default.white(model.displayName.padEnd(nameWidth)) + "  " + import_chalk3.default.yellow(contextFormatted.padEnd(contextWidth)) + "  " + import_chalk3.default.cyan(inputPrice.padEnd(inputWidth)) + "  " + import_chalk3.default.cyan(outputPrice.padEnd(outputWidth)) + "\n"
+      import_chalk4.default.green(model.modelId.padEnd(idWidth)) + "  " + import_chalk4.default.white(model.displayName.padEnd(nameWidth)) + "  " + import_chalk4.default.yellow(contextFormatted.padEnd(contextWidth)) + "  " + import_chalk4.default.cyan(inputPrice.padEnd(inputWidth)) + "  " + import_chalk4.default.cyan(outputPrice.padEnd(outputWidth)) + "\n"
     );
   }
-  stream2.write(import_chalk3.default.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
-  stream2.write(import_chalk3.default.dim(`  * Prices are per 1M tokens
+  stream2.write(import_chalk4.default.dim("\u2500".repeat(idWidth + nameWidth + contextWidth + inputWidth + outputWidth + 8)) + "\n");
+  stream2.write(import_chalk4.default.dim(`  * Prices are per 1M tokens
 `));
 }
 function renderVerboseTable(models, stream2) {
   for (const model of models) {
-    stream2.write(import_chalk3.default.bold.green(`
+    stream2.write(import_chalk4.default.bold.green(`
   ${model.modelId}
 `));
-    stream2.write(import_chalk3.default.dim("  " + "\u2500".repeat(60)) + "\n");
-    stream2.write(`  ${import_chalk3.default.dim("Name:")}         ${import_chalk3.default.white(model.displayName)}
+    stream2.write(import_chalk4.default.dim("  " + "\u2500".repeat(60)) + "\n");
+    stream2.write(`  ${import_chalk4.default.dim("Name:")}         ${import_chalk4.default.white(model.displayName)}
 `);
-    stream2.write(`  ${import_chalk3.default.dim("Context:")}      ${import_chalk3.default.yellow(formatTokens2(model.contextWindow))}
+    stream2.write(`  ${import_chalk4.default.dim("Context:")}      ${import_chalk4.default.yellow(formatTokens2(model.contextWindow))}
 `);
-    stream2.write(`  ${import_chalk3.default.dim("Max Output:")}   ${import_chalk3.default.yellow(formatTokens2(model.maxOutputTokens))}
+    stream2.write(`  ${import_chalk4.default.dim("Max Output:")}   ${import_chalk4.default.yellow(formatTokens2(model.maxOutputTokens))}
 `);
-    stream2.write(`  ${import_chalk3.default.dim("Pricing:")}      ${import_chalk3.default.cyan(`$${model.pricing.input.toFixed(2)} input`)} ${import_chalk3.default.dim("/")} ${import_chalk3.default.cyan(`$${model.pricing.output.toFixed(2)} output`)} ${import_chalk3.default.dim("(per 1M tokens)")}
+    stream2.write(`  ${import_chalk4.default.dim("Pricing:")}      ${import_chalk4.default.cyan(`$${model.pricing.input.toFixed(2)} input`)} ${import_chalk4.default.dim("/")} ${import_chalk4.default.cyan(`$${model.pricing.output.toFixed(2)} output`)} ${import_chalk4.default.dim("(per 1M tokens)")}
 `);
     if (model.pricing.cachedInput !== void 0) {
-      stream2.write(`  ${import_chalk3.default.dim("Cached Input:")} ${import_chalk3.default.cyan(`$${model.pricing.cachedInput.toFixed(2)} per 1M tokens`)}
+      stream2.write(`  ${import_chalk4.default.dim("Cached Input:")} ${import_chalk4.default.cyan(`$${model.pricing.cachedInput.toFixed(2)} per 1M tokens`)}
 `);
     }
     if (model.knowledgeCutoff) {
-      stream2.write(`  ${import_chalk3.default.dim("Knowledge:")}    ${model.knowledgeCutoff}
+      stream2.write(`  ${import_chalk4.default.dim("Knowledge:")}    ${model.knowledgeCutoff}
 `);
     }
     const features = [];
@@ -5466,20 +6465,20 @@ function renderVerboseTable(models, stream2) {
     if (model.features.structuredOutputs) features.push("structured-outputs");
     if (model.features.fineTuning) features.push("fine-tuning");
     if (features.length > 0) {
-      stream2.write(`  ${import_chalk3.default.dim("Features:")}     ${import_chalk3.default.blue(features.join(", "))}
+      stream2.write(`  ${import_chalk4.default.dim("Features:")}     ${import_chalk4.default.blue(features.join(", "))}
 `);
     }
     if (model.metadata) {
       if (model.metadata.family) {
-        stream2.write(`  ${import_chalk3.default.dim("Family:")}       ${model.metadata.family}
+        stream2.write(`  ${import_chalk4.default.dim("Family:")}       ${model.metadata.family}
 `);
       }
       if (model.metadata.releaseDate) {
-        stream2.write(`  ${import_chalk3.default.dim("Released:")}     ${model.metadata.releaseDate}
+        stream2.write(`  ${import_chalk4.default.dim("Released:")}     ${model.metadata.releaseDate}
 `);
       }
       if (model.metadata.notes) {
-        stream2.write(`  ${import_chalk3.default.dim("Notes:")}        ${import_chalk3.default.italic(model.metadata.notes)}
+        stream2.write(`  ${import_chalk4.default.dim("Notes:")}        ${import_chalk4.default.italic(model.metadata.notes)}
 `);
       }
     }
@@ -5527,9 +6526,41 @@ function registerModelsCommand(program, env) {
   );
 }
 
+// src/cli/custom-command.ts
+function registerCustomCommand(program, name, config, env) {
+  const type = config.type ?? "agent";
+  const description = config.description ?? `Custom ${type} command`;
+  const cmd = program.command(name).description(description).argument("[prompt]", "Prompt for the command. Falls back to stdin when available.");
+  if (type === "complete") {
+    addCompleteOptions(cmd, config);
+    cmd.action(
+      (prompt, cliOptions) => executeAction(async () => {
+        const configDefaults = configToCompleteOptions(config);
+        const options = {
+          ...configDefaults,
+          ...cliOptions
+        };
+        await executeComplete(prompt, options, env);
+      }, env)
+    );
+  } else {
+    addAgentOptions(cmd, config);
+    cmd.action(
+      (prompt, cliOptions) => executeAction(async () => {
+        const configDefaults = configToAgentOptions(config);
+        const options = {
+          ...configDefaults,
+          ...cliOptions
+        };
+        await executeAgent(prompt, options, env);
+      }, env)
+    );
+  }
+}
+
 // src/cli/environment.ts
 var import_node_readline = __toESM(require("readline"), 1);
-var import_chalk4 = __toESM(require("chalk"), 1);
+var import_chalk5 = __toESM(require("chalk"), 1);
 init_client();
 init_logger();
 var LOG_LEVEL_MAP = {
@@ -5575,14 +6606,14 @@ function createPromptFunction(stdin, stdout) {
         output: stdout
       });
       stdout.write("\n");
-      stdout.write(`${import_chalk4.default.cyan("\u2500".repeat(60))}
+      stdout.write(`${import_chalk5.default.cyan("\u2500".repeat(60))}
 `);
-      stdout.write(import_chalk4.default.cyan.bold("\u{1F916} Agent asks:\n"));
+      stdout.write(import_chalk5.default.cyan.bold("\u{1F916} Agent asks:\n"));
       stdout.write(`${question}
 `);
-      stdout.write(`${import_chalk4.default.cyan("\u2500".repeat(60))}
+      stdout.write(`${import_chalk5.default.cyan("\u2500".repeat(60))}
 `);
-      rl.question(import_chalk4.default.green.bold("You: "), (answer) => {
+      rl.question(import_chalk5.default.green.bold("You: "), (answer) => {
         rl.close();
         resolve(answer);
       });
@@ -5617,29 +6648,39 @@ function parseLogLevel2(value) {
   }
   return normalized;
 }
-function createProgram(env) {
+function createProgram(env, config) {
   const program = new import_commander3.Command();
   program.name(CLI_NAME).description(CLI_DESCRIPTION).version(package_default.version).option(OPTION_FLAGS.logLevel, OPTION_DESCRIPTIONS.logLevel, parseLogLevel2).option(OPTION_FLAGS.logFile, OPTION_DESCRIPTIONS.logFile).configureOutput({
     writeOut: (str) => env.stdout.write(str),
     writeErr: (str) => env.stderr.write(str)
   });
-  registerCompleteCommand(program, env);
-  registerAgentCommand(program, env);
+  registerCompleteCommand(program, env, config?.complete);
+  registerAgentCommand(program, env, config?.agent);
   registerModelsCommand(program, env);
+  if (config) {
+    const customNames = getCustomCommandNames(config);
+    for (const name of customNames) {
+      const cmdConfig = config[name];
+      registerCustomCommand(program, name, cmdConfig, env);
+    }
+  }
   return program;
 }
 async function runCLI(overrides = {}) {
+  const opts = "env" in overrides || "config" in overrides ? overrides : { env: overrides };
+  const config = opts.config !== void 0 ? opts.config : loadConfig();
+  const envOverrides = opts.env ?? {};
   const preParser = new import_commander3.Command();
   preParser.option(OPTION_FLAGS.logLevel, OPTION_DESCRIPTIONS.logLevel, parseLogLevel2).option(OPTION_FLAGS.logFile, OPTION_DESCRIPTIONS.logFile).allowUnknownOption().allowExcessArguments().helpOption(false);
   preParser.parse(process.argv);
   const globalOpts = preParser.opts();
   const loggerConfig = {
-    logLevel: globalOpts.logLevel,
-    logFile: globalOpts.logFile
+    logLevel: globalOpts.logLevel ?? config.global?.["log-level"],
+    logFile: globalOpts.logFile ?? config.global?.["log-file"]
   };
   const defaultEnv = createDefaultEnvironment(loggerConfig);
-  const env = { ...defaultEnv, ...overrides };
-  const program = createProgram(env);
+  const env = { ...defaultEnv, ...envOverrides };
+  const program = createProgram(env, config);
   await program.parseAsync(env.argv);
 }