llmist 1.7.0 → 2.1.0

package/dist/cli.cjs

@@ -644,6 +644,44 @@ ${this.endPrefix}`
   }
 });
 
+// src/gadgets/exceptions.ts
+var BreakLoopException, HumanInputException, TimeoutException, AbortError;
+var init_exceptions = __esm({
+  "src/gadgets/exceptions.ts"() {
+    "use strict";
+    BreakLoopException = class extends Error {
+      constructor(message) {
+        super(message ?? "Agent loop terminated by gadget");
+        this.name = "BreakLoopException";
+      }
+    };
+    HumanInputException = class extends Error {
+      question;
+      constructor(question) {
+        super(`Human input required: ${question}`);
+        this.name = "HumanInputException";
+        this.question = question;
+      }
+    };
+    TimeoutException = class extends Error {
+      timeoutMs;
+      gadgetName;
+      constructor(gadgetName, timeoutMs) {
+        super(`Gadget '${gadgetName}' execution exceeded timeout of ${timeoutMs}ms`);
+        this.name = "TimeoutException";
+        this.gadgetName = gadgetName;
+        this.timeoutMs = timeoutMs;
+      }
+    };
+    AbortError = class extends Error {
+      constructor(message) {
+        super(message || "Gadget execution was aborted");
+        this.name = "AbortError";
+      }
+    };
+  }
+});
+
 // src/logging/logger.ts
 function parseLogLevel(value) {
   if (!value) {
@@ -916,6 +954,7 @@ var init_gadget = __esm({
   "src/gadgets/gadget.ts"() {
     "use strict";
     init_constants();
+    init_exceptions();
     init_schema_to_json();
     init_schema_validator();
     BaseGadget = class {
@@ -945,6 +984,136 @@ var init_gadget = __esm({
        * while maintaining runtime compatibility.
        */
       examples;
+      /**
+       * Throws an AbortError if the execution has been aborted.
+       *
+       * Call this at key checkpoints in long-running gadgets to allow early exit
+       * when the gadget has been cancelled (e.g., due to timeout). This enables
+       * resource cleanup and prevents unnecessary work after cancellation.
+       *
+       * @param ctx - The execution context containing the abort signal
+       * @throws AbortError if ctx.signal.aborted is true
+       *
+       * @example
+       * ```typescript
+       * class DataProcessor extends Gadget({
+       *   description: 'Processes data in multiple steps',
+       *   schema: z.object({ items: z.array(z.string()) }),
+       * }) {
+       *   async execute(params: this['params'], ctx?: ExecutionContext): Promise<string> {
+       *     const results: string[] = [];
+       *
+       *     for (const item of params.items) {
+       *       // Check before each expensive operation
+       *       this.throwIfAborted(ctx);
+       *
+       *       results.push(await this.processItem(item));
+       *     }
+       *
+       *     return results.join(', ');
+       *   }
+       * }
+       * ```
+       */
+      throwIfAborted(ctx) {
+        if (ctx?.signal?.aborted) {
+          throw new AbortError();
+        }
+      }
+      /**
+       * Register a cleanup function to run when execution is aborted (timeout or cancellation).
+       * The cleanup function is called immediately if the signal is already aborted.
+       * Errors thrown by the cleanup function are silently ignored.
+       *
+       * Use this to clean up resources like browser instances, database connections,
+       * or child processes when the gadget is cancelled due to timeout.
+       *
+       * @param ctx - The execution context containing the abort signal
+       * @param cleanup - Function to run on abort (can be sync or async)
+       *
+       * @example
+       * ```typescript
+       * class BrowserGadget extends Gadget({
+       *   description: 'Fetches web page content',
+       *   schema: z.object({ url: z.string() }),
+       * }) {
+       *   async execute(params: this['params'], ctx?: ExecutionContext): Promise<string> {
+       *     const browser = await chromium.launch();
+       *     this.onAbort(ctx, () => browser.close());
+       *
+       *     const page = await browser.newPage();
+       *     this.onAbort(ctx, () => page.close());
+       *
+       *     await page.goto(params.url);
+       *     const content = await page.content();
+       *
+       *     await browser.close();
+       *     return content;
+       *   }
+       * }
+       * ```
+       */
+      onAbort(ctx, cleanup) {
+        if (!ctx?.signal) return;
+        const safeCleanup = () => {
+          try {
+            const result = cleanup();
+            if (result && typeof result === "object" && "catch" in result) {
+              result.catch(() => {
+              });
+            }
+          } catch {
+          }
+        };
+        if (ctx.signal.aborted) {
+          safeCleanup();
+          return;
+        }
+        ctx.signal.addEventListener("abort", safeCleanup, { once: true });
+      }
+      /**
+       * Create an AbortController linked to the execution context's signal.
+       * When the parent signal aborts, the returned controller also aborts with the same reason.
+       *
+       * Useful for passing abort signals to child operations like fetch() while still
+       * being able to abort them independently if needed.
+       *
+       * @param ctx - The execution context containing the parent abort signal
+       * @returns A new AbortController linked to the parent signal
+       *
+       * @example
+       * ```typescript
+       * class FetchGadget extends Gadget({
+       *   description: 'Fetches data from URL',
+       *   schema: z.object({ url: z.string() }),
+       * }) {
+       *   async execute(params: this['params'], ctx?: ExecutionContext): Promise<string> {
+       *     const controller = this.createLinkedAbortController(ctx);
+       *
+       *     // fetch() will automatically abort when parent times out
+       *     const response = await fetch(params.url, { signal: controller.signal });
+       *     return response.text();
+       *   }
+       * }
+       * ```
+       */
+      createLinkedAbortController(ctx) {
+        const controller = new AbortController();
+        if (ctx?.signal) {
+          if (ctx.signal.aborted) {
+            controller.abort(ctx.signal.reason);
+          } else {
+            ctx.signal.addEventListener(
+              "abort",
+              () => {
+                controller.abort(ctx.signal.reason);
+              },
+              { once: true }
+            );
+          }
+        }
+        return controller;
+      }
       /**
        * Auto-generated instruction text for the LLM.
        * Combines name, description, and parameter schema into a formatted instruction.
@@ -1012,8 +1181,8 @@ function createGadget(config) {
     parameterSchema = config.schema;
     timeoutMs = config.timeoutMs;
     examples = config.examples;
-    execute(params) {
-      return config.execute(params);
+    execute(params, ctx) {
+      return config.execute(params, ctx);
     }
   }
   return new DynamicGadget();
@@ -2319,6 +2488,162 @@ var init_block_params = __esm({
   }
 });
 
+// src/gadgets/cost-reporting-client.ts
+var CostReportingLLMistWrapper;
+var init_cost_reporting_client = __esm({
+  "src/gadgets/cost-reporting-client.ts"() {
+    "use strict";
+    init_model_shortcuts();
+    CostReportingLLMistWrapper = class {
+      constructor(client, reportCost) {
+        this.client = client;
+        this.reportCost = reportCost;
+      }
+      /**
+       * Access to model registry for cost estimation.
+       */
+      get modelRegistry() {
+        return this.client.modelRegistry;
+      }
+      /**
+       * Quick completion with automatic cost reporting.
+       *
+       * Streams internally to track token usage, then reports the calculated cost.
+       *
+       * @param prompt - User prompt
+       * @param options - Optional configuration (model, temperature, etc.)
+       * @returns Complete text response
+       */
+      async complete(prompt, options) {
+        const model = resolveModel(options?.model ?? "haiku");
+        let result = "";
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let cachedInputTokens = 0;
+        let cacheCreationInputTokens = 0;
+        const messages = [
+          ...options?.systemPrompt ? [{ role: "system", content: options.systemPrompt }] : [],
+          { role: "user", content: prompt }
+        ];
+        for await (const chunk of this.client.stream({
+          model,
+          messages,
+          temperature: options?.temperature,
+          maxTokens: options?.maxTokens
+        })) {
+          result += chunk.text ?? "";
+          if (chunk.usage) {
+            inputTokens = chunk.usage.inputTokens;
+            outputTokens = chunk.usage.outputTokens;
+            cachedInputTokens = chunk.usage.cachedInputTokens ?? 0;
+            cacheCreationInputTokens = chunk.usage.cacheCreationInputTokens ?? 0;
+          }
+        }
+        this.reportCostFromUsage(model, inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens);
+        return result;
+      }
+      /**
+       * Quick streaming with automatic cost reporting when stream completes.
+       *
+       * Yields text chunks as they arrive, then reports cost in finally block.
+       *
+       * @param prompt - User prompt
+       * @param options - Optional configuration (model, temperature, etc.)
+       * @returns Async generator yielding text chunks
+       */
+      async *streamText(prompt, options) {
+        const model = resolveModel(options?.model ?? "haiku");
+        let inputTokens = 0;
+        let outputTokens = 0;
+        let cachedInputTokens = 0;
+        let cacheCreationInputTokens = 0;
+        const messages = [
+          ...options?.systemPrompt ? [{ role: "system", content: options.systemPrompt }] : [],
+          { role: "user", content: prompt }
+        ];
+        try {
+          for await (const chunk of this.client.stream({
+            model,
+            messages,
+            temperature: options?.temperature,
+            maxTokens: options?.maxTokens
+          })) {
+            if (chunk.text) {
+              yield chunk.text;
+            }
+            if (chunk.usage) {
+              inputTokens = chunk.usage.inputTokens;
+              outputTokens = chunk.usage.outputTokens;
+              cachedInputTokens = chunk.usage.cachedInputTokens ?? 0;
+              cacheCreationInputTokens = chunk.usage.cacheCreationInputTokens ?? 0;
+            }
+          }
+        } finally {
+          this.reportCostFromUsage(model, inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens);
+        }
+      }
+      /**
+       * Low-level stream access with automatic cost reporting.
+       *
+       * Returns a wrapped stream that reports costs when iteration completes.
+       *
+       * @param options - Full LLM generation options
+       * @returns Wrapped LLM stream that auto-reports costs
+       */
+      stream(options) {
+        return this.createCostReportingStream(options);
+      }
+      /**
+       * Creates a wrapped stream that tracks usage and reports costs on completion.
+       */
+      createCostReportingStream(options) {
+        const innerStream = this.client.stream(options);
+        const reportCostFromUsage = this.reportCostFromUsage.bind(this);
+        const model = options.model;
+        async function* costReportingWrapper() {
+          let inputTokens = 0;
+          let outputTokens = 0;
+          let cachedInputTokens = 0;
+          let cacheCreationInputTokens = 0;
+          try {
+            for await (const chunk of innerStream) {
+              if (chunk.usage) {
+                inputTokens = chunk.usage.inputTokens;
+                outputTokens = chunk.usage.outputTokens;
+                cachedInputTokens = chunk.usage.cachedInputTokens ?? 0;
+                cacheCreationInputTokens = chunk.usage.cacheCreationInputTokens ?? 0;
+              }
+              yield chunk;
+            }
+          } finally {
+            if (inputTokens > 0 || outputTokens > 0) {
+              reportCostFromUsage(model, inputTokens, outputTokens, cachedInputTokens, cacheCreationInputTokens);
+            }
+          }
+        }
+        return costReportingWrapper();
+      }
+      /**
+       * Calculates and reports cost from token usage.
+       */
+      reportCostFromUsage(model, inputTokens, outputTokens, cachedInputTokens = 0, cacheCreationInputTokens = 0) {
+        if (inputTokens === 0 && outputTokens === 0) return;
+        const modelName = model.includes(":") ? model.split(":")[1] : model;
+        const estimate = this.client.modelRegistry.estimateCost(
+          modelName,
+          inputTokens,
+          outputTokens,
+          cachedInputTokens,
+          cacheCreationInputTokens
+        );
+        if (estimate && estimate.totalCost > 0) {
+          this.reportCost(estimate.totalCost);
+        }
+      }
+    };
+  }
+});
+
 // src/gadgets/error-formatter.ts
 var GadgetErrorFormatter;
 var init_error_formatter = __esm({
@@ -2402,38 +2727,6 @@ var init_error_formatter = __esm({
   }
 });
 
-// src/gadgets/exceptions.ts
-var BreakLoopException, HumanInputException, TimeoutException;
-var init_exceptions = __esm({
-  "src/gadgets/exceptions.ts"() {
-    "use strict";
-    BreakLoopException = class extends Error {
-      constructor(message) {
-        super(message ?? "Agent loop terminated by gadget");
-        this.name = "BreakLoopException";
-      }
-    };
-    HumanInputException = class extends Error {
-      question;
-      constructor(question) {
-        super(`Human input required: ${question}`);
-        this.name = "HumanInputException";
-        this.question = question;
-      }
-    };
-    TimeoutException = class extends Error {
-      timeoutMs;
-      gadgetName;
-      constructor(gadgetName, timeoutMs) {
-        super(`Gadget '${gadgetName}' execution exceeded timeout of ${timeoutMs}ms`);
-        this.name = "TimeoutException";
-        this.gadgetName = gadgetName;
-        this.timeoutMs = timeoutMs;
-      }
-    };
-  }
-});
-
 // src/gadgets/parser.ts
 function stripMarkdownFences(content) {
   let cleaned = content.trim();
@@ -2619,14 +2912,16 @@ var init_executor = __esm({
     init_constants();
     init_logger();
     init_block_params();
+    init_cost_reporting_client();
     init_error_formatter();
     init_exceptions();
     init_parser();
     GadgetExecutor = class {
-      constructor(registry, onHumanInputRequired, logger, defaultGadgetTimeoutMs, errorFormatterOptions) {
+      constructor(registry, onHumanInputRequired, logger, defaultGadgetTimeoutMs, errorFormatterOptions, client) {
         this.registry = registry;
         this.onHumanInputRequired = onHumanInputRequired;
         this.defaultGadgetTimeoutMs = defaultGadgetTimeoutMs;
+        this.client = client;
         this.logger = logger ?? createLogger({ name: "llmist:executor" });
         this.errorFormatter = new GadgetErrorFormatter(errorFormatterOptions);
         this.argPrefix = errorFormatterOptions?.argPrefix ?? GADGET_ARG_PREFIX;
@@ -2636,14 +2931,27 @@ var init_executor = __esm({
       argPrefix;
       /**
        * Creates a promise that rejects with a TimeoutException after the specified timeout.
+       * Aborts the provided AbortController before rejecting, allowing gadgets to clean up.
        */
-      createTimeoutPromise(gadgetName, timeoutMs) {
+      createTimeoutPromise(gadgetName, timeoutMs, abortController) {
         return new Promise((_, reject) => {
           setTimeout(() => {
-            reject(new TimeoutException(gadgetName, timeoutMs));
+            const timeoutError = new TimeoutException(gadgetName, timeoutMs);
+            abortController.abort(timeoutError.message);
+            reject(timeoutError);
           }, timeoutMs);
         });
       }
+      /**
+       * Normalizes gadget execute result to consistent format.
+       * Handles both string returns (backwards compat) and object returns with cost.
+       */
+      normalizeExecuteResult(raw) {
+        if (typeof raw === "string") {
+          return { result: raw, cost: 0 };
+        }
+        return { result: raw.result, cost: raw.cost ?? 0 };
+      }
       // Execute a gadget call asynchronously
       async execute(call) {
         const startTime = Date.now();
@@ -2738,30 +3046,53 @@ var init_executor = __esm({
             validatedParameters = schemaAwareParameters;
           }
           const timeoutMs = gadget.timeoutMs ?? this.defaultGadgetTimeoutMs;
-          let result;
+          const abortController = new AbortController();
+          let callbackCost = 0;
+          const reportCost = (amount) => {
+            if (amount > 0) {
+              callbackCost += amount;
+              this.logger.debug("Gadget reported cost via callback", {
+                gadgetName: call.gadgetName,
+                amount,
+                totalCallbackCost: callbackCost
+              });
+            }
+          };
+          const ctx = {
+            reportCost,
+            llmist: this.client ? new CostReportingLLMistWrapper(this.client, reportCost) : void 0,
+            signal: abortController.signal
+          };
+          let rawResult;
           if (timeoutMs && timeoutMs > 0) {
             this.logger.debug("Executing gadget with timeout", {
               gadgetName: call.gadgetName,
               timeoutMs
             });
-            result = await Promise.race([
-              Promise.resolve(gadget.execute(validatedParameters)),
-              this.createTimeoutPromise(call.gadgetName, timeoutMs)
+            rawResult = await Promise.race([
+              Promise.resolve(gadget.execute(validatedParameters, ctx)),
+              this.createTimeoutPromise(call.gadgetName, timeoutMs, abortController)
             ]);
           } else {
-            result = await Promise.resolve(gadget.execute(validatedParameters));
+            rawResult = await Promise.resolve(gadget.execute(validatedParameters, ctx));
           }
+          const { result, cost: returnCost } = this.normalizeExecuteResult(rawResult);
+          const totalCost = callbackCost + returnCost;
           const executionTimeMs = Date.now() - startTime;
           this.logger.info("Gadget executed successfully", {
             gadgetName: call.gadgetName,
             invocationId: call.invocationId,
-            executionTimeMs
+            executionTimeMs,
+            cost: totalCost > 0 ? totalCost : void 0,
+            callbackCost: callbackCost > 0 ? callbackCost : void 0,
+            returnCost: returnCost > 0 ? returnCost : void 0
           });
           this.logger.debug("Gadget result", {
             gadgetName: call.gadgetName,
             invocationId: call.invocationId,
             parameters: validatedParameters,
             result,
+            cost: totalCost,
             executionTimeMs
           });
           return {
@@ -2769,7 +3100,8 @@ var init_executor = __esm({
             invocationId: call.invocationId,
             parameters: validatedParameters,
             result,
-            executionTimeMs
+            executionTimeMs,
+            cost: totalCost
           };
         } catch (error) {
           if (error instanceof BreakLoopException) {
@@ -2800,6 +3132,19 @@ var init_executor = __esm({
               executionTimeMs: Date.now() - startTime
             };
           }
+          if (error instanceof AbortError) {
+            this.logger.info("Gadget execution was aborted", {
+              gadgetName: call.gadgetName,
+              executionTimeMs: Date.now() - startTime
+            });
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: validatedParameters,
+              error: error.message,
+              executionTimeMs: Date.now() - startTime
+            };
+          }
           if (error instanceof HumanInputException) {
             this.logger.info("Gadget requested human input", {
               gadgetName: call.gadgetName,
@@ -2926,7 +3271,8 @@ var init_stream_processor = __esm({
           options.onHumanInputRequired,
           this.logger.getSubLogger({ name: "executor" }),
           options.defaultGadgetTimeoutMs,
-          { argPrefix: options.gadgetArgPrefix }
+          { argPrefix: options.gadgetArgPrefix },
+          options.client
         );
       }
       /**
@@ -3193,6 +3539,7 @@ var init_stream_processor = __esm({
               error: result.error,
               executionTimeMs: result.executionTimeMs,
               breaksLoop: result.breaksLoop,
+              cost: result.cost,
               logger: this.logger
             };
             await this.hooks.observers.onGadgetExecutionComplete(context);
@@ -3549,6 +3896,17 @@ var init_agent = __esm({
                 llmOptions = { ...llmOptions, ...action.modifiedOptions };
               }
             }
+            await this.safeObserve(async () => {
+              if (this.hooks.observers?.onLLMCallReady) {
+                const context = {
+                  iteration: currentIteration,
+                  maxIterations: this.maxIterations,
+                  options: llmOptions,
+                  logger: this.logger
+                };
+                await this.hooks.observers.onLLMCallReady(context);
+              }
+            });
             this.logger.info("Calling LLM", { model: this.model });
             this.logger.silly("LLM request details", {
               model: llmOptions.model,
@@ -3569,7 +3927,8 @@ var init_agent = __esm({
               onHumanInputRequired: this.onHumanInputRequired,
               stopOnGadgetError: this.stopOnGadgetError,
               shouldContinueAfterError: this.shouldContinueAfterError,
-              defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs
+              defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
+              client: this.client
             });
             const result = await processor.process(stream2);
             for (const output of result.outputs) {
@@ -6634,7 +6993,6 @@ var OPTION_FLAGS = {
   logFile: "--log-file <path>",
   logReset: "--log-reset",
   logLlmRequests: "--log-llm-requests [dir]",
-  logLlmResponses: "--log-llm-responses [dir]",
   noBuiltins: "--no-builtins",
   noBuiltinInteraction: "--no-builtin-interaction",
   quiet: "-q, --quiet",
@@ -6653,8 +7011,7 @@ var OPTION_DESCRIPTIONS = {
   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/",
+  logLlmRequests: "Save LLM requests/responses to session directories. Optional dir, defaults to ~/.llmist/logs/requests/",
   noBuiltins: "Disable built-in gadgets (AskUser, TellUser).",
   noBuiltinInteraction: "Disable interactive gadgets (AskUser) while keeping TellUser.",
   quiet: "Suppress all output except content (text and TellUser messages).",
@@ -6671,7 +7028,7 @@ var import_commander2 = require("commander");
 // package.json
 var package_default = {
   name: "llmist",
-  version: "1.6.2",
+  version: "2.0.0",
   description: "Universal TypeScript LLM client with streaming-first agent framework. Works with any model - no structured outputs or native tool calling required. Implements its own flexible grammar for function calling.",
   type: "module",
   main: "dist/index.cjs",
@@ -6844,6 +7201,14 @@ ${addedLines}`;
 }
 
 // src/cli/approval/context-providers.ts
