@everworker/oneringai 0.4.0 → 0.4.2

package/dist/index.cjs

@@ -11943,6 +11943,9 @@ var ToolManager = class extends eventemitter3.EventEmitter {
   }
 };
 
+// src/core/context-nextgen/AgentContextNextGen.ts
+init_Logger();
+
 // src/core/Vendor.ts
 var Vendor = {
   OpenAI: "openai",
@@ -13316,6 +13319,7 @@ var ContentType = /* @__PURE__ */ ((ContentType2) => {
   ContentType2["OUTPUT_TEXT"] = "output_text";
   ContentType2["TOOL_USE"] = "tool_use";
   ContentType2["TOOL_RESULT"] = "tool_result";
+  ContentType2["THINKING"] = "thinking";
   return ContentType2;
 })(ContentType || {});
 
@@ -13578,6 +13582,11 @@ var BasePluginNextGen = class {
   }
 };
 
+// src/core/context-nextgen/snapshot.ts
+function formatPluginDisplayName(name) {
+  return name.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
 // src/core/context-nextgen/AgentContextNextGen.ts
 init_Connector();
 
@@ -14505,7 +14514,7 @@ var PRIORITY_VALUES = {
 };
 var DEFAULT_CONFIG = {
   maxEntries: 20,
-  maxTotalTokens: 4e3,
+  maxTotalTokens: 4e4,
   defaultPriority: "normal",
   showTimestamps: false
 };
@@ -16256,8 +16265,11 @@ var AlgorithmicCompactionStrategy = class {
    * Emergency compaction when context exceeds threshold.
    *
    * Strategy:
-   * 1. Run consolidate() first to move tool results to memory
+   * 1. Run consolidate() first to move tool results to memory (if working memory available)
    * 2. If still need space, apply rolling window (remove oldest messages)
+   *
+   * Gracefully degrades: if working memory plugin is not registered,
+   * skips step 1 and only uses rolling window compaction.
    */
   async compact(context, targetToFree) {
     const log = [];
@@ -16270,7 +16282,7 @@ var AlgorithmicCompactionStrategy = class {
       tokensFreed += Math.abs(consolidateResult.tokensChanged);
       log.push(...consolidateResult.actions);
     }
-    let remaining = targetToFree - tokensFreed;
+    const remaining = targetToFree - tokensFreed;
     if (remaining > 0 && context.conversation.length > 0) {
       log.push(`Rolling window: need to free ~${remaining} more tokens`);
       const result = await this.applyRollingWindow(context, remaining, log);
@@ -16284,8 +16296,11 @@ var AlgorithmicCompactionStrategy = class {
    * Post-cycle consolidation.
    *
    * 1. Find all tool pairs in conversation
-   * 2. Move large tool results (> threshold) to Working Memory
+   * 2. Move large tool results (> threshold) to Working Memory (if available)
    * 3. Limit remaining tool pairs to maxToolPairs
+   *
+   * Gracefully degrades: if working memory is not available, skips step 2
+   * and only limits tool pairs + removes excess via rolling window.
    */
   async consolidate(context) {
     const log = [];
@@ -16296,23 +16311,25 @@ var AlgorithmicCompactionStrategy = class {
       return { performed: false, tokensChanged: 0, actions: [] };
     }
     const indicesToRemove = [];
-    for (const pair of toolPairs) {
-      if (pair.resultSizeBytes > this.toolResultSizeThreshold) {
-        const key = this.generateKey(pair.toolName, pair.toolUseId);
-        const desc = this.generateDescription(pair.toolName, pair.toolArgs);
-        await memory.store(key, desc, pair.resultContent, {
-          tier: "raw",
-          priority: "normal"
-        });
-        if (!indicesToRemove.includes(pair.toolUseIndex)) {
-          indicesToRemove.push(pair.toolUseIndex);
-        }
-        if (!indicesToRemove.includes(pair.toolResultIndex)) {
-          indicesToRemove.push(pair.toolResultIndex);
+    if (memory) {
+      for (const pair of toolPairs) {
+        if (pair.resultSizeBytes > this.toolResultSizeThreshold) {
+          const key = this.generateKey(pair.toolName, pair.toolUseId);
+          const desc = this.generateDescription(pair.toolName, pair.toolArgs);
+          await memory.store(key, desc, pair.resultContent, {
+            tier: "raw",
+            priority: "normal"
+          });
+          if (!indicesToRemove.includes(pair.toolUseIndex)) {
+            indicesToRemove.push(pair.toolUseIndex);
+          }
+          if (!indicesToRemove.includes(pair.toolResultIndex)) {
+            indicesToRemove.push(pair.toolResultIndex);
+          }
+          log.push(
+            `Moved ${pair.toolName} result (${this.formatBytes(pair.resultSizeBytes)}) to memory: ${key}`
+          );
         }
-        log.push(
-          `Moved ${pair.toolName} result (${this.formatBytes(pair.resultSizeBytes)}) to memory: ${key}`
-        );
       }
     }
     const remainingPairs = toolPairs.filter(
@@ -16341,15 +16358,12 @@ var AlgorithmicCompactionStrategy = class {
     };
   }
   /**
-   * Get the Working Memory plugin from context.
-   * @throws Error if plugin is not available
+   * Get the Working Memory plugin from context, or null if not available.
+   * When null, the strategy degrades gracefully (skips memory operations).
    */
   getWorkingMemory(context) {
     const plugin = context.plugins.find((p) => p.name === "working_memory");
-    if (!plugin) {
-      throw new Error("AlgorithmicCompactionStrategy requires working_memory plugin");
-    }
-    return plugin;
+    return plugin ? plugin : null;
   }
   /**
    * Find all tool_use/tool_result pairs in conversation.
@@ -16690,7 +16704,7 @@ var StrategyRegistry = class {
 // src/core/context-nextgen/types.ts
 var DEFAULT_FEATURES = {
   workingMemory: true,
-  inContextMemory: false,
+  inContextMemory: true,
   persistentInstructions: false,
   userInfo: false
 };
@@ -16734,6 +16748,8 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
   _storage;
   /** Destroyed flag */
   _destroyed = false;
+  /** Last thinking/reasoning content from the most recent assistant response */
+  _lastThinking = null;
   /** Cached budget from last prepare() call */
   _cachedBudget = null;
   /** Callback for beforeCompaction hook (set by Agent) */
@@ -16821,15 +16837,16 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
   }
   /**
    * Validate that a strategy's required plugins are registered.
-   * @throws Error if any required plugin is missing
+   * Logs a warning if required plugins are missing — the strategy should degrade gracefully.
    */
   validateStrategyDependencies(strategy) {
     if (!strategy.requiredPlugins?.length) return;
     const availablePlugins = new Set(this._plugins.keys());
     const missing = strategy.requiredPlugins.filter((name) => !availablePlugins.has(name));
     if (missing.length > 0) {
-      throw new Error(
-        `Strategy '${strategy.name}' requires plugins that are not registered: ${missing.join(", ")}. Available plugins: ${Array.from(availablePlugins).join(", ") || "none"}`
+      exports.logger.warn(
+        { strategy: strategy.name, missing, available: Array.from(availablePlugins) },
+        `Strategy '${strategy.name}' recommends plugins that are not registered: ${missing.join(", ")}. Strategy will degrade gracefully.`
       );
     }
   }
@@ -16945,6 +16962,13 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
   get storage() {
     return this._storage ?? null;
   }
+  /**
+   * Get the last thinking/reasoning content from the most recent assistant response.
+   * Updated on every assistant response, always available regardless of persistence setting.
+   */
+  get lastThinking() {
+    return this._lastThinking;
+  }
   /** Get max context tokens */
   get maxContextTokens() {
     return this._maxContextTokens;
@@ -17126,6 +17150,7 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
     }
     const id = this.generateId();
     const contentArray = [];
+    let thinkingText = null;
     for (const item of output) {
       if (item.type === "message" && "content" in item) {
         const msg = item;
@@ -17137,12 +17162,19 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
             });
           } else if (c.type === "tool_use" /* TOOL_USE */) {
             contentArray.push(c);
+          } else if (c.type === "thinking" /* THINKING */) {
+            const thinking = c;
+            thinkingText = thinking.thinking;
+            if (thinking.persistInHistory) {
+              contentArray.push(c);
+            }
           }
         }
       } else if (item.type === "compaction" || item.type === "reasoning") {
         continue;
       }
     }
+    this._lastThinking = thinkingText;
     if (contentArray.length > 0) {
       const message = {
         type: "message",
@@ -17241,6 +17273,7 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
    */
   async prepare() {
     this.assertNotDestroyed();
+    this._lastThinking = null;
     const compactionLog = [];
     const toolsTokens = this.calculateToolsTokens();
     const availableForContent = this._maxContextTokens - this._config.responseReserve - toolsTokens;
@@ -17453,6 +17486,8 @@ ${content}`);
             total += this._estimateImageTokens();
           }
         }
+      } else if (c.type === "thinking" /* THINKING */) {
+        total += this._estimator.estimateTokens(c.thinking || "");
       } else if (c.type === "input_image_url" /* INPUT_IMAGE_URL */) {
         const imgContent = c;
         const detail = imgContent.image_url?.detail;
@@ -17950,6 +17985,188 @@ ${content}`);
   get strategy() {
     return this._compactionStrategy.name;
   }
+  /**
+   * Get a complete, serializable snapshot of the context state.
+   *
+   * Returns all data needed by UI "Look Inside" panels without reaching
+   * into plugin internals. Plugin data is auto-discovered from the plugin
+   * registry — new/custom plugins appear automatically.
+   *
+   * @param toolStats - Optional tool usage stats (from ToolManager.getStats())
+   * @returns Serializable context snapshot
+   */
+  async getSnapshot(toolStats) {
+    const resolveContents = async (raw) => {
+      const resolved = raw instanceof Promise ? await raw : raw;
+      if (resolved instanceof Map) return Array.from(resolved.values());
+      return resolved;
+    };
+    if (this._destroyed) {
+      const emptyBudget = this._cachedBudget ?? {
+        maxTokens: this._maxContextTokens,
+        responseReserve: this._config.responseReserve,
+        systemMessageTokens: 0,
+        toolsTokens: 0,
+        conversationTokens: 0,
+        currentInputTokens: 0,
+        totalUsed: 0,
+        available: this._maxContextTokens - this._config.responseReserve,
+        utilizationPercent: 0,
+        breakdown: {
+          systemPrompt: 0,
+          persistentInstructions: 0,
+          pluginInstructions: 0,
+          pluginContents: {},
+          tools: 0,
+          conversation: 0,
+          currentInput: 0
+        }
+      };
+      return {
+        available: false,
+        agentId: this._agentId,
+        model: this._config.model,
+        features: this._config.features,
+        budget: emptyBudget,
+        strategy: this._compactionStrategy.name,
+        messagesCount: 0,
+        toolCallsCount: 0,
+        systemPrompt: null,
+        plugins: [],
+        tools: []
+      };
+    }
+    const budget = await this.calculateBudget();
+    const plugins = [];
+    for (const plugin of this._plugins.values()) {
+      let formattedContent = null;
+      try {
+        formattedContent = await plugin.getContent();
+      } catch {
+      }
+      plugins.push({
+        name: plugin.name,
+        displayName: formatPluginDisplayName(plugin.name),
+        enabled: true,
+        tokenSize: plugin.getTokenSize(),
+        instructionsTokenSize: plugin.getInstructionsTokenSize(),
+        compactable: plugin.isCompactable(),
+        contents: await resolveContents(plugin.getContents()),
+        formattedContent
+      });
+    }
+    const usageCounts = /* @__PURE__ */ new Map();
+    if (toolStats?.mostUsed) {
+      for (const { name, count } of toolStats.mostUsed) {
+        usageCounts.set(name, count);
+      }
+    }
+    const tools = [];
+    for (const toolName of this._tools.list()) {
+      const reg = this._tools.getRegistration(toolName);
+      if (!reg) continue;
+      tools.push({
+        name: toolName,
+        description: reg.tool.definition.function.description || "",
+        enabled: reg.enabled,
+        callCount: reg.metadata.usageCount ?? usageCounts.get(toolName) ?? 0,
+        namespace: reg.namespace || void 0
+      });
+    }
+    let toolCallsCount = 0;
+    for (const item of this._conversation) {
+      if (item.type === "message" && item.role === "assistant" /* ASSISTANT */) {
+        for (const c of item.content) {
+          if (c.type === "tool_use" /* TOOL_USE */) toolCallsCount++;
+        }
+      }
+    }
+    return {
+      available: true,
+      agentId: this._agentId,
+      model: this._config.model,
+      features: this._config.features,
+      budget,
+      strategy: this._compactionStrategy.name,
+      messagesCount: this._conversation.length,
+      toolCallsCount,
+      systemPrompt: this._systemPrompt ?? null,
+      plugins,
+      tools
+    };
+  }
+  /**
+   * Get a human-readable breakdown of the prepared context.
+   *
+   * Calls `prepare()` internally, then maps each InputItem to a named
+   * component with content text and token estimate. Used by "View Full Context" UIs.
+   *
+   * @returns View context data with components and raw text for "Copy All"
+   */
+  async getViewContext() {
+    if (this._destroyed) {
+      return { available: false, components: [], totalTokens: 0, rawContext: "" };
+    }
+    const { input, budget } = await this.prepare();
+    const components = [];
+    let rawParts = [];
+    for (const item of input) {
+      if (item.type === "compaction") {
+        components.push({
+          name: "Compaction Block",
+          content: "[Compacted content]",
+          tokenEstimate: 0
+        });
+        continue;
+      }
+      const msg = item;
+      const roleName = msg.role === "developer" /* DEVELOPER */ ? "System Message" : msg.role === "user" /* USER */ ? "User Message" : "Assistant Message";
+      for (const block of msg.content) {
+        let name = roleName;
+        let text = "";
+        switch (block.type) {
+          case "input_text" /* INPUT_TEXT */:
+            text = block.text;
+            break;
+          case "output_text" /* OUTPUT_TEXT */:
+            text = block.text;
+            break;
+          case "tool_use" /* TOOL_USE */:
+            name = `Tool Call: ${block.name}`;
+            text = `${block.name}(${block.arguments})`;
+            break;
+          case "tool_result" /* TOOL_RESULT */:
+            name = `Tool Result: ${block.tool_use_id}`;
+            text = typeof block.content === "string" ? block.content : JSON.stringify(block.content, null, 2);
+            if (block.error) text = `[Error] ${block.error}
+${text}`;
+            break;
+          case "input_image_url" /* INPUT_IMAGE_URL */:
+            name = "Image Input";
+            text = `[Image: ${block.image_url.url.substring(0, 100)}...]`;
+            break;
+          case "input_file" /* INPUT_FILE */:
+            name = "File Input";
+            text = `[File: ${block.file_id}]`;
+            break;
+          case "thinking" /* THINKING */:
+            name = "Thinking";
+            text = block.thinking || "";
+            break;
+        }
+        const tokenEstimate = this._estimator.estimateTokens(text);
+        components.push({ name, content: text, tokenEstimate });
+        rawParts.push(`--- ${name} ---
+${text}`);
+      }
+    }
+    return {
+      available: true,
+      components,
+      totalTokens: budget.totalUsed,
+      rawContext: rawParts.join("\n\n")
+    };
+  }
   // ============================================================================
   // Utilities
   // ============================================================================
@@ -18208,6 +18425,13 @@ var BaseTextProvider = class extends BaseProvider {
     }
     return textParts.join("\n");
   }
+  /**
+   * List available models from the provider's API.
+   * Default returns empty array; providers override when they have SDK support.
+   */
+  async listModels() {
+    return [];
+  }
   /**
    * Clean up provider resources (circuit breaker listeners, etc.)
    * Should be called when the provider is no longer needed.
@@ -18360,12 +18584,21 @@ var OpenAIResponsesConverter = class {
       } else if (item.type === "reasoning") {
         const reasoning = item;
         if (reasoning.summary) {
-          content.push({
-            type: "reasoning",
-            summary: reasoning.summary,
-            // effort field may not exist in all versions
-            ..."effort" in reasoning && { effort: reasoning.effort }
-          });
+          let summaryText;
+          if (typeof reasoning.summary === "string") {
+            summaryText = reasoning.summary;
+          } else if (Array.isArray(reasoning.summary)) {
+            summaryText = reasoning.summary.map((s) => s.text || "").filter(Boolean).join("\n");
+          } else {
+            summaryText = "";
+          }
+          if (summaryText) {
+            content.push({
+              type: "thinking" /* THINKING */,
+              thinking: summaryText,
+              persistInHistory: false
+            });
+          }
         }
       }
     }
