llmist 0.7.0 → 1.0.0

package/dist/cli.js

@@ -22,7 +22,7 @@ import {
   init_model_shortcuts,
   init_registry,
   resolveModel
-} from "./chunk-ZFHFBEQ5.js";
+} from "./chunk-T24KLXY4.js";
 
 // src/cli/constants.ts
 var CLI_NAME = "llmist";
@@ -34,7 +34,6 @@ var COMMANDS = {
 };
 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,12 +41,14 @@ 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"
+  noBuiltinInteraction: "--no-builtin-interaction",
+  quiet: "-q, --quiet"
 };
 var OPTION_DESCRIPTIONS = {
   model: "Model identifier, e.g. openai:gpt-5-nano or anthropic:claude-sonnet-4-5.",
@@ -56,22 +57,24 @@ 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."
+  noBuiltinInteraction: "Disable interactive gadgets (AskUser) while keeping TellUser.",
+  quiet: "Suppress all output except content (text and TellUser messages)."
 };
 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.6.2",
+  version: "0.8.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",
@@ -155,6 +158,7 @@ var package_default = {
     "@google/genai": "^1.27.0",
     chalk: "^5.6.2",
     commander: "^12.1.0",
+    eta: "^4.4.1",
     "js-toml": "^1.0.2",
     "js-yaml": "^4.1.0",
     marked: "^15.0.12",
@@ -274,12 +278,19 @@ import fs from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 var PATH_PREFIXES = [".", "/", "~"];
+function isGadgetLike(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.execute === "function" && typeof obj.description === "string" && ("parameterSchema" in obj || "schema" in obj);
+}
 function isGadgetConstructor(value) {
   if (typeof value !== "function") {
     return false;
   }
   const prototype = value.prototype;
-  return Boolean(prototype) && prototype instanceof BaseGadget;
+  return Boolean(prototype) && (prototype instanceof BaseGadget || isGadgetLike(prototype));
 }
 function expandHomePath(input) {
   if (!input.startsWith("~")) {
@@ -316,7 +327,7 @@ function extractGadgetsFromModule(moduleExports) {
       return;
     }
     visited.add(value);
-    if (value instanceof BaseGadget) {
+    if (value instanceof BaseGadget || isGadgetLike(value)) {
       results.push(value);
       return;
     }
@@ -365,8 +376,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();
@@ -410,9 +446,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}`;
 }
@@ -441,8 +497,14 @@ function renderSummary(metadata) {
     parts.push(chalk.magenta(metadata.model));
   }
   if (metadata.usage) {
-    const { inputTokens, outputTokens } = metadata.usage;
+    const { inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens } = metadata.usage;
     parts.push(chalk.dim("\u2191") + chalk.yellow(` ${formatTokens(inputTokens)}`));
+    if (cachedInputTokens && cachedInputTokens > 0) {
+      parts.push(chalk.dim("\u27F3") + chalk.blue(` ${formatTokens(cachedInputTokens)}`));
+    }
+    if (cacheCreationInputTokens && cacheCreationInputTokens > 0) {
+      parts.push(chalk.dim("\u270E") + chalk.magenta(` ${formatTokens(cacheCreationInputTokens)}`));
+    }
     parts.push(chalk.dim("\u2193") + chalk.green(` ${formatTokens(outputTokens)}`));
   }
   if (metadata.elapsedSeconds !== void 0 && metadata.elapsedSeconds > 0) {
@@ -526,7 +588,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}`;
   }
@@ -611,6 +673,9 @@ var StreamProgress = class {
   callOutputTokensEstimated = true;
   callOutputChars = 0;
   isStreaming = false;
+  // Cache token tracking for live cost estimation during streaming
+  callCachedInputTokens = 0;
+  callCacheCreationInputTokens = 0;
   // Cumulative stats (cumulative mode)
   totalStartTime = Date.now();
   totalTokens = 0;
@@ -636,11 +701,13 @@ var StreamProgress = class {
     this.callOutputTokensEstimated = true;
     this.callOutputChars = 0;
     this.isStreaming = false;
+    this.callCachedInputTokens = 0;
+    this.callCacheCreationInputTokens = 0;
     this.start();
   }
   /**
    * Ends the current LLM call. Updates cumulative stats and switches to cumulative mode.
-   * @param usage - Final token usage from the call
+   * @param usage - Final token usage from the call (including cached tokens if available)
    */
   endCall(usage) {
     this.iterations++;
@@ -652,7 +719,9 @@ var StreamProgress = class {
           const cost = this.modelRegistry.estimateCost(
             modelName,
             usage.inputTokens,
-            usage.outputTokens
+            usage.outputTokens,
+            usage.cachedInputTokens ?? 0,
+            usage.cacheCreationInputTokens ?? 0
           );
           if (cost) {
             this.totalCost += cost.totalCost;
@@ -692,6 +761,16 @@ var StreamProgress = class {
     this.callOutputTokens = tokens;
     this.callOutputTokensEstimated = estimated;
   }
+  /**
+   * Sets cached token counts for the current call (from stream metadata).
+   * Used for live cost estimation during streaming.
+   * @param cachedInputTokens - Number of tokens read from cache (cheaper)
+   * @param cacheCreationInputTokens - Number of tokens written to cache (more expensive)
+   */
+  setCachedTokens(cachedInputTokens, cacheCreationInputTokens) {
+    this.callCachedInputTokens = cachedInputTokens;
+    this.callCacheCreationInputTokens = cacheCreationInputTokens;
+  }
   /**
    * Get total elapsed time in seconds since the first call started.
    * @returns Elapsed time in seconds with 1 decimal place
@@ -756,11 +835,32 @@ var StreamProgress = class {
       parts.push(chalk2.dim("\u2193") + chalk2.green(` ${prefix}${formatTokens(outTokens)}`));
     }
     parts.push(chalk2.dim(`${elapsed}s`));
-    if (this.totalCost > 0) {
-      parts.push(chalk2.cyan(`$${formatCost(this.totalCost)}`));
+    const callCost = this.calculateCurrentCallCost(outTokens);
+    if (callCost > 0) {
+      parts.push(chalk2.cyan(`$${formatCost(callCost)}`));
     }
     this.target.write(`\r${parts.join(chalk2.dim(" | "))} ${chalk2.cyan(spinner)}`);
   }
+  /**
+   * Calculates live cost estimate for the current streaming call.
+   * Uses current input/output tokens and cached token counts.
+   */
+  calculateCurrentCallCost(outputTokens) {
+    if (!this.modelRegistry || !this.model) return 0;
+    try {
+      const modelName = this.model.includes(":") ? this.model.split(":")[1] : this.model;
+      const cost = this.modelRegistry.estimateCost(
+        modelName,
+        this.callInputTokens,
+        outputTokens,
+        this.callCachedInputTokens,
+        this.callCacheCreationInputTokens
+      );
+      return cost?.totalCost ?? 0;
+    } catch {
+      return 0;
+    }
+  }
   renderCumulativeMode(spinner) {
     const elapsed = ((Date.now() - this.totalStartTime) / 1e3).toFixed(1);
     const parts = [];
@@ -795,7 +895,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;
     }
   }
@@ -888,16 +988,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,
@@ -909,7 +999,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.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 = []) => [
@@ -929,16 +1019,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.logLlmRequests, OPTION_DESCRIPTIONS.logLlmRequests, defaults?.["log-llm-requests"]).option(OPTION_FLAGS.logLlmResponses, OPTION_DESCRIPTIONS.logLlmResponses, defaults?.["log-llm-responses"]);
 }
 function configToCompleteOptions(config) {
   const result = {};
@@ -946,6 +1031,9 @@ function configToCompleteOptions(config) {
   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"];
+  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) {
@@ -955,7 +1043,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"];
@@ -963,6 +1050,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;
 }
 
@@ -986,7 +1078,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();
@@ -1008,9 +1100,10 @@ async function executeAgent(promptArg, options, env) {
   const prompt = await resolvePrompt(promptArg, env);
   const client = env.createClient();
   const registry = new GadgetRegistry();
+  const stdinIsInteractive = isInteractive(env.stdin);
   if (options.builtins !== false) {
     for (const gadget of builtinGadgets) {
-      if (options.builtinInteraction === false && gadget.name === "AskUser") {
+      if (gadget.name === "AskUser" && (options.builtinInteraction === false || !stdinIsInteractive)) {
         continue;
       }
       registry.registerByClass(gadget);
@@ -1028,6 +1121,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);
@@ -1050,12 +1146,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
@@ -1068,6 +1170,10 @@ async function executeAgent(promptArg, options, env) {
           if (context.usage.outputTokens) {
             progress.setOutputTokens(context.usage.outputTokens, false);
           }
+          progress.setCachedTokens(
+            context.usage.cachedInputTokens ?? 0,
+            context.usage.cacheCreationInputTokens ?? 0
+          );
         }
       },
       // onLLMCallComplete: Finalize metrics after each LLM call
@@ -1086,11 +1192,13 @@ async function executeAgent(promptArg, options, env) {
         let callCost;
         if (context.usage && client.modelRegistry) {
           try {
-            const modelName = options.model.includes(":") ? options.model.split(":")[1] : options.model;
+            const modelName = context.options.model.includes(":") ? context.options.model.split(":")[1] : context.options.model;
             const costResult = client.modelRegistry.estimateCost(
               modelName,
               context.usage.inputTokens,
-              context.usage.outputTokens
+              context.usage.outputTokens,
+              context.usage.cachedInputTokens ?? 0,
+              context.usage.cacheCreationInputTokens ?? 0
             );
             if (costResult) callCost = costResult.totalCost;
           } catch {
@@ -1098,7 +1206,7 @@ async function executeAgent(promptArg, options, env) {
         }
         const callElapsed = progress.getCallElapsedSeconds();
         progress.endCall(context.usage);
-        if (stderrTTY) {
+        if (!options.quiet) {
           const summary = renderSummary({
             iterations: context.iteration + 1,
             model: options.model,
@@ -1112,6 +1220,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
@@ -1176,13 +1288,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",
     {
@@ -1199,22 +1313,38 @@ 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 (stderrTTY) {
+      if (options.quiet) {
+        if (event.result.gadgetName === "TellUser" && event.result.parameters?.message) {
+          const message = String(event.result.parameters.message);
+          env.stdout.write(`${message}
+`);
+        }
+      } else {
         const tokenCount = await countGadgetOutputTokens(event.result.result);
         env.stderr.write(`${formatGadgetSummary({ ...event.result, tokenCount })}
 `);
       }
     }
   }
+  flushTextBuffer();
   progress.complete();
   printer.ensureNewline();
-  if (stderrTTY && iterations > 1) {
+  if (!options.quiet && iterations > 1) {
     env.stderr.write(`${chalk3.dim("\u2500".repeat(40))}
 `);
     const summary = renderOverallSummary({
@@ -1250,9 +1380,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
   });
@@ -1263,7 +1402,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;
@@ -1276,8 +1415,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) {
@@ -1287,7 +1426,11 @@ async function executeComplete(promptArg, options, env) {
   progress.endCall(usage);
   progress.complete();
   printer.ensureNewline();
-  if (stderrTTY) {
+  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) {
       env.stderr.write(`${summary}
@@ -1305,36 +1448,136 @@ 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
+import { Eta } from "eta";
+var TemplateError = class extends Error {
+  constructor(message, promptName, configPath) {
+    super(promptName ? `[prompts.${promptName}]: ${message}` : message);
+    this.promptName = promptName;
+    this.configPath = configPath;
+    this.name = "TemplateError";
+  }
+};
+function createTemplateEngine(prompts, configPath) {
+  const eta = new Eta({
+    views: "/",
+    // Required but we use named templates
+    autoEscape: false,
+    // Don't escape - these are prompts, not HTML
+    autoTrim: false
+    // Preserve whitespace in prompts
+  });
+  for (const [name, template] of Object.entries(prompts)) {
+    try {
+      eta.loadTemplate(`@${name}`, template);
+    } catch (error) {
+      throw new TemplateError(
+        error instanceof Error ? error.message : String(error),
+        name,
+        configPath
+      );
+    }
+  }
+  return eta;
+}
+function resolveTemplate(eta, template, context = {}, configPath) {
+  try {
+    const fullContext = {
+      ...context,
+      env: process.env
+    };
+    return eta.renderString(template, fullContext);
+  } catch (error) {
+    throw new TemplateError(
+      error instanceof Error ? error.message : String(error),
+      void 0,
+      configPath
+    );
+  }
+}
+function validatePrompts(prompts, configPath) {
+  const eta = createTemplateEngine(prompts, configPath);
+  for (const [name, template] of Object.entries(prompts)) {
+    try {
+      eta.renderString(template, { env: {} });
+    } catch (error) {
+      throw new TemplateError(
+        error instanceof Error ? error.message : String(error),
+        name,
+        configPath
+      );
+    }
+  }
+}
+function validateEnvVars(template, promptName, configPath) {
+  const envVarPattern = /<%=\s*it\.env\.(\w+)\s*%>/g;
+  const matches = template.matchAll(envVarPattern);
+  for (const match of matches) {
+    const varName = match[1];
+    if (process.env[varName] === void 0) {
+      throw new TemplateError(
+        `Environment variable '${varName}' is not set`,
+        promptName,
+        configPath
+      );
+    }
+  }
+}
+function hasTemplateSyntax(str) {
+  return str.includes("<%");
+}
+
+// src/cli/config.ts
 var GLOBAL_CONFIG_KEYS = /* @__PURE__ */ new Set(["log-level", "log-file", "log-reset"]);
 var VALID_LOG_LEVELS = ["silly", "trace", "debug", "info", "warn", "error", "fatal"];
-var COMPLETE_CONFIG_KEYS = /* @__PURE__ */ new Set(["model", "system", "temperature", "max-tokens"]);
+var COMPLETE_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "model",
+  "system",
+  "temperature",
+  "max-tokens",
+  "quiet",
+  "inherits",
+  "log-level",
+  "log-file",
+  "log-reset",
+  "log-llm-requests",
+  "log-llm-responses",
+  "type"
+  // Allowed for inheritance compatibility, ignored for built-in commands
+]);
 var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "model",
   "system",
   "temperature",
   "max-iterations",
   "gadget",
-  "parameter-format",
   "builtins",
   "builtin-interaction",
   "gadget-start-prefix",
-  "gadget-end-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
 ]);
 var CUSTOM_CONFIG_KEYS = /* @__PURE__ */ new Set([
   ...COMPLETE_CONFIG_KEYS,
   ...AGENT_CONFIG_KEYS,
   "type",
-  "description",
-  "log-level",
-  "log-file",
-  "log-reset"
+  "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) {
@@ -1381,6 +1624,39 @@ function validateStringArray(value, key, section) {
   }
   return value;
 }
+function validateInherits(value, section) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      if (typeof value[i] !== "string") {
+        throw new ConfigError(`[${section}].inherits[${i}] must be a string`);
+      }
+    }
+    return value;
+  }
+  throw new ConfigError(`[${section}].inherits must be a string or array of strings`);
+}
+function validateLoggingConfig(raw, section) {
+  const result = {};
+  if ("log-level" in raw) {
+    const level = validateString(raw["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 raw) {
+    result["log-file"] = validateString(raw["log-file"], "log-file", section);
+  }
+  if ("log-reset" in raw) {
+    result["log-reset"] = validateBoolean(raw["log-reset"], "log-reset", section);
+  }
+  return result;
+}
 function validateBaseConfig(raw, section) {
   const result = {};
   if ("model" in raw) {
@@ -1395,6 +1671,9 @@ function validateBaseConfig(raw, section) {
       max: 2
     });
   }
+  if ("inherits" in raw) {
+    result.inherits = validateInherits(raw.inherits, section);
+  }
   return result;
 }
 function validateGlobalConfig(raw, section) {
@@ -1407,23 +1686,7 @@ function validateGlobalConfig(raw, section) {
       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);
-  }
-  if ("log-reset" in rawObj) {
-    result["log-reset"] = validateBoolean(rawObj["log-reset"], "log-reset", section);
-  }
-  return result;
+  return validateLoggingConfig(rawObj, section);
 }
 function validateCompleteConfig(raw, section) {
   if (typeof raw !== "object" || raw === null) {
@@ -1435,13 +1698,33 @@ function validateCompleteConfig(raw, section) {
       throw new ConfigError(`[${section}].${key} is not a valid option`);
     }
   }
-  const result = { ...validateBaseConfig(rawObj, section) };
+  const result = {
+    ...validateBaseConfig(rawObj, section),
+    ...validateLoggingConfig(rawObj, section)
+  };
   if ("max-tokens" in rawObj) {
     result["max-tokens"] = validateNumber(rawObj["max-tokens"], "max-tokens", section, {
       integer: true,
       min: 1
     });
   }
+  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) {
@@ -1454,7 +1737,10 @@ function validateAgentConfig(raw, section) {
       throw new ConfigError(`[${section}].${key} is not a valid option`);
     }
   }
-  const result = { ...validateBaseConfig(rawObj, section) };
+  const result = {
+    ...validateBaseConfig(rawObj, section),
+    ...validateLoggingConfig(rawObj, section)
+  };
   if ("max-iterations" in rawObj) {
     result["max-iterations"] = validateNumber(rawObj["max-iterations"], "max-iterations", section, {
       integer: true,
@@ -1464,15 +1750,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);
   }
@@ -1497,8 +1774,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`);
@@ -1533,15 +1840,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);
   }
@@ -1566,26 +1864,35 @@ 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,
       min: 1
     });
   }
-  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 ("quiet" in rawObj) {
+    result.quiet = validateBoolean(rawObj.quiet, "quiet", section);
   }
-  if ("log-file" in rawObj) {
-    result["log-file"] = validateString(rawObj["log-file"], "log-file", section);
+  Object.assign(result, validateLoggingConfig(rawObj, section));
+  return result;
+}
+function validatePromptsConfig(raw, section) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new ConfigError(`[${section}] must be a table`);
   }
-  if ("log-reset" in rawObj) {
-    result["log-reset"] = validateBoolean(rawObj["log-reset"], "log-reset", section);
+  const result = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value !== "string") {
+      throw new ConfigError(`[${section}].${key} must be a string`);
+    }
+    result[key] = value;
   }
   return result;
 }
@@ -1603,6 +1910,8 @@ function validateConfig(raw, configPath) {
         result.complete = validateCompleteConfig(value, key);
       } else if (key === "agent") {
         result.agent = validateAgentConfig(value, key);
+      } else if (key === "prompts") {
+        result.prompts = validatePromptsConfig(value, key);
       } else {
         result[key] = validateCustomConfig(value, key);
       }
@@ -1638,12 +1947,119 @@ function loadConfig() {
       configPath
     );
   }
-  return validateConfig(raw, configPath);
+  const validated = validateConfig(raw, configPath);
+  const inherited = resolveInheritance(validated, configPath);
+  return resolveTemplatesInConfig(inherited, configPath);
 }
 function getCustomCommandNames(config) {
-  const reserved = /* @__PURE__ */ new Set(["global", "complete", "agent"]);
+  const reserved = /* @__PURE__ */ new Set(["global", "complete", "agent", "prompts"]);
   return Object.keys(config).filter((key) => !reserved.has(key));
 }
+function resolveTemplatesInConfig(config, configPath) {
+  const prompts = config.prompts ?? {};
+  const hasPrompts = Object.keys(prompts).length > 0;
+  let hasTemplates = false;
+  for (const [sectionName, section] of Object.entries(config)) {
+    if (sectionName === "global" || sectionName === "prompts") continue;
+    if (!section || typeof section !== "object") continue;
+    const sectionObj = section;
+    if (typeof sectionObj.system === "string" && hasTemplateSyntax(sectionObj.system)) {
+      hasTemplates = true;
+      break;
+    }
+  }
+  for (const template of Object.values(prompts)) {
+    if (hasTemplateSyntax(template)) {
+      hasTemplates = true;
+      break;
+    }
+  }
+  if (!hasPrompts && !hasTemplates) {
+    return config;
+  }
+  try {
+    validatePrompts(prompts, configPath);
+  } catch (error) {
+    if (error instanceof TemplateError) {
+      throw new ConfigError(error.message, configPath);
+    }
+    throw error;
+  }
+  for (const [name, template] of Object.entries(prompts)) {
+    try {
+      validateEnvVars(template, name, configPath);
+    } catch (error) {
+      if (error instanceof TemplateError) {
+        throw new ConfigError(error.message, configPath);
+      }
+      throw error;
+    }
+  }
+  const eta = createTemplateEngine(prompts, configPath);
+  const result = { ...config };
+  for (const [sectionName, section] of Object.entries(config)) {
+    if (sectionName === "global" || sectionName === "prompts") continue;
+    if (!section || typeof section !== "object") continue;
+    const sectionObj = section;
+    if (typeof sectionObj.system === "string" && hasTemplateSyntax(sectionObj.system)) {
+      try {
+        validateEnvVars(sectionObj.system, void 0, configPath);
+      } catch (error) {
+        if (error instanceof TemplateError) {
+          throw new ConfigError(`[${sectionName}].system: ${error.message}`, configPath);
+        }
+        throw error;
+      }
+      try {
+        const resolved = resolveTemplate(eta, sectionObj.system, {}, configPath);
+        result[sectionName] = {
+          ...sectionObj,
+          system: resolved
+        };
+      } catch (error) {
+        if (error instanceof TemplateError) {
+          throw new ConfigError(`[${sectionName}].system: ${error.message}`, configPath);
+        }
+        throw error;
+      }
+    }
+  }
+  return result;
+}
+function resolveInheritance(config, configPath) {
+  const resolved = {};
+  const resolving = /* @__PURE__ */ new Set();
+  function resolveSection(name) {
+    if (name in resolved) {
+      return resolved[name];
+    }
+    if (resolving.has(name)) {
+      throw new ConfigError(`Circular inheritance detected: ${name}`, configPath);
+    }
+    const section = config[name];
+    if (section === void 0 || typeof section !== "object") {
+      throw new ConfigError(`Cannot inherit from unknown section: ${name}`, configPath);
+    }
+    resolving.add(name);
+    const sectionObj = section;
+    const inheritsRaw = sectionObj.inherits;
+    const inheritsList = inheritsRaw ? Array.isArray(inheritsRaw) ? inheritsRaw : [inheritsRaw] : [];
+    let merged = {};
+    for (const parent of inheritsList) {
+      const parentResolved = resolveSection(parent);
+      merged = { ...merged, ...parentResolved };
+    }
+    const { inherits: _inherits, ...ownValues } = sectionObj;
+    merged = { ...merged, ...ownValues };
+    resolving.delete(name);
+    resolved[name] = merged;
+    return merged;
+  }
+  for (const name of Object.keys(config)) {
+    resolveSection(name);
+  }
+  return resolved;
+}
 
 // src/cli/models-command.ts
 import chalk4 from "chalk";
@@ -1940,7 +2356,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;
 }