+function formatGadgetSummary(gadgetName, params) {
+  const paramEntries = Object.entries(params);
+  if (paramEntries.length === 0) {
+    return `${gadgetName}()`;
+  }
+  const paramStr = paramEntries.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
+  return `${gadgetName}(${paramStr})`;
+}
 var WriteFileContextProvider = class {
   gadgetName = "WriteFile";
   async getContext(params) {
@@ -6852,14 +7217,14 @@ var WriteFileContextProvider = class {
     const resolvedPath = (0, import_node_path2.resolve)(process.cwd(), filePath);
     if (!(0, import_node_fs2.existsSync)(resolvedPath)) {
       return {
-        summary: `Create new file: ${filePath}`,
+        summary: formatGadgetSummary(this.gadgetName, params),
         details: formatNewFileDiff(filePath, newContent)
       };
     }
     const oldContent = (0, import_node_fs2.readFileSync)(resolvedPath, "utf-8");
     const diff = (0, import_diff.createPatch)(filePath, oldContent, newContent, "original", "modified");
     return {
-      summary: `Modify: ${filePath}`,
+      summary: formatGadgetSummary(this.gadgetName, params),
       details: diff
     };
   }
@@ -6873,37 +7238,27 @@ var EditFileContextProvider = class {
       const newContent = String(params.content);
       if (!(0, import_node_fs2.existsSync)(resolvedPath)) {
         return {
-          summary: `Create new file: ${filePath}`,
+          summary: formatGadgetSummary(this.gadgetName, params),
           details: formatNewFileDiff(filePath, newContent)
         };
       }
       const oldContent = (0, import_node_fs2.readFileSync)(resolvedPath, "utf-8");
       const diff = (0, import_diff.createPatch)(filePath, oldContent, newContent, "original", "modified");
       return {
-        summary: `Modify: ${filePath}`,
+        summary: formatGadgetSummary(this.gadgetName, params),
         details: diff
       };
     }
     if ("commands" in params) {
       const commands = String(params.commands);
       return {
-        summary: `Edit: ${filePath}`,
+        summary: formatGadgetSummary(this.gadgetName, params),
         details: `Commands:
 ${commands}`
       };
     }
     return {
-      summary: `Edit: ${filePath}`
-    };
-  }
-};
-var RunCommandContextProvider = class {
-  gadgetName = "RunCommand";
-  async getContext(params) {
-    const command = String(params.command ?? "");
-    const cwd = params.cwd ? ` (in ${params.cwd})` : "";
-    return {
-      summary: `Execute: ${command}${cwd}`
+      summary: formatGadgetSummary(this.gadgetName, params)
     };
   }
 };
