llmist 1.2.0 → 1.3.1

package/dist/testing/index.cjs

@@ -1112,6 +1112,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({
@@ -1214,10 +1625,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);
         }
@@ -1234,6 +1651,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);
+          }
+        }
+      }
     };
   }
 });
@@ -2780,6 +3216,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();
@@ -2810,6 +3247,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.
@@ -2869,6 +3308,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.
@@ -2891,6 +3338,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.
@@ -2911,6 +3405,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(),
@@ -2930,6 +3448,7 @@ var init_agent = __esm({
             if (this.hooks.controllers?.beforeLLMCall) {
               const context = {
                 iteration: currentIteration,
+                maxIterations: this.maxIterations,
                 options: llmOptions,
                 logger: this.logger
               };
@@ -2994,12 +3513,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);
@@ -3261,6 +3785,7 @@ var init_builder = __esm({
       defaultGadgetTimeoutMs;
       gadgetOutputLimit;
       gadgetOutputLimitPercent;
+      compactionConfig;
       constructor(client) {
         this.client = client;
       }
@@ -3656,6 +4181,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.
        *
@@ -3771,7 +4347,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);
       }
@@ -3873,7 +4450,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);
       }
@@ -5858,19 +6436,44 @@ var init_client = __esm({
 var testing_exports = {};
 __export(testing_exports, {
   MockBuilder: () => MockBuilder,
+  MockConversationManager: () => MockConversationManager,
   MockGadgetBuilder: () => MockGadgetBuilder,
   MockManager: () => MockManager,
+  MockPromptRecorder: () => MockPromptRecorder,
   MockProviderAdapter: () => MockProviderAdapter,
+  collectOutput: () => collectOutput,
+  collectStream: () => collectStream,
+  collectStreamText: () => collectStreamText,
+  createAssistantMessage: () => createAssistantMessage,
+  createConversation: () => createConversation,
+  createConversationWithGadgets: () => createConversationWithGadgets,
+  createEmptyStream: () => createEmptyStream,
+  createErrorStream: () => createErrorStream,
+  createLargeConversation: () => createLargeConversation,
+  createMinimalConversation: () => createMinimalConversation,
   createMockAdapter: () => createMockAdapter,
   createMockClient: () => createMockClient,
+  createMockConversationManager: () => createMockConversationManager,
   createMockGadget: () => createMockGadget,
+  createMockPrompt: () => createMockPrompt,
+  createMockReadable: () => createMockReadable,
   createMockStream: () => createMockStream,
+  createMockWritable: () => createMockWritable,
+  createSystemMessage: () => createSystemMessage,
+  createTestEnvironment: () => createTestEnvironment,
+  createTestStream: () => createTestStream,
   createTextMockStream: () => createTextMockStream,
+  createTextStream: () => createTextStream,
+  createUserMessage: () => createUserMessage,
+  estimateTokens: () => estimateTokens,
+  getBufferedOutput: () => getBufferedOutput,
   getMockManager: () => getMockManager,
+  getStreamFinalChunk: () => getStreamFinalChunk,
   mockGadget: () => mockGadget,
   mockLLM: () => mockLLM,
   testGadget: () => testGadget,
-  testGadgetBatch: () => testGadgetBatch
+  testGadgetBatch: () => testGadgetBatch,
+  waitFor: () => waitFor
 });
 module.exports = __toCommonJS(testing_exports);
 
@@ -6779,21 +7382,477 @@ var MockGadgetBuilder = class {
 function mockGadget() {
   return new MockGadgetBuilder();
 }
+
+// src/testing/stream-helpers.ts
+function createTestStream(chunks) {
+  return async function* () {
+    for (const chunk of chunks) {
+      yield chunk;
+    }
+  }();
+}
+function createTextStream(text, options) {
+  return async function* () {
+    if (options?.delayMs) {
+      await sleep2(options.delayMs);
+    }
+    const chunkSize = options?.chunkSize ?? text.length;
+    const chunks = [];
+    for (let i = 0; i < text.length; i += chunkSize) {
+      chunks.push(text.slice(i, i + chunkSize));
+    }
+    for (let i = 0; i < chunks.length; i++) {
+      const isLast = i === chunks.length - 1;
+      const chunk = { text: chunks[i] };
+      if (isLast) {
+        chunk.finishReason = options?.finishReason ?? "stop";
+        const inputTokens = Math.ceil(text.length / 4);
+        const outputTokens = Math.ceil(text.length / 4);
+        chunk.usage = options?.usage ?? {
+          inputTokens,
+          outputTokens,
+          totalTokens: inputTokens + outputTokens
+        };
+      }
+      yield chunk;
+      if (options?.chunkDelayMs && !isLast) {
+        await sleep2(options.chunkDelayMs);
+      }
+    }
+  }();
+}
+async function collectStream(stream2) {
+  const chunks = [];
+  for await (const chunk of stream2) {
+    chunks.push(chunk);
+  }
+  return chunks;
+}
+async function collectStreamText(stream2) {
+  let text = "";
+  for await (const chunk of stream2) {
+    text += chunk.text ?? "";
+  }
+  return text;
+}
+async function getStreamFinalChunk(stream2) {
+  let lastChunk;
+  for await (const chunk of stream2) {
+    lastChunk = chunk;
+  }
+  return lastChunk;
+}
+function createEmptyStream() {
+  return async function* () {
+  }();
+}
+function createErrorStream(chunksBeforeError, error) {
+  return async function* () {
+    for (const chunk of chunksBeforeError) {
+      yield chunk;
+    }
+    throw error;
+  }();
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/testing/conversation-fixtures.ts
+function createConversation(turnCount, options) {
+  const messages = [];
+  const userPrefix = options?.userPrefix ?? "User message";
+  const assistantPrefix = options?.assistantPrefix ?? "Assistant response";
+  const contentLength = options?.contentLength ?? 100;
+  for (let i = 0; i < turnCount; i++) {
+    const padding = " ".repeat(Math.max(0, contentLength - 30));
+    messages.push({
+      role: "user",
+      content: `${userPrefix} ${i + 1}: This is turn ${i + 1} of the conversation.${padding}`
+    });
+    messages.push({
+      role: "assistant",
+      content: `${assistantPrefix} ${i + 1}: I acknowledge turn ${i + 1}.${padding}`
+    });
+  }
+  return messages;
+}
+function createConversationWithGadgets(turnCount, gadgetCallsPerTurn = 1, options) {
+  const messages = [];
+  const gadgetNames = options?.gadgetNames ?? ["search", "calculate", "read"];
+  const contentLength = options?.contentLength ?? 50;
+  let gadgetIndex = 0;
+  for (let turn = 0; turn < turnCount; turn++) {
+    messages.push({
+      role: "user",
+      content: `User request ${turn + 1}${"x".repeat(contentLength)}`
+    });
+    for (let g = 0; g < gadgetCallsPerTurn; g++) {
+      const gadgetName = gadgetNames[gadgetIndex % gadgetNames.length];
+      gadgetIndex++;
+      messages.push({
+        role: "assistant",
+        content: `!!!GADGET_START:${gadgetName}
+!!!ARG:query
+test query ${turn}-${g}
+!!!GADGET_END`
+      });
+      messages.push({
+        role: "user",
+        content: `Result: Gadget ${gadgetName} returned result for query ${turn}-${g}`
+      });
+    }
+    messages.push({
+      role: "assistant",
+      content: `Final response for turn ${turn + 1}${"y".repeat(contentLength)}`
+    });
+  }
+  return messages;
+}
+function estimateTokens(messages) {
+  return Math.ceil(
+    messages.reduce((sum, msg) => sum + (msg.content?.length ?? 0), 0) / 4
+  );
+}
+function createUserMessage(content) {
+  return { role: "user", content };
+}
+function createAssistantMessage(content) {
+  return { role: "assistant", content };
+}
+function createSystemMessage(content) {
+  return { role: "system", content };
+}
+function createMinimalConversation() {
+  return [
+    { role: "user", content: "Hello" },
+    { role: "assistant", content: "Hi there!" }
+  ];
+}
+function createLargeConversation(targetTokens, options) {
+  const tokensPerTurn = options?.tokensPerTurn ?? 200;
+  const turnsNeeded = Math.ceil(targetTokens / tokensPerTurn);
+  const charsPerMessage = Math.floor(tokensPerTurn * 4 / 2);
+  return createConversation(turnsNeeded, {
+    contentLength: charsPerMessage
+  });
+}
+
+// src/testing/mock-conversation.ts
+var MockConversationManager = class {
+  history;
+  baseMessages;
+  replacementHistory;
+  replaceHistoryCallCount = 0;
+  addedMessages = [];
+  constructor(history = [], baseMessages = []) {
+    this.history = [...history];
+    this.baseMessages = [...baseMessages];
+  }
+  addUserMessage(content) {
+    const msg = { role: "user", content };
+    this.history.push(msg);
+    this.addedMessages.push(msg);
+  }
+  addAssistantMessage(content) {
+    const msg = { role: "assistant", content };
+    this.history.push(msg);
+    this.addedMessages.push(msg);
+  }
+  addGadgetCall(gadgetName, parameters, result) {
+    const assistantMsg = {
+      role: "assistant",
+      content: `!!!GADGET_START:${gadgetName}
+${JSON.stringify(parameters)}
+!!!GADGET_END`
+    };
+    const resultMsg = {
+      role: "user",
+      content: `Result: ${result}`
+    };
+    this.history.push(assistantMsg);
+    this.history.push(resultMsg);
+    this.addedMessages.push(assistantMsg);
+    this.addedMessages.push(resultMsg);
+  }
+  getMessages() {
+    return [...this.baseMessages, ...this.history];
+  }
+  getHistoryMessages() {
+    return [...this.history];
+  }
+  getBaseMessages() {
+    return [...this.baseMessages];
+  }
+  replaceHistory(newHistory) {
+    this.replacementHistory = [...newHistory];
+    this.history = [...newHistory];
+    this.replaceHistoryCallCount++;
+  }
+  // ============================================
+  // Test Helper Methods
+  // ============================================
+  /**
+   * Check if replaceHistory was called.
+   */
+  wasReplaceHistoryCalled() {
+    return this.replaceHistoryCallCount > 0;
+  }
+  /**
+   * Get the number of times replaceHistory was called.
+   */
+  getReplaceHistoryCallCount() {
+    return this.replaceHistoryCallCount;
+  }
+  /**
+   * Get the most recent history passed to replaceHistory.
+   * Returns undefined if replaceHistory was never called.
+   */
+  getReplacementHistory() {
+    return this.replacementHistory;
+  }
+  /**
+   * Get all messages that were added via add* methods.
+   */
+  getAddedMessages() {
+    return [...this.addedMessages];
+  }
+  /**
+   * Reset all tracking state while preserving the conversation.
+   */
+  resetTracking() {
+    this.replacementHistory = void 0;
+    this.replaceHistoryCallCount = 0;
+    this.addedMessages = [];
+  }
+  /**
+   * Completely reset the mock to initial state.
+   * Note: baseMessages cannot be changed after construction.
+   */
+  reset(history = []) {
+    this.history = [...history];
+    this.resetTracking();
+  }
+  /**
+   * Set the history directly (for test setup).
+   */
+  setHistory(messages) {
+    this.history = [...messages];
+  }
+  /**
+   * Get the current history length.
+   */
+  getHistoryLength() {
+    return this.history.length;
+  }
+  /**
+   * Get total message count (base + history).
+   */
+  getTotalMessageCount() {
+    return this.baseMessages.length + this.history.length;
+  }
+};
+function createMockConversationManager(turnCount, baseMessages = []) {
+  const history = [];
+  for (let i = 0; i < turnCount; i++) {
+    history.push({
+      role: "user",
+      content: `User message ${i + 1}: This is turn ${i + 1} of the conversation.`
+    });
+    history.push({
+      role: "assistant",
+      content: `Assistant response ${i + 1}: I acknowledge turn ${i + 1}.`
+    });
+  }
+  return new MockConversationManager(history, baseMessages);
+}
+
+// src/testing/cli-helpers.ts
+var import_node_stream = require("stream");
+function createTestEnvironment(options = {}) {
+  const stdin = createMockReadable(options.stdin);
+  const stdout = new import_node_stream.PassThrough();
+  const stderr = new import_node_stream.PassThrough();
+  let exitCode;
+  return {
+    stdin,
+    stdout,
+    stderr,
+    isTTY: options.isTTY ?? false,
+    argv: options.argv ?? ["node", "llmist"],
+    env: { ...filterDefinedEnv(process.env), ...options.env },
+    get exitCode() {
+      return exitCode;
+    },
+    setExitCode: (code) => {
+      exitCode = code;
+    }
+  };
+}
+function createMockReadable(input) {
+  if (!input) {
+    const stream3 = new import_node_stream.Readable({ read() {
+    } });
+    stream3.push(null);
+    return stream3;
+  }
+  const content = Array.isArray(input) ? `${input.join("\n")}
+` : input;
+  const stream2 = new import_node_stream.Readable({ read() {
+  } });
+  stream2.push(content);
+  stream2.push(null);
+  return stream2;
+}
+function createMockWritable() {
+  const chunks = [];
+  const stream2 = new import_node_stream.Writable({
+    write(chunk, _encoding, callback) {
+      chunks.push(Buffer.from(chunk));
+      callback();
+    }
+  });
+  stream2.getData = () => Buffer.concat(chunks).toString("utf8");
+  return stream2;
+}
+async function collectOutput(stream2, timeout = 5e3) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const timeoutId = setTimeout(() => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    }, timeout);
+    stream2.on("data", (chunk) => {
+      chunks.push(Buffer.from(chunk));
+    });
+    stream2.on("end", () => {
+      clearTimeout(timeoutId);
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    stream2.on("error", (err) => {
+      clearTimeout(timeoutId);
+      reject(err);
+    });
+  });
+}
+function getBufferedOutput(stream2) {
+  const chunks = [];
+  for (; ; ) {
+    const chunk = stream2.read();
+    if (chunk === null) break;
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function createMockPrompt(responses) {
+  let index = 0;
+  return async (_question) => {
+    if (index >= responses.length) {
+      throw new Error(`Mock prompt exhausted: no response for question ${index + 1}`);
+    }
+    return responses[index++];
+  };
+}
+var MockPromptRecorder = class {
+  responses;
+  index = 0;
+  questions = [];
+  constructor(responses) {
+    this.responses = responses;
+  }
+  /**
+   * The prompt function to use in tests.
+   */
+  prompt = async (question) => {
+    this.questions.push(question);
+    if (this.index >= this.responses.length) {
+      throw new Error(`Mock prompt exhausted after ${this.index} questions`);
+    }
+    return this.responses[this.index++];
+  };
+  /**
+   * Get all questions that were asked.
+   */
+  getQuestions() {
+    return [...this.questions];
+  }
+  /**
+   * Get the number of questions asked.
+   */
+  getQuestionCount() {
+    return this.questions.length;
+  }
+  /**
+   * Reset the recorder state.
+   */
+  reset(newResponses) {
+    this.index = 0;
+    this.questions = [];
+    if (newResponses) {
+      this.responses = newResponses;
+    }
+  }
+};
+async function waitFor(condition, timeout = 5e3, interval = 50) {
+  const startTime = Date.now();
+  while (!condition()) {
+    if (Date.now() - startTime > timeout) {
+      throw new Error(`waitFor timed out after ${timeout}ms`);
+    }
+    await sleep3(interval);
+  }
+}
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function filterDefinedEnv(env) {
+  const result = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MockBuilder,
+  MockConversationManager,
   MockGadgetBuilder,
   MockManager,
+  MockPromptRecorder,
   MockProviderAdapter,
+  collectOutput,
+  collectStream,
+  collectStreamText,
+  createAssistantMessage,
+  createConversation,
+  createConversationWithGadgets,
+  createEmptyStream,
+  createErrorStream,
+  createLargeConversation,
+  createMinimalConversation,
   createMockAdapter,
   createMockClient,
+  createMockConversationManager,
   createMockGadget,
+  createMockPrompt,
+  createMockReadable,
   createMockStream,
+  createMockWritable,
+  createSystemMessage,
+  createTestEnvironment,
+  createTestStream,
   createTextMockStream,
+  createTextStream,
+  createUserMessage,
+  estimateTokens,
+  getBufferedOutput,
   getMockManager,
+  getStreamFinalChunk,
   mockGadget,
   mockLLM,
   testGadget,
-  testGadgetBatch
+  testGadgetBatch,
+  waitFor
 });
 //# sourceMappingURL=index.cjs.map