llmist 1.1.0 → 1.3.0

package/dist/cli.cjs

@@ -1113,6 +1113,417 @@ var init_output_viewer = __esm({
   }
 });
 
+// src/agent/compaction/config.ts
+function resolveCompactionConfig(config = {}) {
+  const trigger = config.triggerThresholdPercent ?? DEFAULT_COMPACTION_CONFIG.triggerThresholdPercent;
+  const target = config.targetPercent ?? DEFAULT_COMPACTION_CONFIG.targetPercent;
+  if (target >= trigger) {
+    console.warn(
+      `[llmist/compaction] targetPercent (${target}) should be less than triggerThresholdPercent (${trigger}) to be effective.`
+    );
+  }
+  const strategy = config.strategy ?? DEFAULT_COMPACTION_CONFIG.strategy;
+  const strategyName = typeof strategy === "object" && "name" in strategy ? strategy.name : strategy;
+  return {
+    enabled: config.enabled ?? DEFAULT_COMPACTION_CONFIG.enabled,
+    strategy: strategyName,
+    triggerThresholdPercent: trigger,
+    targetPercent: target,
+    preserveRecentTurns: config.preserveRecentTurns ?? DEFAULT_COMPACTION_CONFIG.preserveRecentTurns,
+    summarizationModel: config.summarizationModel,
+    summarizationPrompt: config.summarizationPrompt ?? DEFAULT_SUMMARIZATION_PROMPT,
+    onCompaction: config.onCompaction
+  };
+}
+var DEFAULT_COMPACTION_CONFIG, DEFAULT_SUMMARIZATION_PROMPT;
+var init_config = __esm({
+  "src/agent/compaction/config.ts"() {
+    "use strict";
+    DEFAULT_COMPACTION_CONFIG = {
+      enabled: true,
+      strategy: "hybrid",
+      triggerThresholdPercent: 80,
+      targetPercent: 50,
+      preserveRecentTurns: 5
+    };
+    DEFAULT_SUMMARIZATION_PROMPT = `Summarize this conversation history concisely, preserving:
+1. Key decisions made and their rationale
+2. Important facts and data discovered
+3. Errors encountered and how they were resolved
+4. Current task context and goals
+
+Format as a brief narrative paragraph, not bullet points.
+Previous conversation:`;
+  }
+});
+
+// src/agent/compaction/strategy.ts
+function groupIntoTurns(messages) {
+  const turns = [];
+  let currentTurn = [];
+  for (const msg of messages) {
+    if (msg.role === "user" && currentTurn.length > 0) {
+      turns.push({
+        messages: currentTurn,
+        tokenEstimate: estimateTurnTokens(currentTurn)
+      });
+      currentTurn = [msg];
+    } else {
+      currentTurn.push(msg);
+    }
+  }
+  if (currentTurn.length > 0) {
+    turns.push({
+      messages: currentTurn,
+      tokenEstimate: estimateTurnTokens(currentTurn)
+    });
+  }
+  return turns;
+}
+function estimateTurnTokens(messages) {
+  return Math.ceil(messages.reduce((sum, msg) => sum + (msg.content?.length ?? 0), 0) / 4);
+}
+function flattenTurns(turns) {
+  return turns.flatMap((turn) => turn.messages);
+}
+var init_strategy = __esm({
+  "src/agent/compaction/strategy.ts"() {
+    "use strict";
+  }
+});
+
+// src/agent/compaction/strategies/sliding-window.ts
+var TRUNCATION_MARKER_TEMPLATE, SlidingWindowStrategy;
+var init_sliding_window = __esm({
+  "src/agent/compaction/strategies/sliding-window.ts"() {
+    "use strict";
+    init_strategy();
+    TRUNCATION_MARKER_TEMPLATE = "[Previous conversation truncated. Removed {count} turn(s) to fit context window.]";
+    SlidingWindowStrategy = class {
+      name = "sliding-window";
+      async compact(messages, config, context) {
+        const turns = groupIntoTurns(messages);
+        const preserveCount = Math.min(config.preserveRecentTurns, turns.length);
+        if (turns.length <= preserveCount) {
+          return {
+            messages,
+            strategyName: this.name,
+            metadata: {
+              originalCount: messages.length,
+              compactedCount: messages.length,
+              tokensBefore: context.currentTokens,
+              tokensAfter: context.currentTokens
+            }
+          };
+        }
+        const turnsToKeep = turns.slice(-preserveCount);
+        const turnsRemoved = turns.length - preserveCount;
+        const truncationMarker = {
+          role: "user",
+          content: TRUNCATION_MARKER_TEMPLATE.replace("{count}", turnsRemoved.toString())
+        };
+        const compactedMessages = [truncationMarker, ...flattenTurns(turnsToKeep)];
+        const tokensAfter = Math.ceil(
+          compactedMessages.reduce((sum, msg) => sum + (msg.content?.length ?? 0), 0) / 4
+        );
+        return {
+          messages: compactedMessages,
+          strategyName: this.name,
+          metadata: {
+            originalCount: messages.length,
+            compactedCount: compactedMessages.length,
+            tokensBefore: context.currentTokens,
+            tokensAfter
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/agent/compaction/strategies/summarization.ts
+var SummarizationStrategy;
+var init_summarization = __esm({
+  "src/agent/compaction/strategies/summarization.ts"() {
+    "use strict";
+    init_strategy();
+    SummarizationStrategy = class {
+      name = "summarization";
+      async compact(messages, config, context) {
+        const turns = groupIntoTurns(messages);
+        const preserveCount = Math.min(config.preserveRecentTurns, turns.length);
+        if (turns.length <= preserveCount) {
+          return {
+            messages,
+            strategyName: this.name,
+            metadata: {
+              originalCount: messages.length,
+              compactedCount: messages.length,
+              tokensBefore: context.currentTokens,
+              tokensAfter: context.currentTokens
+            }
+          };
+        }
+        const turnsToSummarize = turns.slice(0, -preserveCount);
+        const turnsToKeep = turns.slice(-preserveCount);
+        const conversationToSummarize = this.formatTurnsForSummary(flattenTurns(turnsToSummarize));
+        const summary = await this.generateSummary(conversationToSummarize, config, context);
+        const summaryMessage = {
+          role: "user",
+          content: `[Previous conversation summary]
+${summary}
+[End of summary - conversation continues below]`
+        };
+        const compactedMessages = [summaryMessage, ...flattenTurns(turnsToKeep)];
+        const tokensAfter = Math.ceil(
+          compactedMessages.reduce((sum, msg) => sum + (msg.content?.length ?? 0), 0) / 4
+        );
+        return {
+          messages: compactedMessages,
+          summary,
+          strategyName: this.name,
+          metadata: {
+            originalCount: messages.length,
+            compactedCount: compactedMessages.length,
+            tokensBefore: context.currentTokens,
+            tokensAfter
+          }
+        };
+      }
+      /**
+       * Formats messages into a readable conversation format for summarization.
+       */
+      formatTurnsForSummary(messages) {
+        return messages.map((msg) => {
+          const role = msg.role.charAt(0).toUpperCase() + msg.role.slice(1);
+          return `${role}: ${msg.content}`;
+        }).join("\n\n");
+      }
+      /**
+       * Generates a summary using the configured LLM.
+       */
+      async generateSummary(conversation, config, context) {
+        const model = config.summarizationModel ?? context.model;
+        const prompt = `${config.summarizationPrompt}
+
+${conversation}`;
+        const response = await context.client.complete(prompt, {
+          model,
+          temperature: 0.3
+          // Low temperature for factual summarization
+        });
+        return response.trim();
+      }
+    };
+  }
+});
+
+// src/agent/compaction/strategies/hybrid.ts
+var MIN_TURNS_FOR_SUMMARIZATION, HybridStrategy;
+var init_hybrid = __esm({
+  "src/agent/compaction/strategies/hybrid.ts"() {
+    "use strict";
+    init_strategy();
+    init_sliding_window();
+    init_summarization();
+    MIN_TURNS_FOR_SUMMARIZATION = 3;
+    HybridStrategy = class {
+      name = "hybrid";
+      slidingWindow = new SlidingWindowStrategy();
+      summarization = new SummarizationStrategy();
+      async compact(messages, config, context) {
+        const turns = groupIntoTurns(messages);
+        const preserveCount = Math.min(config.preserveRecentTurns, turns.length);
+        if (turns.length <= preserveCount) {
+          return {
+            messages,
+            strategyName: this.name,
+            metadata: {
+              originalCount: messages.length,
+              compactedCount: messages.length,
+              tokensBefore: context.currentTokens,
+              tokensAfter: context.currentTokens
+            }
+          };
+        }
+        const turnsToSummarize = turns.length - preserveCount;
+        if (turnsToSummarize < MIN_TURNS_FOR_SUMMARIZATION) {
+          return this.slidingWindow.compact(messages, config, context);
+        }
+        return this.summarization.compact(messages, config, context);
+      }
+    };
+  }
+});
+
+// src/agent/compaction/strategies/index.ts
+var init_strategies = __esm({
+  "src/agent/compaction/strategies/index.ts"() {
+    "use strict";
+    init_sliding_window();
+    init_summarization();
+    init_hybrid();
+  }
+});
+
+// src/agent/compaction/manager.ts
+function createStrategy(name) {
+  switch (name) {
+    case "sliding-window":
+      return new SlidingWindowStrategy();
+    case "summarization":
+      return new SummarizationStrategy();
+    case "hybrid":
+      return new HybridStrategy();
+    default:
+      throw new Error(`Unknown compaction strategy: ${name}`);
+  }
+}
+var CompactionManager;
+var init_manager = __esm({
+  "src/agent/compaction/manager.ts"() {
+    "use strict";
+    init_config();
+    init_strategies();
+    CompactionManager = class {
+      client;
+      model;
+      config;
+      strategy;
+      modelLimits;
+      // Statistics
+      totalCompactions = 0;
+      totalTokensSaved = 0;
+      lastTokenCount = 0;
+      constructor(client, model, config = {}) {
+        this.client = client;
+        this.model = model;
+        this.config = resolveCompactionConfig(config);
+        if (typeof config.strategy === "object" && "compact" in config.strategy) {
+          this.strategy = config.strategy;
+        } else {
+          this.strategy = createStrategy(this.config.strategy);
+        }
+      }
+      /**
+       * Check if compaction is needed and perform it if so.
+       *
+       * @param conversation - The conversation manager to compact
+       * @param iteration - Current agent iteration (for event metadata)
+       * @returns CompactionEvent if compaction was performed, null otherwise
+       */
+      async checkAndCompact(conversation, iteration) {
+        if (!this.config.enabled) {
+          return null;
+        }
+        if (!this.modelLimits) {
+          this.modelLimits = this.client.modelRegistry.getModelLimits(this.model);
+          if (!this.modelLimits) {
+            return null;
+          }
+        }
+        if (!this.client.countTokens) {
+          return null;
+        }
+        const messages = conversation.getMessages();
+        const currentTokens = await this.client.countTokens(this.model, messages);
+        this.lastTokenCount = currentTokens;
+        const usagePercent = currentTokens / this.modelLimits.contextWindow * 100;
+        if (usagePercent < this.config.triggerThresholdPercent) {
+          return null;
+        }
+        const historyMessages = conversation.getHistoryMessages();
+        const baseMessages = conversation.getBaseMessages();
+        const historyTokens = await this.client.countTokens(this.model, historyMessages);
+        const baseTokens = await this.client.countTokens(this.model, baseMessages);
+        return this.compact(conversation, iteration, {
+          historyMessages,
+          baseMessages,
+          historyTokens,
+          baseTokens,
+          currentTokens: historyTokens + baseTokens
+        });
+      }
+      /**
+       * Force compaction regardless of threshold.
+       *
+       * @param conversation - The conversation manager to compact
+       * @param iteration - Current agent iteration (for event metadata). Use -1 for manual compaction.
+       * @param precomputed - Optional pre-computed token counts (passed from checkAndCompact for efficiency)
+       * @returns CompactionEvent with compaction details
+       */
+      async compact(conversation, iteration, precomputed) {
+        if (!this.modelLimits) {
+          this.modelLimits = this.client.modelRegistry.getModelLimits(this.model);
+          if (!this.modelLimits) {
+            return null;
+          }
+        }
+        const historyMessages = precomputed?.historyMessages ?? conversation.getHistoryMessages();
+        const baseMessages = precomputed?.baseMessages ?? conversation.getBaseMessages();
+        const historyTokens = precomputed?.historyTokens ?? await this.client.countTokens(this.model, historyMessages);
+        const baseTokens = precomputed?.baseTokens ?? await this.client.countTokens(this.model, baseMessages);
+        const currentTokens = precomputed?.currentTokens ?? historyTokens + baseTokens;
+        const targetTotalTokens = Math.floor(
+          this.modelLimits.contextWindow * this.config.targetPercent / 100
+        );
+        const targetHistoryTokens = Math.max(0, targetTotalTokens - baseTokens);
+        const result = await this.strategy.compact(historyMessages, this.config, {
+          currentTokens: historyTokens,
+          targetTokens: targetHistoryTokens,
+          modelLimits: this.modelLimits,
+          client: this.client,
+          model: this.config.summarizationModel ?? this.model
+        });
+        conversation.replaceHistory(result.messages);
+        const afterTokens = await this.client.countTokens(this.model, conversation.getMessages());
+        const tokensSaved = currentTokens - afterTokens;
+        this.totalCompactions++;
+        this.totalTokensSaved += tokensSaved;
+        this.lastTokenCount = afterTokens;
+        const event = {
+          strategy: result.strategyName,
+          tokensBefore: currentTokens,
+          tokensAfter: afterTokens,
+          messagesBefore: historyMessages.length + baseMessages.length,
+          messagesAfter: result.messages.length + baseMessages.length,
+          summary: result.summary,
+          iteration
+        };
+        if (this.config.onCompaction) {
+          try {
+            this.config.onCompaction(event);
+          } catch (err) {
+            console.warn("[llmist/compaction] onCompaction callback error:", err);
+          }
+        }
+        return event;
+      }
+      /**
+       * Get compaction statistics.
+       */
+      getStats() {
+        const contextWindow = this.modelLimits?.contextWindow ?? 0;
+        return {
+          totalCompactions: this.totalCompactions,
+          totalTokensSaved: this.totalTokensSaved,
+          currentUsage: {
+            tokens: this.lastTokenCount,
+            percent: contextWindow > 0 ? this.lastTokenCount / contextWindow * 100 : 0
+          },
+          contextWindow
+        };
+      }
+      /**
+       * Check if compaction is enabled.
+       */
+      isEnabled() {
+        return this.config.enabled;
+      }
+    };
+  }
+});
+
 // src/agent/gadget-output-store.ts
 var import_node_crypto, GadgetOutputStore;
 var init_gadget_output_store = __esm({
@@ -1215,10 +1626,16 @@ var init_conversation_manager = __esm({
       baseMessages;
       initialMessages;
       historyBuilder;
+      startPrefix;
+      endPrefix;
+      argPrefix;
       constructor(baseMessages, initialMessages, options = {}) {
         this.baseMessages = baseMessages;
         this.initialMessages = initialMessages;
         this.historyBuilder = new LLMMessageBuilder();
+        this.startPrefix = options.startPrefix;
+        this.endPrefix = options.endPrefix;
+        this.argPrefix = options.argPrefix;
         if (options.startPrefix && options.endPrefix) {
           this.historyBuilder.withPrefixes(options.startPrefix, options.endPrefix, options.argPrefix);
         }
@@ -1235,6 +1652,25 @@ var init_conversation_manager = __esm({
       getMessages() {
         return [...this.baseMessages, ...this.initialMessages, ...this.historyBuilder.build()];
       }
+      getHistoryMessages() {
+        return this.historyBuilder.build();
+      }
+      getBaseMessages() {
+        return [...this.baseMessages, ...this.initialMessages];
+      }
+      replaceHistory(newHistory) {
+        this.historyBuilder = new LLMMessageBuilder();
+        if (this.startPrefix && this.endPrefix) {
+          this.historyBuilder.withPrefixes(this.startPrefix, this.endPrefix, this.argPrefix);
+        }
+        for (const msg of newHistory) {
+          if (msg.role === "user") {
+            this.historyBuilder.addUser(msg.content);
+          } else if (msg.role === "assistant") {
+            this.historyBuilder.addAssistant(msg.content);
+          }
+        }
+      }
     };
   }
 });
@@ -1447,334 +1883,241 @@ var init_hook_validators = __esm({
   }
 });
 
-// src/gadgets/error-formatter.ts
-var GadgetErrorFormatter;
-var init_error_formatter = __esm({
-  "src/gadgets/error-formatter.ts"() {
+// src/gadgets/schema-introspector.ts
+function getDef(schema) {
+  return schema._def;
+}
+function getTypeName(schema) {
+  const def = getDef(schema);
+  return def?.type ?? def?.typeName;
+}
+function getShape(schema) {
+  const def = getDef(schema);
+  if (typeof def?.shape === "function") {
+    return def.shape();
+  }
+  return def?.shape;
+}
+var SchemaIntrospector;
+var init_schema_introspector = __esm({
+  "src/gadgets/schema-introspector.ts"() {
     "use strict";
-    init_constants();
-    GadgetErrorFormatter = class {
-      argPrefix;
-      startPrefix;
-      endPrefix;
-      constructor(options = {}) {
-        this.argPrefix = options.argPrefix ?? GADGET_ARG_PREFIX;
-        this.startPrefix = options.startPrefix ?? GADGET_START_PREFIX;
-        this.endPrefix = options.endPrefix ?? GADGET_END_PREFIX;
+    SchemaIntrospector = class {
+      schema;
+      cache = /* @__PURE__ */ new Map();
+      constructor(schema) {
+        this.schema = schema;
       }
       /**
-       * Format a Zod validation error with full gadget instructions.
+       * Get the expected type at a JSON pointer path.
        *
-       * @param gadgetName - Name of the gadget that was called
-       * @param zodError - The Zod validation error
-       * @param gadget - The gadget instance (for generating instructions)
-       * @returns Formatted error message with usage instructions
+       * @param pointer - JSON pointer path without leading / (e.g., "config/timeout", "items/0")
+       * @returns Type hint for coercion decision
        */
-      formatValidationError(gadgetName, zodError, gadget) {
-        const parts = [];
-        parts.push(`Error: Invalid parameters for '${gadgetName}':`);
-        for (const issue of zodError.issues) {
-          const path2 = issue.path.join(".") || "root";
-          parts.push(`  - ${path2}: ${issue.message}`);
+      getTypeAtPath(pointer) {
+        const cached = this.cache.get(pointer);
+        if (cached !== void 0) {
+          return cached;
         }
-        parts.push("");
-        parts.push("Gadget Usage:");
-        parts.push(gadget.getInstruction(this.argPrefix));
-        return parts.join("\n");
+        const result = this.resolveTypeAtPath(pointer);
+        this.cache.set(pointer, result);
+        return result;
       }
       /**
-       * Format a parse error with block format reference.
-       *
-       * @param gadgetName - Name of the gadget that was called
-       * @param parseError - The parse error message
-       * @param gadget - The gadget instance if found (for generating instructions)
-       * @returns Formatted error message with format reference
+       * Internal method to resolve type at path without caching.
        */
-      formatParseError(gadgetName, parseError, gadget) {
-        const parts = [];
-        parts.push(`Error: Failed to parse parameters for '${gadgetName}':`);
-        parts.push(`  ${parseError}`);
-        if (gadget) {
-          parts.push("");
-          parts.push("Gadget Usage:");
-          parts.push(gadget.getInstruction(this.argPrefix));
+      resolveTypeAtPath(pointer) {
+        if (!pointer) {
+          return this.getBaseType(this.schema);
+        }
+        const segments = pointer.split("/");
+        let current = this.schema;
+        for (const segment of segments) {
+          current = this.unwrapSchema(current);
+          const typeName = getTypeName(current);
+          if (typeName === "object" || typeName === "ZodObject") {
+            const shape = getShape(current);
+            if (!shape || !(segment in shape)) {
+              return "unknown";
+            }
+            current = shape[segment];
+          } else if (typeName === "array" || typeName === "ZodArray") {
+            if (!/^\d+$/.test(segment)) {
+              return "unknown";
+            }
+            const def = getDef(current);
+            const elementType = def?.element ?? def?.type;
+            if (!elementType) {
+              return "unknown";
+            }
+            current = elementType;
+          } else if (typeName === "tuple" || typeName === "ZodTuple") {
+            if (!/^\d+$/.test(segment)) {
+              return "unknown";
+            }
+            const index = parseInt(segment, 10);
+            const def = getDef(current);
+            const items = def?.items;
+            if (!items || index >= items.length) {
+              return "unknown";
+            }
+            current = items[index];
+          } else if (typeName === "record" || typeName === "ZodRecord") {
+            const def = getDef(current);
+            const valueType = def?.valueType;
+            if (!valueType) {
+              return "unknown";
+            }
+            current = valueType;
+          } else {
+            return "unknown";
+          }
         }
-        parts.push("");
-        parts.push("Block Format Reference:");
-        parts.push(`  ${this.startPrefix}${gadgetName}`);
-        parts.push(`  ${this.argPrefix}parameterName`);
-        parts.push("  parameter value here");
-        parts.push(`  ${this.endPrefix}`);
-        return parts.join("\n");
+        return this.getBaseType(current);
       }
       /**
-       * Format a registry error (gadget not found) with available gadgets list.
-       *
-       * @param gadgetName - Name of the gadget that was not found
-       * @param availableGadgets - List of available gadget names
-       * @returns Formatted error message with available gadgets
+       * Unwrap schema modifiers (optional, default, nullable, branded, etc.)
+       * to get to the underlying type.
        */
-      formatRegistryError(gadgetName, availableGadgets) {
-        const parts = [];
-        parts.push(`Error: Gadget '${gadgetName}' not found.`);
-        if (availableGadgets.length > 0) {
-          parts.push("");
-          parts.push(`Available gadgets: ${availableGadgets.join(", ")}`);
-        } else {
-          parts.push("");
-          parts.push("No gadgets are currently registered.");
+      unwrapSchema(schema) {
+        let current = schema;
+        let iterations = 0;
+        const maxIterations = 20;
+        while (iterations < maxIterations) {
+          const typeName = getTypeName(current);
+          const wrapperTypes = [
+            "optional",
+            "nullable",
+            "default",
+            "catch",
+            "branded",
+            "readonly",
+            "pipeline",
+            "ZodOptional",
+            "ZodNullable",
+            "ZodDefault",
+            "ZodCatch",
+            "ZodBranded",
+            "ZodReadonly",
+            "ZodPipeline"
+          ];
+          if (typeName && wrapperTypes.includes(typeName)) {
+            const def = getDef(current);
+            const inner = def?.innerType ?? def?.in ?? def?.type;
+            if (!inner || inner === current) break;
+            current = inner;
+            iterations++;
+            continue;
+          }
+          break;
         }
-        return parts.join("\n");
-      }
-    };
-  }
-});
-
-// 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;
+        return current;
       }
-    };
-    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/executor.ts
-var GadgetExecutor;
-var init_executor = __esm({
-  "src/gadgets/executor.ts"() {
-    "use strict";
-    init_logger();
-    init_error_formatter();
-    init_exceptions();
-    GadgetExecutor = class {
-      constructor(registry, onHumanInputRequired, logger, defaultGadgetTimeoutMs, errorFormatterOptions) {
-        this.registry = registry;
-        this.onHumanInputRequired = onHumanInputRequired;
-        this.defaultGadgetTimeoutMs = defaultGadgetTimeoutMs;
-        this.logger = logger ?? createLogger({ name: "llmist:executor" });
-        this.errorFormatter = new GadgetErrorFormatter(errorFormatterOptions);
-      }
-      logger;
-      errorFormatter;
-      /**
-       * Creates a promise that rejects with a TimeoutException after the specified timeout.
-       */
-      createTimeoutPromise(gadgetName, timeoutMs) {
-        return new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(new TimeoutException(gadgetName, timeoutMs));
-          }, timeoutMs);
-        });
-      }
-      // Execute a gadget call asynchronously
-      async execute(call) {
-        const startTime = Date.now();
-        this.logger.debug("Executing gadget", {
-          gadgetName: call.gadgetName,
-          invocationId: call.invocationId,
-          parameters: call.parameters
-        });
-        const rawParameters = call.parameters ?? {};
-        let validatedParameters = rawParameters;
-        try {
-          const gadget = this.registry.get(call.gadgetName);
-          if (!gadget) {
-            this.logger.error("Gadget not found", { gadgetName: call.gadgetName });
-            const availableGadgets = this.registry.getNames();
-            return {
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: call.parameters ?? {},
-              error: this.errorFormatter.formatRegistryError(call.gadgetName, availableGadgets),
-              executionTimeMs: Date.now() - startTime
-            };
-          }
-          if (call.parseError || !call.parameters) {
-            this.logger.error("Gadget parameter parse error", {
-              gadgetName: call.gadgetName,
-              parseError: call.parseError,
-              rawParameters: call.parametersRaw
-            });
-            const parseErrorMessage = call.parseError ?? "Failed to parse parameters";
-            return {
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: {},
-              error: this.errorFormatter.formatParseError(call.gadgetName, parseErrorMessage, gadget),
-              executionTimeMs: Date.now() - startTime
-            };
-          }
-          if (gadget.parameterSchema) {
-            const validationResult = gadget.parameterSchema.safeParse(rawParameters);
-            if (!validationResult.success) {
-              const validationError = this.errorFormatter.formatValidationError(
-                call.gadgetName,
-                validationResult.error,
-                gadget
-              );
-              this.logger.error("Gadget parameter validation failed", {
-                gadgetName: call.gadgetName,
-                issueCount: validationResult.error.issues.length
-              });
-              return {
-                gadgetName: call.gadgetName,
-                invocationId: call.invocationId,
-                parameters: rawParameters,
-                error: validationError,
-                executionTimeMs: Date.now() - startTime
-              };
-            }
-            validatedParameters = validationResult.data;
-          }
-          const timeoutMs = gadget.timeoutMs ?? this.defaultGadgetTimeoutMs;
-          let result;
-          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)
-            ]);
-          } else {
-            result = await Promise.resolve(gadget.execute(validatedParameters));
-          }
-          const executionTimeMs = Date.now() - startTime;
-          this.logger.info("Gadget executed successfully", {
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            executionTimeMs
-          });
-          this.logger.debug("Gadget result", {
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            parameters: validatedParameters,
-            result,
-            executionTimeMs
-          });
-          return {
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            parameters: validatedParameters,
-            result,
-            executionTimeMs
-          };
-        } catch (error) {
-          if (error instanceof BreakLoopException) {
-            this.logger.info("Gadget requested loop termination", {
-              gadgetName: call.gadgetName,
-              message: error.message
-            });
-            return {
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: validatedParameters,
-              result: error.message,
-              breaksLoop: true,
-              executionTimeMs: Date.now() - startTime
-            };
-          }
-          if (error instanceof TimeoutException) {
-            this.logger.error("Gadget execution timed out", {
-              gadgetName: call.gadgetName,
-              timeoutMs: error.timeoutMs,
-              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,
-              question: error.question
-            });
-            if (this.onHumanInputRequired) {
-              try {
-                const answer = await this.onHumanInputRequired(error.question);
-                this.logger.debug("Human input received", {
-                  gadgetName: call.gadgetName,
-                  answerLength: answer.length
-                });
-                return {
-                  gadgetName: call.gadgetName,
-                  invocationId: call.invocationId,
-                  parameters: validatedParameters,
-                  result: answer,
-                  executionTimeMs: Date.now() - startTime
-                };
-              } catch (inputError) {
-                this.logger.error("Human input callback error", {
-                  gadgetName: call.gadgetName,
-                  error: inputError instanceof Error ? inputError.message : String(inputError)
-                });
-                return {
-                  gadgetName: call.gadgetName,
-                  invocationId: call.invocationId,
-                  parameters: validatedParameters,
-                  error: inputError instanceof Error ? inputError.message : String(inputError),
-                  executionTimeMs: Date.now() - startTime
-                };
-              }
-            }
-            this.logger.warn("Human input required but no callback provided", {
-              gadgetName: call.gadgetName
-            });
-            return {
-              gadgetName: call.gadgetName,
-              invocationId: call.invocationId,
-              parameters: validatedParameters,
-              error: "Human input required but not available (stdin is not interactive)",
-              executionTimeMs: Date.now() - startTime
-            };
-          }
-          const executionTimeMs = Date.now() - startTime;
-          this.logger.error("Gadget execution failed", {
-            gadgetName: call.gadgetName,
-            error: error instanceof Error ? error.message : String(error),
-            executionTimeMs
-          });
-          return {
-            gadgetName: call.gadgetName,
-            invocationId: call.invocationId,
-            parameters: validatedParameters,
-            error: error instanceof Error ? error.message : String(error),
-            executionTimeMs
-          };
-        }
-      }
-      // Execute multiple gadget calls in parallel
-      async executeAll(calls) {
-        return Promise.all(calls.map((call) => this.execute(call)));
+      /**
+       * Get the primitive type hint from an unwrapped schema.
+       */
+      getBaseType(schema) {
+        const unwrapped = this.unwrapSchema(schema);
+        const typeName = getTypeName(unwrapped);
+        switch (typeName) {
+          // Primitive types
+          case "string":
+          case "ZodString":
+            return "string";
+          case "number":
+          case "ZodNumber":
+          case "bigint":
+          case "ZodBigInt":
+            return "number";
+          case "boolean":
+          case "ZodBoolean":
+            return "boolean";
+          // Literal types - check the literal value type
+          case "literal":
+          case "ZodLiteral": {
+            const def = getDef(unwrapped);
+            const values = def?.values;
+            const value = values?.[0] ?? def?.value;
+            if (typeof value === "string") return "string";
+            if (typeof value === "number" || typeof value === "bigint")
+              return "number";
+            if (typeof value === "boolean") return "boolean";
+            return "unknown";
+          }
+          // Enum - always string keys
+          case "enum":
+          case "ZodEnum":
+          case "nativeEnum":
+          case "ZodNativeEnum":
+            return "string";
+          // Union - return 'unknown' to let auto-coercion decide
+          // Since multiple types are valid, we can't definitively say what the LLM intended
+          // Auto-coercion will handle common cases (numbers, booleans) appropriately
+          case "union":
+          case "ZodUnion":
+            return "unknown";
+          // Discriminated union - complex, return unknown
+          case "discriminatedUnion":
+          case "ZodDiscriminatedUnion":
+            return "unknown";
+          // Intersection - check both sides
+          case "intersection":
+          case "ZodIntersection": {
+            const def = getDef(unwrapped);
+            const left = def?.left;
+            const right = def?.right;
+            if (!left || !right) return "unknown";
+            const leftType = this.getBaseType(left);
+            const rightType = this.getBaseType(right);
+            if (leftType === rightType) return leftType;
+            if (leftType === "string" || rightType === "string") return "string";
+            return "unknown";
+          }
+          // Effects/transforms - return unknown to let Zod handle it
+          case "effects":
+          case "ZodEffects":
+            return "unknown";
+          // Lazy - can't resolve without evaluating
+          case "lazy":
+          case "ZodLazy":
+            return "unknown";
+          // Complex types - return unknown
+          case "object":
+          case "ZodObject":
+          case "array":
+          case "ZodArray":
+          case "tuple":
+          case "ZodTuple":
+          case "record":
+          case "ZodRecord":
+          case "map":
+          case "ZodMap":
+          case "set":
+          case "ZodSet":
+          case "function":
+          case "ZodFunction":
+          case "promise":
+          case "ZodPromise":
+          case "date":
+          case "ZodDate":
+            return "unknown";
+          // Unknown/any/never/void/undefined/null
+          case "unknown":
+          case "ZodUnknown":
+          case "any":
+          case "ZodAny":
+          case "never":
+          case "ZodNever":
+          case "void":
+          case "ZodVoid":
+          case "undefined":
+          case "ZodUndefined":
+          case "null":
+          case "ZodNull":
+            return "unknown";
+          default:
+            return "unknown";
+        }
       }
     };
   }
@@ -1785,6 +2128,7 @@ function parseBlockParams(content, options) {
   const argPrefix = options?.argPrefix ?? GADGET_ARG_PREFIX;
   const result = {};
   const seenPointers = /* @__PURE__ */ new Set();
+  const introspector = options?.schema ? new SchemaIntrospector(options.schema) : void 0;
   const parts = content.split(argPrefix);
   for (let i = 1; i < parts.length; i++) {
     const part = parts[i];
@@ -1796,7 +2140,7 @@ function parseBlockParams(content, options) {
           throw new Error(`Duplicate pointer: ${pointer2}`);
         }
         seenPointers.add(pointer2);
-        setByPointer(result, pointer2, "");
+        setByPointer(result, pointer2, "", introspector);
       }
       continue;
     }
@@ -1812,15 +2156,30 @@ function parseBlockParams(content, options) {
       throw new Error(`Duplicate pointer: ${pointer}`);
     }
     seenPointers.add(pointer);
-    setByPointer(result, pointer, value);
+    setByPointer(result, pointer, value, introspector);
   }
   return result;
 }
-function coerceValue(value) {
+function coerceValue(value, expectedType) {
   if (value.includes("\n")) {
     return value;
   }
   const trimmed = value.trim();
+  if (expectedType === "string") {
+    return value;
+  }
+  if (expectedType === "boolean") {
+    if (trimmed === "true") return true;
+    if (trimmed === "false") return false;
+    return value;
+  }
+  if (expectedType === "number") {
+    const num = Number(trimmed);
+    if (!isNaN(num) && isFinite(num) && trimmed !== "") {
+      return num;
+    }
+    return value;
+  }
   if (trimmed === "true") return true;
   if (trimmed === "false") return false;
   if (trimmed !== "" && /^-?\d+(\.\d+)?$/.test(trimmed)) {
@@ -1831,7 +2190,7 @@ function coerceValue(value) {
   }
   return value;
 }
-function setByPointer(obj, pointer, value) {
+function setByPointer(obj, pointer, value, introspector) {
   const segments = pointer.split("/");
   let current = obj;
   for (let i = 0; i < segments.length - 1; i++) {
@@ -1859,7 +2218,8 @@ function setByPointer(obj, pointer, value) {
     }
   }
   const lastSegment = segments[segments.length - 1];
-  const coercedValue = coerceValue(value);
+  const expectedType = introspector?.getTypeAtPath(pointer);
+  const coercedValue = coerceValue(value, expectedType);
   if (Array.isArray(current)) {
     const index = parseInt(lastSegment, 10);
     if (isNaN(index) || index < 0) {
@@ -1877,6 +2237,122 @@ var init_block_params = __esm({
   "src/gadgets/block-params.ts"() {
     "use strict";
     init_constants();
+    init_schema_introspector();
+  }
+});
+
+// src/gadgets/error-formatter.ts
+var GadgetErrorFormatter;
+var init_error_formatter = __esm({
+  "src/gadgets/error-formatter.ts"() {
+    "use strict";
+    init_constants();
+    GadgetErrorFormatter = class {
+      argPrefix;
+      startPrefix;
+      endPrefix;
+      constructor(options = {}) {
+        this.argPrefix = options.argPrefix ?? GADGET_ARG_PREFIX;
+        this.startPrefix = options.startPrefix ?? GADGET_START_PREFIX;
+        this.endPrefix = options.endPrefix ?? GADGET_END_PREFIX;
+      }
+      /**
+       * Format a Zod validation error with full gadget instructions.
+       *
+       * @param gadgetName - Name of the gadget that was called
+       * @param zodError - The Zod validation error
+       * @param gadget - The gadget instance (for generating instructions)
+       * @returns Formatted error message with usage instructions
+       */
+      formatValidationError(gadgetName, zodError, gadget) {
+        const parts = [];
+        parts.push(`Error: Invalid parameters for '${gadgetName}':`);
+        for (const issue of zodError.issues) {
+          const path2 = issue.path.join(".") || "root";
+          parts.push(`  - ${path2}: ${issue.message}`);
+        }
+        parts.push("");
+        parts.push("Gadget Usage:");
+        parts.push(gadget.getInstruction(this.argPrefix));
+        return parts.join("\n");
+      }
+      /**
+       * Format a parse error with block format reference.
+       *
+       * @param gadgetName - Name of the gadget that was called
+       * @param parseError - The parse error message
+       * @param gadget - The gadget instance if found (for generating instructions)
+       * @returns Formatted error message with format reference
+       */
+      formatParseError(gadgetName, parseError, gadget) {
+        const parts = [];
+        parts.push(`Error: Failed to parse parameters for '${gadgetName}':`);
+        parts.push(`  ${parseError}`);
+        if (gadget) {
+          parts.push("");
+          parts.push("Gadget Usage:");
+          parts.push(gadget.getInstruction(this.argPrefix));
+        }
+        parts.push("");
+        parts.push("Block Format Reference:");
+        parts.push(`  ${this.startPrefix}${gadgetName}`);
+        parts.push(`  ${this.argPrefix}parameterName`);
+        parts.push("  parameter value here");
+        parts.push(`  ${this.endPrefix}`);
+        return parts.join("\n");
+      }
+      /**
+       * Format a registry error (gadget not found) with available gadgets list.
+       *
+       * @param gadgetName - Name of the gadget that was not found
+       * @param availableGadgets - List of available gadget names
+       * @returns Formatted error message with available gadgets
+       */
+      formatRegistryError(gadgetName, availableGadgets) {
+        const parts = [];
+        parts.push(`Error: Gadget '${gadgetName}' not found.`);
+        if (availableGadgets.length > 0) {
+          parts.push("");
+          parts.push(`Available gadgets: ${availableGadgets.join(", ")}`);
+        } else {
+          parts.push("");
+          parts.push("No gadgets are currently registered.");
+        }
+        return parts.join("\n");
+      }
+    };
+  }
+});
+
+// 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;
+      }
+    };
   }
 });
 
@@ -1994,64 +2470,341 @@ var init_parser = __esm({
               break;
             }
           }
-          const parametersRaw = this.buffer.substring(contentStartIndex, partEndIndex).trim();
-          const { parameters, parseError } = this.parseParameters(parametersRaw);
-          yield {
-            type: "gadget_call",
-            call: {
-              gadgetName: actualGadgetName,
-              invocationId,
-              parametersRaw,
-              parameters,
-              parseError
-            }
+          const parametersRaw = this.buffer.substring(contentStartIndex, partEndIndex).trim();
+          const { parameters, parseError } = this.parseParameters(parametersRaw);
+          yield {
+            type: "gadget_call",
+            call: {
+              gadgetName: actualGadgetName,
+              invocationId,
+              parametersRaw,
+              parameters,
+              parseError
+            }
+          };
+          startIndex = partEndIndex + endMarkerLength;
+          this.lastReportedTextLength = startIndex;
+        }
+        if (startIndex > 0) {
+          this.buffer = this.buffer.substring(startIndex);
+          this.lastReportedTextLength = 0;
+        }
+      }
+      // 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,
+                parametersRaw,
+                parameters,
+                parseError
+              }
+            };
+            return;
+          }
+        }
+        const remainingText = this.takeTextUntil(this.buffer.length);
+        if (remainingText !== void 0) {
+          yield { type: "text", content: remainingText };
+        }
+      }
+      // Reset parser state (note: global invocation counter is NOT reset to ensure unique IDs)
+      reset() {
+        this.buffer = "";
+        this.lastReportedTextLength = 0;
+      }
+    };
+  }
+});
+
+// src/gadgets/executor.ts
+var GadgetExecutor;
+var init_executor = __esm({
+  "src/gadgets/executor.ts"() {
+    "use strict";
+    init_constants();
+    init_logger();
+    init_block_params();
+    init_error_formatter();
+    init_exceptions();
+    init_parser();
+    GadgetExecutor = class {
+      constructor(registry, onHumanInputRequired, logger, defaultGadgetTimeoutMs, errorFormatterOptions) {
+        this.registry = registry;
+        this.onHumanInputRequired = onHumanInputRequired;
+        this.defaultGadgetTimeoutMs = defaultGadgetTimeoutMs;
+        this.logger = logger ?? createLogger({ name: "llmist:executor" });
+        this.errorFormatter = new GadgetErrorFormatter(errorFormatterOptions);
+        this.argPrefix = errorFormatterOptions?.argPrefix ?? GADGET_ARG_PREFIX;
+      }
+      logger;
+      errorFormatter;
+      argPrefix;
+      /**
+       * Creates a promise that rejects with a TimeoutException after the specified timeout.
+       */
+      createTimeoutPromise(gadgetName, timeoutMs) {
+        return new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(new TimeoutException(gadgetName, timeoutMs));
+          }, timeoutMs);
+        });
+      }
+      // Execute a gadget call asynchronously
+      async execute(call) {
+        const startTime = Date.now();
+        this.logger.debug("Executing gadget", {
+          gadgetName: call.gadgetName,
+          invocationId: call.invocationId,
+          parameters: call.parameters
+        });
+        const rawParameters = call.parameters ?? {};
+        let validatedParameters = rawParameters;
+        try {
+          const gadget = this.registry.get(call.gadgetName);
+          if (!gadget) {
+            this.logger.error("Gadget not found", { gadgetName: call.gadgetName });
+            const availableGadgets = this.registry.getNames();
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: call.parameters ?? {},
+              error: this.errorFormatter.formatRegistryError(call.gadgetName, availableGadgets),
+              executionTimeMs: Date.now() - startTime
+            };
+          }
+          if (call.parseError || !call.parameters) {
+            this.logger.error("Gadget parameter parse error", {
+              gadgetName: call.gadgetName,
+              parseError: call.parseError,
+              rawParameters: call.parametersRaw
+            });
+            const parseErrorMessage = call.parseError ?? "Failed to parse parameters";
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: {},
+              error: this.errorFormatter.formatParseError(call.gadgetName, parseErrorMessage, gadget),
+              executionTimeMs: Date.now() - startTime
+            };
+          }
+          let schemaAwareParameters = rawParameters;
+          const hasBlockFormat = call.parametersRaw?.includes(this.argPrefix);
+          if (gadget.parameterSchema && hasBlockFormat) {
+            try {
+              const cleanedRaw = stripMarkdownFences(call.parametersRaw);
+              const initialParse = parseBlockParams(cleanedRaw, { argPrefix: this.argPrefix });
+              const parametersWereModified = !this.deepEquals(rawParameters, initialParse);
+              if (parametersWereModified) {
+                this.logger.debug("Parameters modified by interceptor, skipping re-parse", {
+                  gadgetName: call.gadgetName
+                });
+                schemaAwareParameters = rawParameters;
+              } else {
+                schemaAwareParameters = parseBlockParams(cleanedRaw, {
+                  argPrefix: this.argPrefix,
+                  schema: gadget.parameterSchema
+                });
+                this.logger.debug("Re-parsed parameters with schema", {
+                  gadgetName: call.gadgetName,
+                  original: rawParameters,
+                  schemaAware: schemaAwareParameters
+                });
+              }
+            } catch (error) {
+              this.logger.warn("Schema-aware re-parsing failed, using original parameters", {
+                gadgetName: call.gadgetName,
+                error: error instanceof Error ? error.message : String(error)
+              });
+              schemaAwareParameters = rawParameters;
+            }
+          }
+          if (gadget.parameterSchema) {
+            const validationResult = gadget.parameterSchema.safeParse(schemaAwareParameters);
+            if (!validationResult.success) {
+              const validationError = this.errorFormatter.formatValidationError(
+                call.gadgetName,
+                validationResult.error,
+                gadget
+              );
+              this.logger.error("Gadget parameter validation failed", {
+                gadgetName: call.gadgetName,
+                issueCount: validationResult.error.issues.length
+              });
+              return {
+                gadgetName: call.gadgetName,
+                invocationId: call.invocationId,
+                parameters: schemaAwareParameters,
+                error: validationError,
+                executionTimeMs: Date.now() - startTime
+              };
+            }
+            validatedParameters = validationResult.data;
+          } else {
+            validatedParameters = schemaAwareParameters;
+          }
+          const timeoutMs = gadget.timeoutMs ?? this.defaultGadgetTimeoutMs;
+          let result;
+          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)
+            ]);
+          } else {
+            result = await Promise.resolve(gadget.execute(validatedParameters));
+          }
+          const executionTimeMs = Date.now() - startTime;
+          this.logger.info("Gadget executed successfully", {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            executionTimeMs
+          });
+          this.logger.debug("Gadget result", {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters: validatedParameters,
+            result,
+            executionTimeMs
+          });
+          return {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters: validatedParameters,
+            result,
+            executionTimeMs
           };