@@ -6912,27 +7267,15 @@ var DefaultContextProvider = class {
     this.gadgetName = gadgetName;
   }
   async getContext(params) {
-    const paramEntries = Object.entries(params);
-    if (paramEntries.length === 0) {
-      return {
-        summary: `${this.gadgetName}()`
-      };
-    }
-    const formatValue = (value) => {
-      const MAX_LEN = 50;
-      const str = JSON.stringify(value);
-      return str.length > MAX_LEN ? `${str.slice(0, MAX_LEN - 3)}...` : str;
-    };
-    const paramStr = paramEntries.map(([k, v]) => `${k}=${formatValue(v)}`).join(", ");
     return {
-      summary: `${this.gadgetName}(${paramStr})`
+      summary: formatGadgetSummary(this.gadgetName, params)
     };
   }
 };
 var builtinContextProviders = [
   new WriteFileContextProvider(),
-  new EditFileContextProvider(),
-  new RunCommandContextProvider()
+  new EditFileContextProvider()
+  // Note: RunCommand uses DefaultContextProvider - no custom details needed
 ];
 
 // src/cli/approval/manager.ts
@@ -6943,11 +7286,13 @@ var ApprovalManager = class {
    * @param config - Approval configuration with per-gadget modes
    * @param env - CLI environment for I/O operations
    * @param progress - Optional progress indicator to pause during prompts
+   * @param keyboard - Optional keyboard coordinator to disable ESC listener during prompts
    */
-  constructor(config, env, progress) {
+  constructor(config, env, progress, keyboard) {
     this.config = config;
     this.env = env;
     this.progress = progress;
+    this.keyboard = keyboard;
     for (const provider of builtinContextProviders) {
       this.registerProvider(provider);
     }
@@ -7016,26 +7361,34 @@ var ApprovalManager = class {
     const provider = this.providers.get(gadgetName.toLowerCase()) ?? new DefaultContextProvider(gadgetName);
     const context = await provider.getContext(params);
     this.progress?.pause();
-    this.env.stderr.write(`
+    if (this.keyboard?.cleanupEsc) {
+      this.keyboard.cleanupEsc();
+      this.keyboard.cleanupEsc = null;
+    }
+    try {
+      this.env.stderr.write(`
 ${import_chalk2.default.yellow("\u{1F512} Approval required:")} ${context.summary}
 `);
-    if (context.details) {
-      this.env.stderr.write(`
+      if (context.details) {
+        this.env.stderr.write(`
 ${renderColoredDiff(context.details)}
 `);
-    }
-    const response = await this.prompt("   \u23CE approve, or type to reject: ");
-    const isApproved = response === "" || response.toLowerCase() === "y";
-    if (isApproved) {
-      this.env.stderr.write(`   ${import_chalk2.default.green("\u2713 Approved")}
+      }
+      const response = await this.prompt("   \u23CE approve, or type to reject: ");
+      const isApproved = response === "" || response.toLowerCase() === "y";
+      if (isApproved) {
+        this.env.stderr.write(`   ${import_chalk2.default.green("\u2713 Approved")}
 
 `);
-      return { approved: true };
-    }
-    this.env.stderr.write(`   ${import_chalk2.default.red("\u2717 Denied")}
+        return { approved: true };
+      }
+      this.env.stderr.write(`   ${import_chalk2.default.red("\u2717 Denied")}
 
 `);
-    return { approved: false, reason: response || "Rejected by user" };
+      return { approved: false, reason: response || "Rejected by user" };
+    } finally {
+      this.keyboard?.restore();
+    }
   }
   /**
    * Prompts for user input.
@@ -7534,49 +7887,77 @@ error: ${message}`;
 var import_zod8 = require("zod");
 var runCommand = createGadget({
   name: "RunCommand",
-  description: "Execute a shell command and return its output. Returns both stdout and stderr combined with the exit status.",
+  description: "Execute a command with arguments and return its output. Uses argv array to bypass shell - arguments are passed directly without interpretation. Returns stdout/stderr combined with exit status.",
   schema: import_zod8.z.object({
-    command: import_zod8.z.string().describe("The shell command to execute"),
+    argv: import_zod8.z.array(import_zod8.z.string()).describe("Command and arguments as array (e.g., ['git', 'commit', '-m', 'message'])"),
     cwd: import_zod8.z.string().optional().describe("Working directory for the command (default: current directory)"),
     timeout: import_zod8.z.number().default(3e4).describe("Timeout in milliseconds (default: 30000)")
   }),
   examples: [
     {
-      params: { command: "ls -la", timeout: 3e4 },
+      params: { argv: ["ls", "-la"], timeout: 3e4 },
       output: "status=0\n\ntotal 24\ndrwxr-xr-x  5 user  staff   160 Nov 27 10:00 .\ndrwxr-xr-x  3 user  staff    96 Nov 27 09:00 ..\n-rw-r--r--  1 user  staff  1024 Nov 27 10:00 package.json",
       comment: "List directory contents with details"
     },
     {
-      params: { command: "echo 'Hello World'", timeout: 3e4 },
+      params: { argv: ["echo", "Hello World"], timeout: 3e4 },
       output: "status=0\n\nHello World",
-      comment: "Simple echo command"
+      comment: "Echo without shell - argument passed directly"
     },
     {
-      params: { command: "cat nonexistent.txt", timeout: 3e4 },
+      params: { argv: ["cat", "nonexistent.txt"], timeout: 3e4 },
       output: "status=1\n\ncat: nonexistent.txt: No such file or directory",
       comment: "Command that fails returns non-zero status"
     },
     {
-      params: { command: "pwd", cwd: "/tmp", timeout: 3e4 },
+      params: { argv: ["pwd"], cwd: "/tmp", timeout: 3e4 },
       output: "status=0\n\n/tmp",
       comment: "Execute command in a specific directory"
+    },
+    {
+      params: { argv: ["gh", "pr", "review", "123", "--comment", "--body", "Review with `backticks` and 'quotes'"], timeout: 3e4 },
+      output: "status=0\n\n(no output)",
+      comment: "Complex arguments with special characters - no escaping needed"
+    },
+    {
+      params: {
+        argv: [
+          "gh",
+          "pr",
+          "review",
+          "123",
+          "--approve",
+          "--body",
+          "## Review Summary\n\n**Looks good!**\n\n- Clean code\n- Tests pass"
+        ],
+        timeout: 3e4
+      },
+      output: "status=0\n\nApproving pull request #123",
+      comment: "Multiline body: --body flag and content must be SEPARATE array elements"
     }
   ],
-  execute: async ({ command, cwd, timeout }) => {
+  execute: async ({ argv, cwd, timeout }) => {
     const workingDir = cwd ?? process.cwd();
+    if (argv.length === 0) {
+      return "status=1\n\nerror: argv array cannot be empty";
+    }
+    let timeoutId;
     try {
-      const proc = Bun.spawn(["sh", "-c", command], {
+      const proc = Bun.spawn(argv, {
         cwd: workingDir,
         stdout: "pipe",
         stderr: "pipe"
       });
       const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
+        timeoutId = setTimeout(() => {
           proc.kill();
           reject(new Error(`Command timed out after ${timeout}ms`));
         }, timeout);
       });
       const exitCode = await Promise.race([proc.exited, timeoutPromise]);
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
       const stdout = await new Response(proc.stdout).text();
       const stderr = await new Response(proc.stderr).text();
       const output = [stdout, stderr].filter(Boolean).join("\n").trim();
@@ -7584,6 +7965,9 @@ var runCommand = createGadget({
 
 ${output || "(no output)"}`;
     } catch (error) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
       const message = error instanceof Error ? error.message : String(error);
       return `status=1
 
@@ -7756,6 +8140,30 @@ async function writeLogFile(dir, filename, content) {
   await (0, import_promises2.mkdir)(dir, { recursive: true });
   await (0, import_promises2.writeFile)((0, import_node_path7.join)(dir, filename), content, "utf-8");
 }
+function formatSessionTimestamp(date = /* @__PURE__ */ new Date()) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  const year = date.getFullYear();
+  const month = pad(date.getMonth() + 1);
+  const day = pad(date.getDate());
+  const hours = pad(date.getHours());
+  const minutes = pad(date.getMinutes());
+  const seconds = pad(date.getSeconds());
+  return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`;
+}
+async function createSessionDir(baseDir) {
+  const timestamp = formatSessionTimestamp();
+  const sessionDir = (0, import_node_path7.join)(baseDir, timestamp);
+  try {
+    await (0, import_promises2.mkdir)(sessionDir, { recursive: true });
+    return sessionDir;
+  } catch (error) {
+    console.warn(`[llmist] Failed to create log session directory: ${sessionDir}`, error);
+    return void 0;
+  }
+}
+function formatCallNumber(n) {
+  return n.toString().padStart(4, "0");
+}
 
 // src/cli/utils.ts
 var import_chalk4 = __toESM(require("chalk"), 1);
@@ -7919,7 +8327,7 @@ function formatBytes(bytes) {
   }
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
-function formatGadgetSummary(result) {
+function formatGadgetSummary2(result) {
   const gadgetLabel = import_chalk3.default.magenta.bold(result.gadgetName);
   const timeLabel = import_chalk3.default.dim(`${Math.round(result.executionTimeMs)}ms`);
   const paramsStr = formatParametersInline(result.parameters);
@@ -8004,12 +8412,21 @@ function isInteractive(stream2) {
 }
 var ESC_KEY = 27;
 var ESC_TIMEOUT_MS = 50;
-function createEscKeyListener(stdin, onEsc) {
+var CTRL_C = 3;
+function createEscKeyListener(stdin, onEsc, onCtrlC) {
   if (!stdin.isTTY || typeof stdin.setRawMode !== "function") {
     return null;
   }
   let escTimeout = null;
   const handleData = (data) => {
+    if (data[0] === CTRL_C && onCtrlC) {
+      if (escTimeout) {
+        clearTimeout(escTimeout);
+        escTimeout = null;
+      }
+      onCtrlC();
+      return;
+    }
     if (data[0] === ESC_KEY) {
       if (data.length === 1) {
         escTimeout = setTimeout(() => {
@@ -8457,7 +8874,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"]);
+  ).option(OPTION_FLAGS.quiet, OPTION_DESCRIPTIONS.quiet, defaults?.quiet).option(OPTION_FLAGS.logLlmRequests, OPTION_DESCRIPTIONS.logLlmRequests, defaults?.["log-llm-requests"]);
 }
 function addAgentOptions(cmd, defaults) {
   const gadgetAccumulator = (value, previous = []) => [
@@ -8481,7 +8898,7 @@ function addAgentOptions(cmd, defaults) {
     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"]).option(OPTION_FLAGS.docker, OPTION_DESCRIPTIONS.docker).option(OPTION_FLAGS.dockerRo, OPTION_DESCRIPTIONS.dockerRo).option(OPTION_FLAGS.noDocker, OPTION_DESCRIPTIONS.noDocker).option(OPTION_FLAGS.dockerDev, OPTION_DESCRIPTIONS.dockerDev);
+  ).option(OPTION_FLAGS.quiet, OPTION_DESCRIPTIONS.quiet, defaults?.quiet).option(OPTION_FLAGS.logLlmRequests, OPTION_DESCRIPTIONS.logLlmRequests, defaults?.["log-llm-requests"]).option(OPTION_FLAGS.docker, OPTION_DESCRIPTIONS.docker).option(OPTION_FLAGS.dockerRo, OPTION_DESCRIPTIONS.dockerRo).option(OPTION_FLAGS.noDocker, OPTION_DESCRIPTIONS.noDocker).option(OPTION_FLAGS.dockerDev, OPTION_DESCRIPTIONS.dockerDev);
 }
 function configToCompleteOptions(config) {
   const result = {};
@@ -8491,7 +8908,6 @@ function configToCompleteOptions(config) {
   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) {
@@ -8515,7 +8931,6 @@ function configToAgentOptions(config) {
     result.gadgetApproval = config["gadget-approval"];
   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"];
   if (config.docker !== void 0) result.docker = config.docker;
   if (config["docker-cwd-permission"] !== void 0)
     result.dockerCwdPermission = config["docker-cwd-permission"];
@@ -8533,7 +8948,8 @@ var DOCKER_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "env-vars",
   "image-name",
   "dev-mode",
-  "dev-source"
+  "dev-source",
+  "docker-args"
 ]);
 var DEFAULT_IMAGE_NAME = "llmist-sandbox";
 var DEFAULT_CWD_PERMISSION = "rw";
@@ -8648,7 +9064,6 @@ var COMPLETE_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "log-file",
   "log-reset",
   "log-llm-requests",
-  "log-llm-responses",
   "type",
   // Allowed for inheritance compatibility, ignored for built-in commands
   "docker",
@@ -8681,7 +9096,6 @@ var AGENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "log-file",
   "log-reset",
   "log-llm-requests",
-  "log-llm-responses",
   "type",
   // Allowed for inheritance compatibility, ignored for built-in commands
   "docker",
@@ -8869,13 +9283,6 @@ function validateCompleteConfig(raw, section) {
       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) {
@@ -8954,13 +9361,6 @@ function validateAgentConfig(raw, section) {
       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) {
@@ -9402,6 +9802,9 @@ function validateDockerConfig(raw, section) {
   if ("dev-source" in rawObj) {
     result["dev-source"] = validateString2(rawObj["dev-source"], "dev-source", section);
   }
+  if ("docker-args" in rawObj) {
+    result["docker-args"] = validateStringArray2(rawObj["docker-args"], "docker-args", section);
+  }
   return result;
 }
 
@@ -9413,6 +9816,8 @@ FROM oven/bun:1-debian
 
 # Install essential tools
 RUN apt-get update && apt-get install -y --no-install-recommends \\
+    # ed for EditFile gadget (line-oriented editor)
+    ed \\
     # ripgrep for fast file searching
     ripgrep \\
     # git for version control operations
@@ -9445,6 +9850,7 @@ FROM oven/bun:1-debian
 
 # Install essential tools (same as production)
 RUN apt-get update && apt-get install -y --no-install-recommends \\
+    ed \\
     ripgrep \\
     git \\
     curl \\
@@ -9679,6 +10085,9 @@ function buildDockerRunArgs(ctx, imageName, devMode) {
       }
     }
   }
+  if (ctx.config["docker-args"]) {
+    args.push(...ctx.config["docker-args"]);
+  }
   args.push(imageName);
   args.push(...ctx.forwardArgs);
   return args;
@@ -9845,6 +10254,8 @@ async function executeAgent(promptArg, options, env) {
       env.stderr.write(import_chalk5.default.yellow(`
 [Cancelled] ${progress.formatStats()}
 `));
+    } else {
+      handleQuit();
     }
   };
   const keyboard = {
@@ -9852,7 +10263,7 @@ async function executeAgent(promptArg, options, env) {
     cleanupSigint: null,
     restore: () => {
       if (stdinIsInteractive && stdinStream.isTTY && !wasCancelled) {
-        keyboard.cleanupEsc = createEscKeyListener(stdinStream, handleCancel);
+        keyboard.cleanupEsc = createEscKeyListener(stdinStream, handleCancel, handleCancel);
       }
     }
   };
@@ -9877,7 +10288,7 @@ async function executeAgent(promptArg, options, env) {
     process.exit(130);
   };
   if (stdinIsInteractive && stdinStream.isTTY) {
-    keyboard.cleanupEsc = createEscKeyListener(stdinStream, handleCancel);
+    keyboard.cleanupEsc = createEscKeyListener(stdinStream, handleCancel, handleCancel);
   }
   keyboard.cleanupSigint = createSigintListener(
     handleCancel,
@@ -9903,11 +10314,11 @@ async function executeAgent(promptArg, options, env) {
     gadgetApprovals,
     defaultMode: "allowed"
   };
-  const approvalManager = new ApprovalManager(approvalConfig, env, progress);
+  const approvalManager = new ApprovalManager(approvalConfig, env, progress, keyboard);
   let usage;
   let iterations = 0;
-  const llmRequestsDir = resolveLogDir(options.logLlmRequests, "requests");
-  const llmResponsesDir = resolveLogDir(options.logLlmResponses, "responses");
+  const llmLogsBaseDir = resolveLogDir(options.logLlmRequests, "requests");
+  let llmSessionDir;
   let llmCallCounter = 0;
   const countMessagesTokens = async (model, messages) => {
     try {
@@ -9939,10 +10350,19 @@ async function executeAgent(promptArg, options, env) {
         );
         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);
+      },
+      // onLLMCallReady: Log the exact request being sent to the LLM
+      // This fires AFTER controller modifications (e.g., trailing messages)
+      onLLMCallReady: async (context) => {
+        if (llmLogsBaseDir) {
+          if (!llmSessionDir) {
+            llmSessionDir = await createSessionDir(llmLogsBaseDir);
+          }
+          if (llmSessionDir) {
+            const filename = `${formatCallNumber(llmCallCounter)}.request`;
+            const content = formatLlmRequest(context.options.messages);
+            await writeLogFile(llmSessionDir, filename, content);
+          }
         }
       },
       // onStreamChunk: Real-time updates as LLM generates tokens
@@ -10007,9 +10427,9 @@ async function executeAgent(promptArg, options, env) {
 `);
           }
         }