@@ -18388,10 +18621,20 @@ var OpenAIResponsesConverter = class {
         }
       ],
       output_text: outputText,
+      // Extract thinking text from content for convenience field
+      ...(() => {
+        const thinkingTexts = content.filter((c) => c.type === "thinking" /* THINKING */).map((c) => c.thinking).filter(Boolean);
+        return thinkingTexts.length > 0 ? { thinking: thinkingTexts.join("\n") } : {};
+      })(),
       usage: {
         input_tokens: response.usage?.input_tokens || 0,
         output_tokens: response.usage?.output_tokens || 0,
-        total_tokens: response.usage?.total_tokens || 0
+        total_tokens: response.usage?.total_tokens || 0,
+        ...response.usage?.output_tokens_details?.reasoning_tokens != null && {
+          output_tokens_details: {
+            reasoning_tokens: response.usage.output_tokens_details.reasoning_tokens
+          }
+        }
       }
     };
   }
@@ -18496,6 +18739,8 @@ var StreamEventType = /* @__PURE__ */ ((StreamEventType2) => {
   StreamEventType2["TOOL_EXECUTION_START"] = "response.tool_execution.start";
   StreamEventType2["TOOL_EXECUTION_DONE"] = "response.tool_execution.done";
   StreamEventType2["ITERATION_COMPLETE"] = "response.iteration.complete";
+  StreamEventType2["REASONING_DELTA"] = "response.reasoning.delta";
+  StreamEventType2["REASONING_DONE"] = "response.reasoning.done";
   StreamEventType2["RESPONSE_COMPLETE"] = "response.complete";
   StreamEventType2["ERROR"] = "response.error";
   return StreamEventType2;
@@ -18515,6 +18760,12 @@ function isToolCallArgumentsDelta(event) {
 function isToolCallArgumentsDone(event) {
   return event.type === "response.tool_call_arguments.done" /* TOOL_CALL_ARGUMENTS_DONE */;
 }
+function isReasoningDelta(event) {
+  return event.type === "response.reasoning.delta" /* REASONING_DELTA */;
+}
+function isReasoningDone(event) {
+  return event.type === "response.reasoning.done" /* REASONING_DONE */;
+}
 function isResponseComplete(event) {
   return event.type === "response.complete" /* RESPONSE_COMPLETE */;
 }
@@ -18532,6 +18783,8 @@ var OpenAIResponsesStreamConverter = class {
     let sequenceNumber = 0;
     const activeItems = /* @__PURE__ */ new Map();
     const toolCallBuffers = /* @__PURE__ */ new Map();
+    const reasoningBuffers = /* @__PURE__ */ new Map();
+    const reasoningDoneEmitted = /* @__PURE__ */ new Set();
     for await (const event of stream) {
       if (process.env.DEBUG_OPENAI) {
         console.error("[DEBUG] Responses API event:", event.type);
@@ -18553,6 +18806,12 @@ var OpenAIResponsesStreamConverter = class {
           activeItems.set(addedEvent.output_index.toString(), {
             type: item.type
           });
+          if (item.type === "reasoning") {
+            activeItems.set(addedEvent.output_index.toString(), {
+              type: "reasoning"
+            });
+            reasoningBuffers.set(addedEvent.output_index.toString(), []);
+          }
           if (item.type === "function_call") {
             const functionCall = item;
             const toolCallId = functionCall.call_id;
@@ -18610,9 +18869,53 @@ var OpenAIResponsesStreamConverter = class {
           }
           break;
         }
+        case "response.reasoning_summary_text.delta":
+        case "response.reasoning_text.delta": {
+          const reasoningEvent = event;
+          const outputIdx = reasoningEvent.output_index?.toString();
+          const buffer = outputIdx ? reasoningBuffers.get(outputIdx) : void 0;
+          if (buffer) {
+            buffer.push(reasoningEvent.delta || "");
+          }
+          yield {
+            type: "response.reasoning.delta" /* REASONING_DELTA */,
+            response_id: responseId,
+            item_id: reasoningEvent.item_id || `reasoning_${responseId}`,
+            delta: reasoningEvent.delta || "",
+            sequence_number: sequenceNumber++
+          };
+          break;
+        }
+        case "response.reasoning_text.done": {
+          const doneEvent = event;
+          const outputIdx = doneEvent.output_index.toString();
+          const rBuf = reasoningBuffers.get(outputIdx);
+          const thinkingText = rBuf ? rBuf.join("") : doneEvent.text || "";
+          reasoningDoneEmitted.add(outputIdx);
+          yield {
+            type: "response.reasoning.done" /* REASONING_DONE */,
+            response_id: responseId,
+            item_id: doneEvent.item_id || `reasoning_${responseId}`,
+            thinking: thinkingText
+          };
+          break;
+        }
         case "response.output_item.done": {
           const doneEvent = event;
           const item = doneEvent.item;
+          if (item.type === "reasoning") {
+            const outputIdx = doneEvent.output_index.toString();
+            if (!reasoningDoneEmitted.has(outputIdx)) {
+              const rBuf = reasoningBuffers.get(outputIdx);
+              const thinkingText = rBuf ? rBuf.join("") : "";
+              yield {
+                type: "response.reasoning.done" /* REASONING_DONE */,
+                response_id: responseId,
+                item_id: item.id || `reasoning_${responseId}`,
+                thinking: thinkingText
+              };
+            }
+          }
           if (item.type === "function_call") {
             const functionCall = item;
             const buffer = toolCallBuffers.get(functionCall.call_id);
@@ -18644,7 +18947,12 @@ var OpenAIResponsesStreamConverter = class {
             usage: {
               input_tokens: response.usage?.input_tokens || 0,
               output_tokens: response.usage?.output_tokens || 0,
-              total_tokens: response.usage?.total_tokens || 0
+              total_tokens: response.usage?.total_tokens || 0,
+              ...response.usage?.output_tokens_details?.reasoning_tokens != null && {
+                output_tokens_details: {
+                  reasoning_tokens: response.usage.output_tokens_details.reasoning_tokens
+                }
+              }
             },
             iterations: 1
           };
@@ -18685,6 +18993,26 @@ function resolveMaxContextTokens(model, fallback) {
   return info ? info.features.input.tokens : fallback;
 }
 
+// src/infrastructure/providers/shared/validateThinkingConfig.ts
+function validateThinkingConfig(thinking) {
+  if (!thinking.enabled) return;
+  if (thinking.budgetTokens !== void 0) {
+    if (typeof thinking.budgetTokens !== "number" || thinking.budgetTokens < 1) {
+      throw new Error(
+        `Invalid thinking budgetTokens: ${thinking.budgetTokens}. Must be a positive number.`
+      );
+    }
+  }
+  if (thinking.effort !== void 0) {
+    const validEfforts = ["low", "medium", "high"];
+    if (!validEfforts.includes(thinking.effort)) {
+      throw new Error(
+        `Invalid thinking effort: '${thinking.effort}'. Must be one of: ${validEfforts.join(", ")}`
+      );
+    }
+  }
+}
+
 // src/infrastructure/providers/openai/OpenAITextProvider.ts
 var OpenAITextProvider = class extends BaseTextProvider {
   name = "openai";
@@ -18752,6 +19080,7 @@ var OpenAITextProvider = class extends BaseTextProvider {
           },
           ...options.metadata && { metadata: options.metadata }
         };
+        this.applyReasoningConfig(params, options);
         const response = await this.client.responses.create(params);
         return this.converter.convertResponse(response);
       } catch (error) {
@@ -18793,6 +19122,7 @@ var OpenAITextProvider = class extends BaseTextProvider {
         ...options.metadata && { metadata: options.metadata },
         stream: true
       };
+      this.applyReasoningConfig(params, options);
       const stream = await this.client.responses.create(params);
       yield* this.streamConverter.convertStream(stream);
     } catch (error) {
@@ -18814,6 +19144,27 @@ var OpenAITextProvider = class extends BaseTextProvider {
       maxOutputTokens: 16384
     });
   }
+  /**
+   * List available models from the OpenAI API
+   */
+  async listModels() {
+    const models = [];
+    for await (const model of this.client.models.list()) {
+      models.push(model.id);
+    }
+    return models.sort();
+  }
+  /**
+   * Apply reasoning config from unified thinking option to request params
+   */
+  applyReasoningConfig(params, options) {
+    if (options.thinking?.enabled) {
+      validateThinkingConfig(options.thinking);
+      params.reasoning = {
+        effort: options.thinking.effort || "medium"
+      };
+    }
+  }
   /**
    * Handle OpenAI-specific errors
    */
@@ -18856,6 +19207,7 @@ function buildLLMResponse(options) {
     }
   ];
   const outputText = extractTextFromContent(content);
+  const thinking = extractThinkingFromContent(content);
   return {
     id: responseId,
     object: "response",
@@ -18864,6 +19216,7 @@ function buildLLMResponse(options) {
     model,
     output,
     output_text: outputText,
+    ...thinking && { thinking },
     usage: {
       input_tokens: usage.inputTokens,
       output_tokens: usage.outputTokens,
@@ -18876,6 +19229,10 @@ function extractTextFromContent(content) {
     (c) => c.type === "output_text" /* OUTPUT_TEXT */
   ).map((c) => c.text).join("\n");
 }
+function extractThinkingFromContent(content) {
+  const thinkingTexts = content.filter((c) => c.type === "thinking" /* THINKING */).map((c) => c.thinking).filter(Boolean);
+  return thinkingTexts.length > 0 ? thinkingTexts.join("\n") : void 0;
+}
 function createTextContent(text) {
   return {
     type: "output_text" /* OUTPUT_TEXT */,
@@ -19125,7 +19482,15 @@ var AnthropicConverter = class extends BaseConverter {
     if (tools && tools.length > 0) {
       params.tools = tools;
     }
-    if (options.temperature !== void 0) {
+    if (options.thinking?.enabled) {
+      validateThinkingConfig(options.thinking);
+      const budgetTokens = options.thinking.budgetTokens || 1e4;
+      params.thinking = {
+        type: "enabled",
+        budget_tokens: budgetTokens
+      };
+      params.temperature = 1;
+    } else if (options.temperature !== void 0) {
       params.temperature = options.temperature;
     }
     return params;
@@ -19171,6 +19536,14 @@ var AnthropicConverter = class extends BaseConverter {
         content.push(this.createText(block.text));
       } else if (block.type === "tool_use") {
         content.push(this.createToolUse(block.id, block.name, block.input));
+      } else if (block.type === "thinking") {
+        const thinkingBlock = block;
+        content.push({
+          type: "thinking" /* THINKING */,
+          thinking: thinkingBlock.thinking || "",
+          signature: thinkingBlock.signature,
+          persistInHistory: true
+        });
       }
     }
     return content;
@@ -19249,6 +19622,17 @@ var AnthropicConverter = class extends BaseConverter {
           });
           break;
         }
+        case "thinking" /* THINKING */: {
+          const thinkingContent = c;
+          if (thinkingContent.signature) {
+            blocks.push({
+              type: "thinking",
+              thinking: thinkingContent.thinking,
+              signature: thinkingContent.signature
+            });
+          }
+          break;
+        }
       }
     }
     if (blocks.length === 1 && blocks[0]?.type === "text") {
@@ -19381,6 +19765,8 @@ var BaseStreamConverter = class {
   usage = { inputTokens: 0, outputTokens: 0 };
   /** Buffers for accumulating tool call arguments */
   toolCallBuffers = /* @__PURE__ */ new Map();
+  /** Buffer for accumulating reasoning/thinking content */
+  reasoningBuffer = "";
   // ==========================================================================
   // Public API
   // ==========================================================================
@@ -19415,6 +19801,7 @@ var BaseStreamConverter = class {
     this.sequenceNumber = 0;
     this.usage = { inputTokens: 0, outputTokens: 0 };
     this.toolCallBuffers.clear();
+    this.reasoningBuffer = "";
   }
   /**
    * Reset converter state for a new stream
@@ -19469,6 +19856,33 @@ var BaseStreamConverter = class {
       sequence_number: this.nextSequence()
     };
   }
+  /**
+   * Create REASONING_DELTA event and accumulate reasoning buffer
+   */
+  emitReasoningDelta(delta, itemId) {
+    this.reasoningBuffer += delta;
+    return {
+      type: "response.reasoning.delta" /* REASONING_DELTA */,
+      response_id: this.responseId,
+      item_id: itemId || `reasoning_${this.responseId}`,
+      delta,
+      sequence_number: this.nextSequence()
+    };
+  }
+  /**
+   * Create REASONING_DONE event with accumulated reasoning
+   */
+  emitReasoningDone(itemId) {
+    const id = itemId || `reasoning_${this.responseId}`;
+    const thinking = this.reasoningBuffer;
+    this.reasoningBuffer = "";
+    return {
+      type: "response.reasoning.done" /* REASONING_DONE */,
+      response_id: this.responseId,
+      item_id: id,
+      thinking
+    };
+  }
   /**
    * Create TOOL_CALL_START event
    */
@@ -19613,7 +20027,10 @@ var AnthropicStreamConverter = class extends BaseStreamConverter {
   handleContentBlockStart(event) {
     const index = event.index;
     const block = event.content_block;
-    if (block.type === "text") {
+    if (block.type === "thinking") {
+      this.contentBlockIndex.set(index, { type: "thinking" });
+      return [];
+    } else if (block.type === "text") {
       this.contentBlockIndex.set(index, { type: "text" });
       return [];
     } else if (block.type === "tool_use") {
@@ -19634,7 +20051,12 @@ var AnthropicStreamConverter = class extends BaseStreamConverter {
     const delta = event.delta;
     const blockInfo = this.contentBlockIndex.get(index);
     if (!blockInfo) return [];
-    if (delta.type === "text_delta") {
+    if (delta.type === "thinking_delta") {
+      const thinkingDelta = delta;
+      return [
+        this.emitReasoningDelta(thinkingDelta.thinking || "", `thinking_${this.responseId}`)
+      ];
+    } else if (delta.type === "text_delta") {
       return [
         this.emitTextDelta(delta.text, {
           itemId: `msg_${this.responseId}`,
@@ -19654,6 +20076,9 @@ var AnthropicStreamConverter = class extends BaseStreamConverter {
     const index = event.index;
     const blockInfo = this.contentBlockIndex.get(index);
     if (!blockInfo) return [];
+    if (blockInfo.type === "thinking") {
+      return [this.emitReasoningDone(`thinking_${this.responseId}`)];
+    }
     if (blockInfo.type === "tool_use") {
       return [this.emitToolCallArgsDone(blockInfo.id || "", blockInfo.name)];
     }
@@ -19752,6 +20177,16 @@ var AnthropicTextProvider = class extends BaseTextProvider {
     caps.supportsJSONSchema = false;
     return caps;
   }
+  /**
+   * List available models from the Anthropic API
+   */
+  async listModels() {
+    const models = [];
+    for await (const model of this.client.models.list()) {
+      models.push(model.id);
+    }
+    return models.sort();
+  }
   /**
    * Handle Anthropic-specific errors
    */
@@ -19930,6 +20365,11 @@ var GoogleConverter = class {
       request.generationConfig.thinkingConfig = {
         thinkingLevel: options.vendorOptions.thinkingLevel
       };
+    } else if (options.thinking?.enabled) {
+      validateThinkingConfig(options.thinking);
+      request.generationConfig.thinkingConfig = {
+        thinkingBudget: options.thinking.budgetTokens || 8192
+      };
     }
     if (tools && tools.length > 0) {
       request.generationConfig.allowCodeExecution = false;
@@ -20145,7 +20585,13 @@ var GoogleConverter = class {
   convertGeminiPartsToContent(parts) {
     const content = [];
     for (const part of parts) {
-      if ("text" in part && part.text) {
+      if ("thought" in part && part.thought === true && "text" in part && part.text) {
+        content.push({
+          type: "thinking" /* THINKING */,
+          thinking: part.text,
+          persistInHistory: false
+        });
+      } else if ("text" in part && part.text) {
         content.push(createTextContent(part.text));
       } else if ("functionCall" in part && part.functionCall) {
         const toolId = generateToolCallId("google");
@@ -20223,6 +20669,8 @@ var GoogleStreamConverter = class {
   isFirst = true;
   toolCallBuffers = /* @__PURE__ */ new Map();
   hadToolCalls = false;
+  reasoningBuffer = "";
+  wasThinking = false;
   // External storage for thought signatures (shared with GoogleConverter)
   thoughtSignatureStorage = null;
   // External storage for tool call ID → name mapping (shared with GoogleConverter)
@@ -20250,6 +20698,8 @@ var GoogleStreamConverter = class {
     this.isFirst = true;
     this.toolCallBuffers.clear();
     this.hadToolCalls = false;
+    this.reasoningBuffer = "";
+    this.wasThinking = false;
     let lastUsage = {
       input_tokens: 0,
       output_tokens: 0,
@@ -20275,6 +20725,16 @@ var GoogleStreamConverter = class {
         yield event;
       }
     }
+    if (this.wasThinking && this.reasoningBuffer) {
+      yield {
+        type: "response.reasoning.done" /* REASONING_DONE */,
+        response_id: this.responseId,
+        item_id: `thinking_${this.responseId}`,
+        thinking: this.reasoningBuffer
+      };
+      this.reasoningBuffer = "";
+      this.wasThinking = false;
+    }
     if (this.toolCallBuffers.size > 0) {
       for (const [toolCallId, buffer] of this.toolCallBuffers) {
         yield {
@@ -20314,7 +20774,28 @@ var GoogleStreamConverter = class {
     const candidate = chunk.candidates?.[0];
     if (!candidate?.content?.parts) return events;
     for (const part of candidate.content.parts) {
-      if (part.text) {
+      const isThought = "thought" in part && part.thought === true;
+      if (isThought && part.text) {
+        this.wasThinking = true;
+        this.reasoningBuffer += part.text;
+        events.push({
+          type: "response.reasoning.delta" /* REASONING_DELTA */,
+          response_id: this.responseId,
+          item_id: `thinking_${this.responseId}`,
+          delta: part.text,
+          sequence_number: this.sequenceNumber++
+        });
+      } else if (part.text) {
+        if (this.wasThinking) {
+          this.wasThinking = false;
+          events.push({
+            type: "response.reasoning.done" /* REASONING_DONE */,
+            response_id: this.responseId,
+            item_id: `thinking_${this.responseId}`,
+            thinking: this.reasoningBuffer
+          });
+          this.reasoningBuffer = "";
+        }
         events.push({
           type: "response.output_text.delta" /* OUTPUT_TEXT_DELTA */,
           response_id: this.responseId,
@@ -20413,6 +20894,8 @@ var GoogleStreamConverter = class {
     this.isFirst = true;
     this.toolCallBuffers.clear();
     this.hadToolCalls = false;
+    this.reasoningBuffer = "";
+    this.wasThinking = false;
   }
   /**
    * Reset converter state for a new stream
@@ -20542,6 +21025,18 @@ var GoogleTextProvider = class extends BaseTextProvider {
       maxOutputTokens: 65536
     });
   }
+  /**
+   * List available models from the Google Gemini API
+   */
+  async listModels() {
+    const models = [];
+    const pager = await this.client.models.list();
+    for await (const model of pager) {
+      const name = model.name?.replace(/^models\//, "") ?? "";
+      if (name) models.push(name);
+    }
+    return models.sort();
+  }
   /**
    * Handle Google-specific errors
    */
@@ -20649,6 +21144,18 @@ var VertexAITextProvider = class extends BaseTextProvider {
       maxOutputTokens: 65536
     });
   }
+  /**
+   * List available models from the Vertex AI API
+   */
+  async listModels() {
+    const models = [];
+    const pager = await this.client.models.list();
+    for await (const model of pager) {
+      const name = model.name?.replace(/^models\//, "") ?? "";
+      if (name) models.push(name);
+    }
+    return models.sort();
+  }
   /**
    * Handle Vertex AI-specific errors
    */
@@ -20694,6 +21201,23 @@ var GenericOpenAIProvider = class extends OpenAITextProvider {
       };
     }
   }
+  /**
+   * Override API key validation for generic providers.
+   * Services like Ollama don't require authentication, so accept any key including mock/placeholder keys.
+   */
+  validateApiKey() {
+    return { isValid: true };
+  }
+  /**
+   * Override listModels for error safety — some OpenAI-compatible APIs may not support /v1/models
+   */
+  async listModels() {
+    try {
+      return await super.listModels();
+    } catch {
+      return [];
+    }
+  }
   /**
    * Override model capabilities for generic providers (registry-driven with conservative defaults)
    */
@@ -21138,6 +21662,34 @@ var BaseAgent = class extends eventemitter3.EventEmitter {
       return tool.definition;
     });
   }
+  // ===== Model Discovery =====
+  /**
+   * List available models from the provider's API.
+   * Useful for discovering models dynamically (e.g., Ollama local models).
+   */
+  async listModels() {
+    return this._provider.listModels();
+  }
+  // ===== Snapshot / Inspection =====
+  /**
+   * Get a complete, serializable snapshot of the agent's context state.
+   *
+   * Convenience method that auto-wires tool usage stats from ToolManager.
+   * Used by UI "Look Inside" panels.
+   */
+  async getSnapshot() {
+    const stats = this._agentContext.tools.getStats();
+    return this._agentContext.getSnapshot({ mostUsed: stats.mostUsed });
+  }
+  /**
+   * Get a human-readable breakdown of the prepared context.
+   *
+   * Convenience method that delegates to AgentContextNextGen.
+   * Used by "View Full Context" UI panels.
+   */
+  async getViewContext() {
+    return this._agentContext.getViewContext();
+  }
   // ===== Direct LLM Access (Bypasses AgentContext) =====
   /**
    * Get the provider for LLM calls.
@@ -21901,6 +22453,8 @@ var StreamState = class {
   createdAt;
   // Text accumulation: item_id -> text chunks
   textBuffers;
+  // Reasoning accumulation: item_id -> reasoning chunks
+  reasoningBuffers;
   // Tool call accumulation: tool_call_id -> buffer
   toolCallBuffers;
   // Completed tool calls
@@ -21922,6 +22476,7 @@ var StreamState = class {
     this.model = model;
     this.createdAt = createdAt || Date.now();
     this.textBuffers = /* @__PURE__ */ new Map();
+    this.reasoningBuffers = /* @__PURE__ */ new Map();
     this.toolCallBuffers = /* @__PURE__ */ new Map();
     this.completedToolCalls = [];
     this.toolResults = /* @__PURE__ */ new Map();
@@ -21965,6 +22520,39 @@ var StreamState = class {
     }
     return allText.join("");
   }
+  /**
+   * Accumulate reasoning delta for a specific item
+   */
+  accumulateReasoningDelta(itemId, delta) {
+    if (!this.reasoningBuffers.has(itemId)) {
+      this.reasoningBuffers.set(itemId, []);
+    }
+    this.reasoningBuffers.get(itemId).push(delta);
+    this.totalChunks++;
+  }
+  /**
+   * Get complete accumulated reasoning for an item
+   */
+  getCompleteReasoning(itemId) {
+    const chunks = this.reasoningBuffers.get(itemId);
+    return chunks ? chunks.join("") : "";
+  }
+  /**
+   * Get all accumulated reasoning (all items concatenated)
+   */
+  getAllReasoning() {
+    const allReasoning = [];
+    for (const chunks of this.reasoningBuffers.values()) {
+      allReasoning.push(chunks.join(""));
+    }
+    return allReasoning.join("");
+  }
+  /**
+   * Check if stream has any accumulated reasoning
+   */
+  hasReasoning() {
+    return this.reasoningBuffers.size > 0;
+  }
   /**
    * Start accumulating tool call arguments
    */
@@ -22133,6 +22721,7 @@ var StreamState = class {
    */
   clear() {
     this.textBuffers.clear();
+    this.reasoningBuffers.clear();
     this.toolCallBuffers.clear();
     this.completedToolCalls = [];
     this.toolResults.clear();
@@ -22146,6 +22735,7 @@ var StreamState = class {
       model: this.model,
       createdAt: this.createdAt,
       textBuffers: new Map(this.textBuffers),
+      reasoningBuffers: new Map(this.reasoningBuffers),
       toolCallBuffers: new Map(this.toolCallBuffers),
       completedToolCalls: [...this.completedToolCalls],
       toolResults: new Map(this.toolResults),
@@ -22575,6 +23165,20 @@ var Agent = class _Agent extends BaseAgent {
   _addStreamingAssistantMessage(streamState, toolCalls) {
     const assistantText = streamState.getAllText();
     const assistantContent = [];
+    if (streamState.hasReasoning()) {
+      const reasoning = streamState.getAllReasoning();
+      if (reasoning) {
+        const isAnthropic = this.connector.vendor === Vendor.Anthropic;
+        assistantContent.push({
+          type: "thinking" /* THINKING */,
+          thinking: reasoning,
+          // Streaming doesn't carry Anthropic signatures, so signature is undefined here.
+          // Non-streaming responses (via convertResponse) capture signatures correctly.
+          signature: void 0,
+          persistInHistory: isAnthropic
+        });
+      }
+    }
     if (assistantText && assistantText.trim()) {
       assistantContent.push({
         type: "output_text" /* OUTPUT_TEXT */,
@@ -22813,6 +23417,7 @@ var Agent = class _Agent extends BaseAgent {
       tools: this.getEnabledToolDefinitions(),
       tool_choice: "auto",
       temperature: this._config.temperature,
+      thinking: this._config.thinking,
       vendorOptions: this._config.vendorOptions
     };
     const beforeLLM = await this.hookManager.executeHooks("before:llm", {
@@ -22878,6 +23483,7 @@ var Agent = class _Agent extends BaseAgent {
       tools: this.getEnabledToolDefinitions(),
       tool_choice: "auto",
       temperature: this._config.temperature,
+      thinking: this._config.thinking,
       vendorOptions: this._config.vendorOptions
     };
     await this.hookManager.executeHooks("before:llm", {
@@ -22895,7 +23501,9 @@ var Agent = class _Agent extends BaseAgent {
     });
     try {
       for await (const event of this._provider.streamGenerate(generateOptions)) {
-        if (event.type === "response.output_text.delta" /* OUTPUT_TEXT_DELTA */) {
+        if (isReasoningDelta(event)) {
+          streamState.accumulateReasoningDelta(event.item_id, event.delta);
+        } else if (event.type === "response.output_text.delta" /* OUTPUT_TEXT_DELTA */) {
           streamState.accumulateTextDelta(event.item_id, event.delta);
         } else if (event.type === "response.tool_call.start" /* TOOL_CALL_START */) {
           streamState.startToolCall(event.tool_call_id, event.tool_name);
@@ -23931,6 +24539,12 @@ function defaultTaskPrompt(task) {
     }
     parts.push("");
   }
+  if (task.dependsOn.length > 0) {
+    parts.push("Note: Results from prerequisite tasks are available in your live context.");
+    parts.push("Small results appear directly; larger results are in working memory \u2014 use memory_retrieve to access them.");
+    parts.push("Review the plan overview and dependency results before starting.");
+    parts.push("");
+  }
   parts.push("After completing the work, store key results in memory once, then respond with a text summary (no more tool calls).");
   return parts.join("\n");
 }
@@ -24014,6 +24628,127 @@ async function collectValidationContext(agent, responseText) {
     toolCallLog
   };
 }
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function buildPlanOverview(execution, definition, currentTaskId) {
+  const parts = [];
+  const progress = execution.progress ?? 0;
+  parts.push(`Routine: ${definition.name}`);
+  if (definition.description) {
+    parts.push(`Goal: ${definition.description}`);
+  }
+  parts.push(`Progress: ${Math.round(progress * 100)}%`);
+  parts.push("");
+  parts.push("Tasks:");
+  for (const task of execution.plan.tasks) {
+    let statusIcon;
+    switch (task.status) {
+      case "completed":
+        statusIcon = "[x]";
+        break;
+      case "in_progress":
+        statusIcon = "[>]";
+        break;
+      case "failed":
+        statusIcon = "[!]";
+        break;
+      case "skipped":
+        statusIcon = "[-]";
+        break;
+      default:
+        statusIcon = "[ ]";
+    }
+    let line = `${statusIcon} ${task.name}`;
+    if (task.dependsOn.length > 0) {
+      const depNames = task.dependsOn.map((depId) => execution.plan.tasks.find((t) => t.id === depId)?.name ?? depId).join(", ");
+      line += ` (after: ${depNames})`;
+    }
+    if (task.id === currentTaskId) {
+      line += "  \u2190 CURRENT";
+    }
+    parts.push(line);
+  }
+  return parts.join("\n");
+}
+async function injectRoutineContext(agent, execution, definition, currentTask) {
+  const icmPlugin = agent.context.getPlugin("in_context_memory");
+  const wmPlugin = agent.context.memory;
+  if (!icmPlugin && !wmPlugin) {
+    exports.logger.warn("injectRoutineContext: No ICM or WM plugin available \u2014 skipping context injection");
+    return;
+  }
+  const planOverview = buildPlanOverview(execution, definition, currentTask.id);
+  if (icmPlugin) {
+    icmPlugin.set("__routine_plan", "Routine plan overview with task statuses", planOverview, "high");
+  }
+  if (icmPlugin) {
+    for (const entry of icmPlugin.list()) {
+      if (entry.key.startsWith("__dep_result_") || entry.key === "__routine_deps") {
+        icmPlugin.delete(entry.key);
+      }
+    }
+  }
+  if (wmPlugin) {
+    const { entries: wmEntries } = await wmPlugin.query();
+    for (const entry of wmEntries) {
+      if (entry.key.startsWith("__dep_result_") || entry.key.startsWith("findings/__dep_result_")) {
+        await wmPlugin.delete(entry.key);
+      }
+    }
+  }
+  if (currentTask.dependsOn.length === 0) return;
+  const inContextDeps = [];
+  const workingMemoryDeps = [];
+  for (const depId of currentTask.dependsOn) {
+    const depTask = execution.plan.tasks.find((t) => t.id === depId);
+    if (!depTask?.result?.output) continue;
+    const output = typeof depTask.result.output === "string" ? depTask.result.output : JSON.stringify(depTask.result.output);
+    const tokens = estimateTokens(output);
+    const depKey = `__dep_result_${depId}`;
+    const depLabel = `Result from task "${depTask.name}"`;
+    if (tokens < 5e3 && icmPlugin) {
+      icmPlugin.set(depKey, depLabel, output, "high");
+      inContextDeps.push(depTask.name);
+    } else if (wmPlugin) {
+      await wmPlugin.store(depKey, depLabel, output, { tier: "findings" });
+      workingMemoryDeps.push(depTask.name);
+    } else if (icmPlugin) {
+      const truncated = output.slice(0, 2e4) + "\n... (truncated, full result not available)";
+      icmPlugin.set(depKey, depLabel, truncated, "high");
+      inContextDeps.push(depTask.name + " (truncated)");
+    }
+  }
+  if (icmPlugin && (inContextDeps.length > 0 || workingMemoryDeps.length > 0)) {
+    const summaryParts = ["Dependency results available:"];
+    if (inContextDeps.length > 0) {
+      summaryParts.push(`In context (visible now): ${inContextDeps.join(", ")}`);
+    }
+    if (workingMemoryDeps.length > 0) {
+      summaryParts.push(`In working memory (use memory_retrieve): ${workingMemoryDeps.join(", ")}`);
+    }
+    icmPlugin.set("__routine_deps", "Dependency results location guide", summaryParts.join("\n"), "high");
+  }
+}
+async function cleanupRoutineContext(agent) {
+  const icmPlugin = agent.context.getPlugin("in_context_memory");
+  const wmPlugin = agent.context.memory;
+  if (icmPlugin) {
+    for (const entry of icmPlugin.list()) {
+      if (entry.key.startsWith("__routine_") || entry.key.startsWith("__dep_result_")) {
+        icmPlugin.delete(entry.key);
+      }
+    }
+  }
+  if (wmPlugin) {
+    const { entries: wmEntries } = await wmPlugin.query();
+    for (const entry of wmEntries) {
+      if (entry.key.startsWith("__dep_result_") || entry.key.startsWith("findings/__dep_result_")) {
+        await wmPlugin.delete(entry.key);
+      }
+    }
+  }
+}
 async function validateTaskCompletion(agent, task, responseText, validationPromptBuilder) {
   const hasExplicitValidation = task.validation?.skipReflection === false && task.validation?.completionCriteria && task.validation.completionCriteria.length > 0;
   if (!hasExplicitValidation) {
@@ -24150,7 +24885,7 @@ async function executeRoutine(options) {
       execution.lastUpdatedAt = Date.now();
       onTaskStarted?.(execution.plan.tasks[taskIndex], execution);
       let taskCompleted = false;
-      const maxTaskIterations = task.execution?.maxIterations ?? 15;
+      const maxTaskIterations = task.execution?.maxIterations ?? 50;
       const iterationLimiter = async (ctx) => {
         if (ctx.iteration >= maxTaskIterations) {
           agent.cancel(`Task "${task.name}" exceeded max iterations (${maxTaskIterations})`);
@@ -24159,6 +24894,7 @@ async function executeRoutine(options) {
       };
       agent.registerHook("pause:check", iterationLimiter);
       const getTask = () => execution.plan.tasks[taskIndex];
+      await injectRoutineContext(agent, execution, definition, getTask());
       while (!taskCompleted) {
         try {
           const taskPrompt = buildTaskPrompt(getTask());
@@ -24261,6 +24997,10 @@ async function executeRoutine(options) {
     );
     return execution;
   } finally {
+    try {
+      await cleanupRoutineContext(agent);
+    } catch {
+    }
     for (const { name, hook } of registeredHooks) {
       try {
         agent.unregisterHook(name, hook);
@@ -38788,6 +39528,42 @@ var StreamHelpers = class {
     }
     return chunks.join("");
   }
+  /**
+   * Get only reasoning/thinking deltas from stream
+   * Filters out all other event types
+   */
+  static async *thinkingOnly(stream) {
+    for await (const event of stream) {
+      if (isReasoningDelta(event)) {
+        yield event.delta;
+      }
+    }
+  }
+  /**
+   * Get both text and thinking deltas from stream
+   * Yields tagged objects so consumers can distinguish them
+   */
+  static async *textAndThinking(stream) {
+    for await (const event of stream) {
+      if (isOutputTextDelta(event)) {
+        yield { type: "text", delta: event.delta };
+      } else if (isReasoningDelta(event)) {
+        yield { type: "thinking", delta: event.delta };
+      }
+    }
+  }
+  /**
+   * Accumulate all thinking/reasoning content from stream into a single string
+   */
+  static async accumulateThinking(stream) {
+    const chunks = [];
+    for await (const event of stream) {
+      if (isReasoningDelta(event)) {
+        chunks.push(event.delta);
+      }
+    }
+    return chunks.join("");
+  }
   /**
    * Buffer stream events into batches
    */
@@ -38847,6 +39623,11 @@ var StreamHelpers = class {
       case "response.output_text.delta" /* OUTPUT_TEXT_DELTA */:
         state.accumulateTextDelta(event.item_id, event.delta);
         break;
+      case "response.reasoning.delta" /* REASONING_DELTA */:
+        state.accumulateReasoningDelta(event.item_id, event.delta);
+        break;
+      case "response.reasoning.done" /* REASONING_DONE */:
+        break;
       case "response.tool_call.start" /* TOOL_CALL_START */:
         state.startToolCall(event.tool_call_id, event.tool_name);
         break;
@@ -38877,21 +39658,36 @@ var StreamHelpers = class {
    */
   static reconstructLLMResponse(state) {
     const output = [];
+    const contentParts = [];
+    let thinkingText;
+    if (state.hasReasoning()) {
+      const reasoning = state.getAllReasoning();
+      if (reasoning) {
+        thinkingText = reasoning;
+        contentParts.push({
+          type: "thinking" /* THINKING */,
+          thinking: reasoning,
+          persistInHistory: false
+          // Vendor-agnostic default; caller can adjust
+        });
+      }
+    }
     if (state.hasText()) {
       const textContent = state.getAllText();
       if (textContent) {
-        output.push({
-          type: "message",
-          role: "assistant" /* ASSISTANT */,
-          content: [
-            {
-              type: "output_text" /* OUTPUT_TEXT */,
-              text: textContent
-            }
-          ]
+        contentParts.push({
+          type: "output_text" /* OUTPUT_TEXT */,
+          text: textContent
         });
       }
     }
+    if (contentParts.length > 0) {
+      output.push({
+        type: "message",
+        role: "assistant" /* ASSISTANT */,
+        content: contentParts
+      });
+    }
     const toolCalls = state.getCompletedToolCalls();
     if (toolCalls.length > 0) {
       const toolUseContent = toolCalls.map((tc) => ({
@@ -38920,6 +39716,7 @@ var StreamHelpers = class {
       model: state.model,
       output,
       output_text: outputText,
+      thinking: thinkingText,
       usage: state.usage
     };
   }
@@ -50368,6 +51165,7 @@ exports.findConnectorByServiceTypes = findConnectorByServiceTypes;
 exports.forPlan = forPlan;
 exports.forTasks = forTasks;
 exports.formatAttendees = formatAttendees;
+exports.formatPluginDisplayName = formatPluginDisplayName;
 exports.formatRecipients = formatRecipients;
 exports.generateEncryptionKey = generateEncryptionKey;
 exports.generateSimplePlan = generateSimplePlan;
@@ -50436,6 +51234,8 @@ exports.isErrorEvent = isErrorEvent;
 exports.isExcludedExtension = isExcludedExtension;
 exports.isKnownService = isKnownService;
 exports.isOutputTextDelta = isOutputTextDelta;
+exports.isReasoningDelta = isReasoningDelta;
+exports.isReasoningDone = isReasoningDone;
 exports.isResponseComplete = isResponseComplete;
 exports.isSimpleScope = isSimpleScope;
 exports.isStreamEvent = isStreamEvent;