-          startIndex = partEndIndex + endMarkerLength;
-          this.lastReportedTextLength = startIndex;
-        }
-        if (startIndex > 0) {
-          this.buffer = this.buffer.substring(startIndex);
-          this.lastReportedTextLength = 0;
-        }
-      }
-      // 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 };
+        } catch (error) {
+          if (error instanceof BreakLoopException) {
+            this.logger.info("Gadget requested loop termination", {
+              gadgetName: call.gadgetName,
+              message: error.message
+            });
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: validatedParameters,
+              result: error.message,
+              breaksLoop: true,
+              executionTimeMs: Date.now() - startTime
+            };
           }
-          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,
-                parametersRaw,
-                parameters,
-                parseError
+          if (error instanceof TimeoutException) {
+            this.logger.error("Gadget execution timed out", {
+              gadgetName: call.gadgetName,
+              timeoutMs: error.timeoutMs,
+              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,
+              question: error.question
+            });
+            if (this.onHumanInputRequired) {
+              try {
+                const answer = await this.onHumanInputRequired(error.question);
+                this.logger.debug("Human input received", {
+                  gadgetName: call.gadgetName,
+                  answerLength: answer.length
+                });
+                return {
+                  gadgetName: call.gadgetName,
+                  invocationId: call.invocationId,
+                  parameters: validatedParameters,
+                  result: answer,
+                  executionTimeMs: Date.now() - startTime
+                };
+              } catch (inputError) {
+                this.logger.error("Human input callback error", {
+                  gadgetName: call.gadgetName,
+                  error: inputError instanceof Error ? inputError.message : String(inputError)
+                });
+                return {
+                  gadgetName: call.gadgetName,
+                  invocationId: call.invocationId,
+                  parameters: validatedParameters,
+                  error: inputError instanceof Error ? inputError.message : String(inputError),
+                  executionTimeMs: Date.now() - startTime
+                };
               }
+            }
+            this.logger.warn("Human input required but no callback provided", {
+              gadgetName: call.gadgetName
+            });
+            return {
+              gadgetName: call.gadgetName,
+              invocationId: call.invocationId,
+              parameters: validatedParameters,
+              error: "Human input required but not available (stdin is not interactive)",
+              executionTimeMs: Date.now() - startTime
             };
-            return;
           }