-        if (llmResponsesDir) {
-          const filename = `${Date.now()}_call_${llmCallCounter}.response.txt`;
-          await writeLogFile(llmResponsesDir, filename, context.rawResponse);
+        if (llmSessionDir) {
+          const filename = `${formatCallNumber(llmCallCounter)}.response`;
+          await writeLogFile(llmSessionDir, filename, context.rawResponse);
         }
       }
     },
@@ -10106,6 +10526,13 @@ Denied: ${result.reason ?? "by user"}`
     parameterMapping: (text) => ({ message: text, done: false, type: "info" }),
     resultMapping: (text) => `\u2139\uFE0F  ${text}`
   });
+  builder.withTrailingMessage(
+    (ctx) => [
+      `[Iteration ${ctx.iteration + 1}/${ctx.maxIterations}]`,
+      "Think carefully: what gadget invocations can you make in parallel right now?",
+      "Maximize efficiency by batching independent operations in a single response."
+    ].join(" ")
+  );
   const agent = builder.ask(prompt);
   let textBuffer = "";
   const flushTextBuffer = () => {
@@ -10131,7 +10558,7 @@ Denied: ${result.reason ?? "by user"}`
           }
         } else {
           const tokenCount = await countGadgetOutputTokens(event.result.result);
-          env.stderr.write(`${formatGadgetSummary({ ...event.result, tokenCount })}
+          env.stderr.write(`${formatGadgetSummary2({ ...event.result, tokenCount })}
 `);
         }
       }
@@ -10143,7 +10570,10 @@ Denied: ${result.reason ?? "by user"}`
   } finally {
     isStreaming = false;
     keyboard.cleanupEsc?.();
-    keyboard.cleanupSigint?.();
+    if (keyboard.cleanupSigint) {
+      keyboard.cleanupSigint();
+      process.once("SIGINT", () => process.exit(130));
+    }
   }
   flushTextBuffer();
   progress.complete();
@@ -10191,13 +10621,15 @@ async function executeComplete(promptArg, options, env) {
   }
   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 llmLogsBaseDir = resolveLogDir(options.logLlmRequests, "requests");
+  let llmSessionDir;
+  if (llmLogsBaseDir) {
+    llmSessionDir = await createSessionDir(llmLogsBaseDir);
+    if (llmSessionDir) {
+      const filename = "0001.request";
+      const content = formatLlmRequest(messages);
+      await writeLogFile(llmSessionDir, filename, content);
+    }
   }
   const stream2 = client.stream({
     model,
@@ -10236,9 +10668,9 @@ async function executeComplete(promptArg, options, env) {
   progress.endCall(usage);
   progress.complete();
   printer.ensureNewline();
-  if (llmResponsesDir) {
-    const filename = `${timestamp}_complete.response.txt`;
-    await writeLogFile(llmResponsesDir, filename, accumulatedResponse);
+  if (llmSessionDir) {
+    const filename = "0001.response";
+    await writeLogFile(llmSessionDir, filename, accumulatedResponse);
   }
   if (stderrTTY && !options.quiet) {
     const summary = renderSummary({ finishReason, usage, cost: progress.getTotalCost() });
@@ -10473,9 +10905,11 @@ ${issues}`);
   env.stderr.write(import_chalk7.default.dim("\nExecuting...\n"));
   const startTime = Date.now();
   let result;
+  let cost;
   try {
+    let rawResult;
     if (gadget.timeoutMs && gadget.timeoutMs > 0) {
-      result = await Promise.race([
+      rawResult = await Promise.race([
         Promise.resolve(gadget.execute(params)),
         new Promise(
           (_, reject) => setTimeout(
@@ -10485,15 +10919,18 @@ ${issues}`);
         )
       ]);
     } else {
-      result = await Promise.resolve(gadget.execute(params));
+      rawResult = await Promise.resolve(gadget.execute(params));
     }
+    result = typeof rawResult === "string" ? rawResult : rawResult.result;
+    cost = typeof rawResult === "object" ? rawResult.cost : void 0;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Execution failed: ${message}`);
   }
   const elapsed = Date.now() - startTime;
+  const costInfo = cost !== void 0 && cost > 0 ? ` (Cost: $${cost.toFixed(6)})` : "";
   env.stderr.write(import_chalk7.default.green(`
-\u2713 Completed in ${elapsed}ms
+\u2713 Completed in ${elapsed}ms${costInfo}
 
 `));
   formatOutput(result, options, env.stdout);