-        }
-        const remainingText = this.takeTextUntil(this.buffer.length);
-        if (remainingText !== void 0) {
-          yield { type: "text", content: remainingText };
+          const executionTimeMs = Date.now() - startTime;
+          this.logger.error("Gadget execution failed", {
+            gadgetName: call.gadgetName,
+            error: error instanceof Error ? error.message : String(error),
+            executionTimeMs
+          });
+          return {
+            gadgetName: call.gadgetName,
+            invocationId: call.invocationId,
+            parameters: validatedParameters,
+            error: error instanceof Error ? error.message : String(error),
+            executionTimeMs
+          };
         }
       }
-      // Reset parser state (note: global invocation counter is NOT reset to ensure unique IDs)
-      reset() {
-        this.buffer = "";
-        this.lastReportedTextLength = 0;
+      // Execute multiple gadget calls in parallel
+      async executeAll(calls) {
+        return Promise.all(calls.map((call) => this.execute(call)));
+      }
+      /**
+       * Deep equality check for objects/arrays.
+       * Used to detect if parameters were modified by an interceptor.
+       */
+      deepEquals(a, b) {
+        if (a === b) return true;
+        if (a === null || b === null) return a === b;
+        if (typeof a !== typeof b) return false;
+        if (typeof a !== "object") return a === b;
+        if (Array.isArray(a) !== Array.isArray(b)) return false;
+        if (Array.isArray(a) && Array.isArray(b)) {
+          if (a.length !== b.length) return false;
+          return a.every((val, i) => this.deepEquals(val, b[i]));
+        }
+        const aObj = a;
+        const bObj = b;
+        const aKeys = Object.keys(aObj);
+        const bKeys = Object.keys(bObj);
+        if (aKeys.length !== bKeys.length) return false;
+        return aKeys.every((key) => this.deepEquals(aObj[key], bObj[key]));
       }
     };
   }
@@ -2094,7 +2847,8 @@ var init_stream_processor = __esm({
           options.registry,
           options.onHumanInputRequired,
           this.logger.getSubLogger({ name: "executor" }),
-          options.defaultGadgetTimeoutMs
+          options.defaultGadgetTimeoutMs,
+          { argPrefix: options.gadgetArgPrefix }
         );
       }
       /**
@@ -2463,6 +3217,7 @@ var init_agent = __esm({
     init_model_shortcuts();
     init_output_viewer();
     init_logger();
+    init_manager();
     init_gadget_output_store();
     init_agent_internal_key();
     init_conversation_manager();
@@ -2493,6 +3248,8 @@ var init_agent = __esm({
       outputStore;
       outputLimitEnabled;
       outputLimitCharLimit;
+      // Context compaction
+      compactionManager;
       /**
        * Creates a new Agent instance.
        * @internal This constructor is private. Use LLMist.createAgent() or AgentBuilder instead.
@@ -2552,6 +3309,14 @@ var init_agent = __esm({
         if (options.userPrompt) {
           this.conversation.addUserMessage(options.userPrompt);
         }
+        const compactionEnabled = options.compactionConfig?.enabled ?? true;
+        if (compactionEnabled) {
+          this.compactionManager = new CompactionManager(
+            this.client,
+            this.model,
+            options.compactionConfig
+          );
+        }
       }
       /**
        * Get the gadget registry for this agent.
@@ -2574,6 +3339,53 @@ var init_agent = __esm({
       getRegistry() {
         return this.registry;
       }
+      /**
+       * Manually trigger context compaction.
+       *
+       * Forces compaction regardless of threshold. Useful for:
+       * - Pre-emptive context management before expected long operations
+       * - Testing compaction behavior
+       *
+       * @returns CompactionEvent if compaction was performed, null if not configured or no history
+       *
+       * @example
+       * ```typescript
+       * const agent = await LLMist.createAgent()
+       *   .withModel('sonnet')
+       *   .withCompaction()
+       *   .ask('...');
+       *
+       * // Manually compact before a long operation
+       * const event = await agent.compact();
+       * if (event) {
+       *   console.log(`Saved ${event.tokensBefore - event.tokensAfter} tokens`);
+       * }
+       * ```
+       */
+      async compact() {
+        if (!this.compactionManager) {
+          return null;
+        }
+        return this.compactionManager.compact(this.conversation, -1);
+      }
+      /**
+       * Get compaction statistics.
+       *
+       * @returns CompactionStats if compaction is enabled, null otherwise
+       *
+       * @example
+       * ```typescript
+       * const stats = agent.getCompactionStats();
+       * if (stats) {
+       *   console.log(`Total compactions: ${stats.totalCompactions}`);
+       *   console.log(`Tokens saved: ${stats.totalTokensSaved}`);
+       *   console.log(`Current usage: ${stats.currentUsage.percent.toFixed(1)}%`);
+       * }
+       * ```
+       */
+      getCompactionStats() {
+        return this.compactionManager?.getStats() ?? null;
+      }
       /**
        * Run the agent loop.
        * Clean, simple orchestration - all complexity is in StreamProcessor.
@@ -2594,6 +3406,30 @@ var init_agent = __esm({
         while (currentIteration < this.maxIterations) {
           this.logger.debug("Starting iteration", { iteration: currentIteration });
           try {
+            if (this.compactionManager) {
+              const compactionEvent = await this.compactionManager.checkAndCompact(
+                this.conversation,
+                currentIteration
+              );
+              if (compactionEvent) {
+                this.logger.info("Context compacted", {
+                  strategy: compactionEvent.strategy,
+                  tokensBefore: compactionEvent.tokensBefore,
+                  tokensAfter: compactionEvent.tokensAfter
+                });
+                yield { type: "compaction", event: compactionEvent };
+                await this.safeObserve(async () => {
+                  if (this.hooks.observers?.onCompaction) {
+                    await this.hooks.observers.onCompaction({
+                      iteration: currentIteration,
+                      event: compactionEvent,
+                      stats: this.compactionManager.getStats(),
+                      logger: this.logger
+                    });
+                  }
+                });
+              }
+            }
             let llmOptions = {
               model: this.model,
               messages: this.conversation.getMessages(),
@@ -2613,6 +3449,7 @@ var init_agent = __esm({
             if (this.hooks.controllers?.beforeLLMCall) {
               const context = {
                 iteration: currentIteration,
+                maxIterations: this.maxIterations,
                 options: llmOptions,
                 logger: this.logger
               };
@@ -2677,12 +3514,17 @@ var init_agent = __esm({
             });
             let finalMessage = result.finalMessage;
             if (this.hooks.controllers?.afterLLMCall) {
+              const gadgetCallCount = result.outputs.filter(
+                (output) => output.type === "gadget_result"
+              ).length;
               const context = {
                 iteration: currentIteration,
+                maxIterations: this.maxIterations,
                 options: llmOptions,
                 finishReason: result.finishReason,
                 usage: result.usage,
                 finalMessage: result.finalMessage,
+                gadgetCallCount,
                 logger: this.logger
               };
               const action = await this.hooks.controllers.afterLLMCall(context);
@@ -4917,6 +5759,7 @@ var init_builder = __esm({
       defaultGadgetTimeoutMs;
       gadgetOutputLimit;
       gadgetOutputLimitPercent;
+      compactionConfig;
       constructor(client) {
         this.client = client;
       }
@@ -5312,6 +6155,57 @@ var init_builder = __esm({
         this.gadgetOutputLimitPercent = percent;
         return this;
       }
+      /**
+       * Configure context compaction.
+       *
+       * Context compaction automatically manages conversation history to prevent
+       * context window overflow in long-running agent conversations.
+       *
+       * @param config - Compaction configuration options
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * // Custom thresholds
+       * .withCompaction({
+       *   triggerThresholdPercent: 70,
+       *   targetPercent: 40,
+       *   preserveRecentTurns: 10,
+       * })
+       *
+       * // Different strategy
+       * .withCompaction({
+       *   strategy: 'sliding-window',
+       * })
+       *
+       * // With callback
+       * .withCompaction({
+       *   onCompaction: (event) => {
+       *     console.log(`Saved ${event.tokensBefore - event.tokensAfter} tokens`);
+       *   }
+       * })
+       * ```
+       */
+      withCompaction(config) {
+        this.compactionConfig = { ...config, enabled: config.enabled ?? true };
+        return this;
+      }
+      /**
+       * Disable context compaction.
+       *
+       * By default, compaction is enabled. Use this method to explicitly disable it.
+       *
+       * @returns This builder for chaining
+       *
+       * @example
+       * ```typescript
+       * .withoutCompaction() // Disable automatic compaction
+       * ```
+       */
+      withoutCompaction() {
+        this.compactionConfig = { enabled: false };
+        return this;
+      }
       /**
        * Add a synthetic gadget call to the conversation history.
        *
@@ -5427,7 +6321,8 @@ ${endPrefix}`
           shouldContinueAfterError: this.shouldContinueAfterError,
           defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
           gadgetOutputLimit: this.gadgetOutputLimit,
-          gadgetOutputLimitPercent: this.gadgetOutputLimitPercent
+          gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
+          compactionConfig: this.compactionConfig
         };
         return new Agent(AGENT_INTERNAL_KEY, options);
       }
@@ -5529,7 +6424,8 @@ ${endPrefix}`
           shouldContinueAfterError: this.shouldContinueAfterError,
           defaultGadgetTimeoutMs: this.defaultGadgetTimeoutMs,
           gadgetOutputLimit: this.gadgetOutputLimit,
-          gadgetOutputLimitPercent: this.gadgetOutputLimitPercent
+          gadgetOutputLimitPercent: this.gadgetOutputLimitPercent,
+          compactionConfig: this.compactionConfig
         };
         return new Agent(AGENT_INTERNAL_KEY, options);
       }
@@ -5588,7 +6484,7 @@ var import_commander2 = require("commander");
 // package.json
 var package_default = {
   name: "llmist",
-  version: "1.0.0",
+  version: "1.2.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",
@@ -5735,26 +6631,16 @@ var askUser = createGadget({
 });
 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.",
+  description: "Tell the user something important.",
   schema: import_zod2.z.object({
     message: import_zod2.z.string().optional().describe("The message to display to the user in Markdown"),
-    done: import_zod2.z.boolean().default(false).describe("Set to true to end the conversation, false to continue"),
     type: import_zod2.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",
+      comment: "Warn the user about something",
       params: {
         message: "Found 3 files with potential issues. Continuing analysis...",
-        done: false,
         type: "warning"
       }
     },
@@ -5762,12 +6648,11 @@ var tellUser = createGadget({
       comment: "Share detailed analysis with bullet points (use heredoc for multiline)",
       params: {
         message: "Here's what I found in the codebase:\n\n1. **Main entry point**: `src/index.ts` exports all public APIs\n2. **Core logic**: Located in `src/core/` with 5 modules\n3. **Tests**: Good coverage in `src/__tests__/`\n\nI'll continue exploring the core modules.",
-        done: false,
         type: "info"
       }
     }
   ],
-  execute: ({ message, done, type }) => {
+  execute: ({ message, type }) => {
     if (!message || message.trim() === "") {
       return "\u26A0\uFE0F  TellUser was called without a message. Please provide content in the 'message' field.";
     }
@@ -5777,14 +6662,24 @@ var tellUser = createGadget({
       warning: "\u26A0\uFE0F  ",
       error: "\u274C "
     };
-    const plainResult = prefixes[type] + message;
-    if (done) {
-      throw new BreakLoopException(plainResult);
+    return prefixes[type] + message;
+  }
+});
+var finish = createGadget({
+  name: "Finish",
+  description: "Signal that you have completed your task. Call this when your work is done.",
+  schema: import_zod2.z.object({}),
+  examples: [
+    {
+      comment: "Signal task completion",
+      params: {}
     }
-    return plainResult;
+  ],
+  execute: () => {
+    throw new BreakLoopException("Task completed");
   }
 });
-var builtinGadgets = [askUser, tellUser];
+var builtinGadgets = [askUser, tellUser, finish];
 
 // src/cli/gadgets.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
@@ -6340,6 +7235,17 @@ var StreamProgress = class {
     } else {
       parts.push(iterPart);
     }
+    const usagePercent = this.getContextUsagePercent();
+    if (usagePercent !== null) {
+      const formatted = `${Math.round(usagePercent)}%`;
+      if (usagePercent >= 80) {
+        parts.push(import_chalk2.default.red(formatted));
+      } else if (usagePercent >= 50) {
+        parts.push(import_chalk2.default.yellow(formatted));
+      } else {
+        parts.push(import_chalk2.default.green(formatted));
+      }
+    }
     if (this.callInputTokens > 0) {
       const prefix = this.callInputTokensEstimated ? "~" : "";
       parts.push(import_chalk2.default.dim("\u2191") + import_chalk2.default.yellow(` ${prefix}${formatTokens(this.callInputTokens)}`));
@@ -6375,6 +7281,21 @@ var StreamProgress = class {
       return 0;
     }
   }
+  /**
+   * Calculates context window usage percentage.
+   * Returns null if model is unknown or context window unavailable.
+   */
+  getContextUsagePercent() {
+    if (!this.modelRegistry || !this.model || this.callInputTokens === 0) {
+      return null;
+    }
+    const modelName = this.model.includes(":") ? this.model.split(":")[1] : this.model;
+    const limits = this.modelRegistry.getModelLimits(modelName);
+    if (!limits?.contextWindow) {
+      return null;
+    }
+    return this.callInputTokens / limits.contextWindow * 100;
+  }
   renderCumulativeMode(spinner) {
     const elapsed = ((Date.now() - this.totalStartTime) / 1e3).toFixed(1);
     const parts = [];
@@ -7002,7 +7923,9 @@ function resolveTemplate(eta, template, context = {}, configPath) {
   try {
     const fullContext = {
       ...context,
-      env: process.env
+      env: process.env,
+      date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+      // "2025-12-01"
     };
     return eta.renderString(template, fullContext);
   } catch (error) {