@cuylabs/agent-core 0.6.0 → 0.8.0

package/dist/index.js

@@ -1,71 +1,27 @@
-import {
-  AgentTurnEngine,
-  ContextOverflowError,
-  DEFAULT_RETRY_CONFIG,
-  DoomLoopError,
-  LLM,
-  LLMError,
-  OUTPUT_TOKEN_MAX,
-  advanceAgentTurnState,
-  applyAgentWorkflowCommitResult,
-  applyAgentWorkflowModelStepResult,
-  applyAgentWorkflowToolBatchResult,
-  applyAgentWorkflowToolCallResult,
-  calculateDelay,
-  cloneAgentWorkflowTurnState,
-  commitOutput,
-  commitStep,
-  convertAgentMessagesToModelMessages,
-  createAgentTaskRunner,
-  createAgentTurnEngine,
-  createAgentTurnState,
-  createAgentTurnStepCommitBatch,
-  createAgentWorkflowTurnState,
-  createRetryHandler,
-  createRetryState,
-  defaultAgentTaskCheckpointStrategy,
-  failAgentTurnState,
-  failAgentWorkflowTurnState,
-  getErrorCategory,
-  getRetryDelay,
-  isRetryable,
-  isRetryableCategory,
-  planNextAgentWorkflowOperation,
-  prepareModelStep,
-  processStream,
-  recordAgentWorkflowReplayDecision,
-  restoreAgentWorkflowMessage,
-  restoreAgentWorkflowMessages,
-  runModelStep,
-  runToolBatch,
-  shouldRetry,
-  sleep,
-  snapshotAgentWorkflowMessage,
-  snapshotAgentWorkflowMessages,
-  withRetry
-} from "./chunk-3C4VKG4P.js";
-import {
-  createSkillResourceTool,
-  createSkillTool,
-  createSkillTools
-} from "./chunk-YUUJK53A.js";
 import {
   FileStorage,
   MemoryStorage,
   STORAGE_VERSION,
   SessionManager,
+  buildEntryPath,
   buildMessagesFromEntries,
   configureDefaultSessionManager,
+  createMessageEntry,
+  createMetadataEntry,
   deserializeMessage,
+  extractSessionInfo,
   generateEntryId,
   getDataDir,
   getDefaultSessionManager,
+  getGitRootHash,
   getLeafId,
+  getProjectId,
   getProjectSessionsDir,
   getSessionsDir,
   parseJSONL,
   serializeMessage,
-  toJSONL
+  toJSONL,
+  toJSONLBatch
 } from "./chunk-BDBZ3SLK.js";
 import {
   DEFAULT_MAX_CONCURRENT,
@@ -78,20 +34,6 @@ import {
   ToolRegistry,
   defaultRegistry
 } from "./chunk-SDSBEQXG.js";
-import {
-  executeAgentToolCall
-} from "./chunk-FG4MD5MU.js";
-import {
-  MAX_BYTES,
-  MAX_LINES,
-  TRUNCATE_DIR,
-  TRUNCATE_GLOB,
-  Tool,
-  defineTool,
-  formatSize,
-  normalizeToolReplayPolicy,
-  truncateOutput
-} from "./chunk-P6YF7USR.js";
 import {
   TurnChangeTracker,
   clearCheckpoints,
@@ -99,43 +41,19 @@ import {
   createTurnTracker
 } from "./chunk-VBWWUHWI.js";
 import {
-  extractFilePathsFromArgs,
-  shouldCaptureBaseline,
-  withFileTracking
-} from "./chunk-VEKUXUVF.js";
-import {
-  ContextManager,
-  DEFAULT_CONTEXT_LIMITS,
-  estimateConversationTokens,
-  estimateMessageTokens,
-  estimateTokens,
-  findCutPoint,
-  generateSummary,
-  isContextOverflowing,
-  pruneContext,
-  pruneToolResults,
-  shouldPruneContext
-} from "./chunk-QAQADS4X.js";
-import {
-  createMCPManager,
-  defineServer,
-  httpServer,
-  sseServer,
-  stdioServer
-} from "./chunk-ZXAKHMWH.js";
-import {
-  ApprovalDeniedError,
-  ApprovalTimeoutError,
-  MiddlewareRunner,
-  approvalMiddleware,
-  createApprovalHandler,
-  createTelemetryConfig,
-  getToolRisk,
-  otelMiddleware
-} from "./chunk-O2ZCFQL6.js";
-import {
-  createResolver
-} from "./chunk-6TDTQJ4P.js";
+  Presets,
+  applyPreset,
+  careful,
+  code,
+  createPreset,
+  explore,
+  filterTools,
+  mergePresets,
+  plan,
+  quick,
+  review,
+  watch
+} from "./chunk-CAA7FHIH.js";
 import {
   DEFAULT_INSTRUCTION_PATTERNS,
   DEFAULT_MAX_DEPTH,
@@ -158,6 +76,58 @@ import {
   loadGlobalInstructions,
   summarizeEnvironment
 } from "./chunk-IVUJDISU.js";
+import {
+  AgentTurnEngine,
+  ContextOverflowError,
+  DoomLoopError,
+  advanceAgentTurnState,
+  applyAgentWorkflowCommitResult,
+  applyAgentWorkflowModelStepResult,
+  applyAgentWorkflowToolBatchResult,
+  applyAgentWorkflowToolCallResult,
+  cloneAgentWorkflowTurnState,
+  commitOutput,
+  commitStep,
+  convertAgentMessagesToModelMessages,
+  createAgentTaskRunner,
+  createAgentTurnEngine,
+  createAgentTurnState,
+  createAgentTurnStepCommitBatch,
+  createAgentWorkflowTurnState,
+  defaultAgentTaskCheckpointStrategy,
+  failAgentTurnState,
+  failAgentWorkflowTurnState,
+  planNextAgentWorkflowOperation,
+  prepareModelStep,
+  processStepStream,
+  processStream,
+  recordAgentWorkflowReplayDecision,
+  restoreAgentWorkflowMessage,
+  restoreAgentWorkflowMessages,
+  runModelStep,
+  runToolBatch,
+  snapshotAgentWorkflowMessage,
+  snapshotAgentWorkflowMessages
+} from "./chunk-4BDA7DQY.js";
+import {
+  LocalSignal
+} from "./chunk-KUVSERLJ.js";
+import {
+  createSkillResourceTool,
+  createSkillTool,
+  createSkillTools
+} from "./chunk-YUUJK53A.js";
+import {
+  MAX_BYTES,
+  MAX_LINES,
+  TRUNCATE_DIR,
+  TRUNCATE_GLOB,
+  Tool,
+  defineTool,
+  formatSize,
+  normalizeToolReplayPolicy,
+  truncateOutput
+} from "./chunk-P6YF7USR.js";
 import {
   DEFAULT_EXTERNAL_DIRS,
   DEFAULT_MAX_SCAN_DEPTH,
@@ -174,19 +144,126 @@ import {
   parseFrontmatter
 } from "./chunk-LRHOS4ZN.js";
 import {
+  ContextManager,
+  DEFAULT_CONTEXT_LIMITS,
+  PRUNE_PROTECTED_TOOLS,
+  estimateConversationTokens,
+  estimateMessageTokens,
+  estimateTokens,
+  findCutPoint,
+  generateSummary,
+  isContextOverflowing,
+  pruneContext,
+  pruneToolResults,
+  shouldPruneContext
+} from "./chunk-WWYYNWEW.js";
+import {
+  dockerHost,
+  localHost
+} from "./chunk-VNQBHPCT.js";
+import {
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  DEFAULT_RETRY_CONFIG,
+  Inference,
+  LLM,
+  OUTPUT_TOKEN_MAX,
+  buildToolSet,
+  calculateDelay,
+  createRetryHandler,
+  createRetryState,
+  shouldRetry,
+  sleep,
+  stream,
+  streamOnce,
+  streamStep,
+  withRetry
+} from "./chunk-N6HWIEEA.js";
+import {
+  executeAgentToolCall
+} from "./chunk-7VKQ4WPB.js";
+import {
+  extractFilePathsFromArgs,
+  shouldCaptureBaseline,
+  withFileTracking
+} from "./chunk-VEKUXUVF.js";
+import {
+  EXTENDED_LEVELS,
+  FIXED_LEVELS,
+  STANDARD_LEVELS,
+  buildAnthropicOptions,
+  buildBedrockOptions,
+  buildGoogleOptions,
+  buildGroqOptions,
+  buildOpenAIOptions,
+  buildOpenRouterOptions,
   buildReasoningOptions,
   buildReasoningOptionsSync,
+  buildXAIOptions,
+  getProviderOptionsKey,
   getReasoningConfig,
   getReasoningConfigSync,
+  shouldIncludeReasoningSummary,
   supportsReasoning,
   supportsReasoningSync
-} from "./chunk-X635CM2F.js";
+} from "./chunk-SQU2AJHO.js";
+import {
+  createScope,
+  currentScope,
+  restoreScope,
+  snapshotScope,
+  streamWithinScope,
+  withinScope
+} from "./chunk-N7P4PN3O.js";
+import {
+  LLMError,
+  getErrorCategory,
+  getRetryDelay,
+  isRetryable,
+  isRetryableCategory,
+  parseRetryDelay
+} from "./chunk-RZITT45F.js";
+import {
+  createMCPManager,
+  defineServer,
+  httpServer,
+  sseServer,
+  stdioServer
+} from "./chunk-ZXAKHMWH.js";
+import {
+  MiddlewareRunner,
+  approvalMiddleware,
+  createTelemetryConfig,
+  otelMiddleware,
+  promptCacheMiddleware
+} from "./chunk-YSLSEQ6B.js";
+import {
+  ApprovalDeniedError,
+  ApprovalTimeoutError,
+  createApprovalHandler,
+  getToolRisk
+} from "./chunk-BFM2YHNM.js";
 import {
+  CacheCapabilitySource,
+  CapabilityCache,
+  DEFAULT_RESOLVER_OPTIONS,
   ModelCapabilityResolver,
+  PatternCapabilitySource,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
+  SourcePriority,
+  applyCapabilityOverride,
   configureResolver,
+  createResolver,
+  extractModelId,
+  extractProvider,
+  findCapabilityOverride,
   getDefaultResolver,
-  getNetworkStatus
-} from "./chunk-QWFMX226.js";
+  getNetworkStatus,
+  getProviderCompatibility,
+  inferContextWindow,
+  inferProvider,
+  likelySupportsReasoning
+} from "./chunk-RFEKJKTO.js";
 import {
   getModelId,
   getProviderId
@@ -279,436 +356,179 @@ function accumulateUsage(current, next) {
 
 // src/agent/chat-loop/loop.ts
 async function* runChatLoop(deps) {
-  const {
-    sessionId,
-    message,
-    abort,
-    systemOverride,
-    sessions,
-    tools: toolRecord,
-    config,
-    turnTracker,
-    interventionCtrl,
-    middlewareRunner,
-    contextManager,
-    rememberedDoomLoopTools,
-    reasoningLevel,
-    promptBuilder,
-    host,
-    mcpTools,
-    toModelMessages,
-    setIsStreaming
-  } = deps;
-  const turnEngine = createAgentTurnEngine({
-    sessionId,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    getToolReplayPolicy: (toolName) => toolRecord[toolName] ? normalizeToolReplayPolicy(toolRecord[toolName].replayPolicy) : void 0
-  });
-  const applyCommitBatch = createChatLoopCommitBatchApplier({
-    turnEngine,
-    sessions,
-    middlewareRunner
-  });
-  yield* applyCommitBatch(
-    turnEngine.createInputCommit({
-      content: message,
-      system: systemOverride
-    }),
-    { emitMessages: true }
-  );
-  setIsStreaming(true);
-  const prevOnApplied = interventionCtrl.onApplied;
-  let chatUsage;
-  let chatError;
-  let chatOutput;
-  try {
-    if (middlewareRunner.hasMiddleware) {
-      await middlewareRunner.runChatStart(sessionId, message);
-    }
-    const systemPrompts = await buildChatSystemPrompts({
-      promptBuilder,
-      middlewareRunner,
-      systemOverride,
-      sessionId,
-      config,
-      tools: toolRecord
-    });
-    let step = 1;
-    let finalStepText = "";
-    let accumulatedUsage;
-    while (step <= config.maxSteps) {
-      const preparedStep = prepareModelStep({
+  yield* streamWithinScope(
+    {
+      kind: "turn",
+      name: "agent-turn",
+      sessionId: deps.sessionId
+    },
+    (async function* () {
+      const {
         sessionId,
-        step,
-        systemPrompts,
-        messages: sessions.getMessages(),
-        toModelMessages,
+        message,
         abort,
+        systemOverride,
+        sessions,
         tools: toolRecord,
-        mcpTools,
         config,
-        host,
         turnTracker,
-        intervention: interventionCtrl,
-        middleware: middlewareRunner,
-        reasoningLevel
-      });
-      const stepResult = yield* runModelStep({
-        preparedStep,
-        turnEngine,
-        applyCommitBatch,
-        rememberedDoomLoopTools
+        interventionCtrl,
+        middlewareRunner,
+        contextManager,
+        rememberedDoomLoopTools,
+        reasoningLevel,
+        promptBuilder,
+        host,
+        mcpTools,
+        toModelMessages,
+        setIsStreaming
+      } = deps;
+      const turnEngine = createAgentTurnEngine({
+        sessionId,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        getToolReplayPolicy: (toolName) => toolRecord[toolName] ? normalizeToolReplayPolicy(toolRecord[toolName].replayPolicy) : void 0
       });
-      accumulatedUsage = accumulateUsage(accumulatedUsage, stepResult.usage);
-      if (stepResult.error) {
-        chatError = stepResult.error;
-        return;
-      }
-      yield* commitStep({
-        step,
-        finishReason: stepResult.finishReason,
+      const applyCommitBatch = createChatLoopCommitBatchApplier({
         turnEngine,
-        applyCommitBatch
+        sessions,
+        middlewareRunner
       });
-      if (stepResult.finishReason === "tool-calls") {
-        if (step >= config.maxSteps) {
-          const maxStepsError = new Error(
-            `Maximum steps (${config.maxSteps}) reached before the turn produced a final response`
-          );
-          chatError = maxStepsError;
-          const statusEvent = { type: "status", status: "error" };
-          middlewareRunner.emitEvent(statusEvent);
-          yield statusEvent;
-          const errorEvent = { type: "error", error: maxStepsError };
-          middlewareRunner.emitEvent(errorEvent);
-          yield errorEvent;
-          return;
+      yield* applyCommitBatch(
+        turnEngine.createInputCommit({
+          content: message,
+          system: systemOverride
+        }),
+        { emitMessages: true }
+      );
+      setIsStreaming(true);
+      const prevOnApplied = interventionCtrl.onApplied;
+      let chatUsage;
+      let chatError;
+      let chatOutput;
+      try {
+        if (middlewareRunner.hasMiddleware) {
+          await middlewareRunner.runChatStart(sessionId, message);
+        }
+        const systemPrompts = await buildChatSystemPrompts({
+          promptBuilder,
+          middlewareRunner,
+          systemOverride,
+          sessionId,
+          config,
+          tools: toolRecord
+        });
+        let step = 1;
+        let finalStepText = "";
+        let accumulatedUsage;
+        while (step <= config.maxSteps) {
+          const preparedStep = prepareModelStep({
+            sessionId,
+            step,
+            systemPrompts,
+            messages: sessions.getMessages(),
+            toModelMessages,
+            abort,
+            tools: toolRecord,
+            mcpTools,
+            config,
+            host,
+            turnTracker,
+            intervention: interventionCtrl,
+            middleware: middlewareRunner,
+            reasoningLevel
+          });
+          const stepResult = yield* runModelStep({
+            preparedStep,
+            turnEngine,
+            applyCommitBatch,
+            rememberedDoomLoopTools
+          });
+          accumulatedUsage = accumulateUsage(accumulatedUsage, stepResult.usage);
+          if (stepResult.error) {
+            chatError = stepResult.error;
+            return;
+          }
+          yield* commitStep({
+            step,
+            finishReason: stepResult.finishReason,
+            turnEngine,
+            applyCommitBatch
+          });
+          if (stepResult.finishReason === "tool-calls") {
+            if (step >= config.maxSteps) {
+              const maxStepsError = new Error(
+                `Maximum steps (${config.maxSteps}) reached before the turn produced a final response`
+              );
+              chatError = maxStepsError;
+              const statusEvent = { type: "status", status: "error" };
+              middlewareRunner.emitEvent(statusEvent);
+              yield statusEvent;
+              const errorEvent = { type: "error", error: maxStepsError };
+              middlewareRunner.emitEvent(errorEvent);
+              yield errorEvent;
+              return;
+            }
+            step += 1;
+            continue;
+          }
+          finalStepText = stepResult.text;
+          break;
+        }
+        yield* commitOutput({
+          text: finalStepText,
+          usage: accumulatedUsage,
+          turnEngine,
+          applyCommitBatch
+        });
+        if (config.compaction?.auto !== false) {
+          const compactionEvents = await runAutoCompaction({
+            contextManager,
+            messages: sessions.getMessages()
+          });
+          for (const event of compactionEvents) {
+            yield event;
+          }
+        }
+        const turnSummary = await turnTracker.endTurn();
+        if (turnSummary.totalTracked > 0) {
+          yield {
+            type: "turn-summary",
+            turnId: turnSummary.turnId,
+            files: turnSummary.files.map((file) => ({
+              path: file.path,
+              type: file.type,
+              additions: file.additions,
+              deletions: file.deletions
+            })),
+            additions: turnSummary.additions,
+            deletions: turnSummary.deletions
+          };
+        }
+        chatUsage = accumulatedUsage;
+        chatOutput = finalStepText || void 0;
+        yield {
+          type: "complete",
+          usage: accumulatedUsage,
+          output: finalStepText || void 0
+        };
+      } catch (error) {
+        chatError = error instanceof Error ? error : new Error(String(error));
+        throw error;
+      } finally {
+        setIsStreaming(false);
+        interventionCtrl.onApplied = prevOnApplied;
+        if (middlewareRunner.hasMiddleware) {
+          await middlewareRunner.runChatEnd(sessionId, {
+            usage: chatUsage,
+            error: chatError,
+            output: chatOutput
+          });
         }
-        step += 1;
-        continue;
-      }
-      finalStepText = stepResult.text;
-      break;
-    }
-    yield* commitOutput({
-      text: finalStepText,
-      usage: accumulatedUsage,
-      turnEngine,
-      applyCommitBatch
-    });
-    if (config.compaction?.auto !== false) {
-      const compactionEvents = await runAutoCompaction({
-        contextManager,
-        messages: sessions.getMessages()
-      });
-      for (const event of compactionEvents) {
-        yield event;
       }
-    }
-    const turnSummary = await turnTracker.endTurn();
-    if (turnSummary.totalTracked > 0) {
-      yield {
-        type: "turn-summary",
-        turnId: turnSummary.turnId,
-        files: turnSummary.files.map((file) => ({
-          path: file.path,
-          type: file.type,
-          additions: file.additions,
-          deletions: file.deletions
-        })),
-        additions: turnSummary.additions,
-        deletions: turnSummary.deletions
-      };
-    }
-    chatUsage = accumulatedUsage;
-    chatOutput = finalStepText || void 0;
-    yield {
-      type: "complete",
-      usage: accumulatedUsage,
-      output: finalStepText || void 0
-    };
-  } catch (error) {
-    chatError = error instanceof Error ? error : new Error(String(error));
-    throw error;
-  } finally {
-    setIsStreaming(false);
-    interventionCtrl.onApplied = prevOnApplied;
-    if (middlewareRunner.hasMiddleware) {
-      await middlewareRunner.runChatEnd(sessionId, {
-        usage: chatUsage,
-        error: chatError,
-        output: chatOutput
-      });
-    }
-  }
-}
-
-// src/presets/patterns.ts
-function globToRegex(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${escaped}$`, "i");
-}
-function matchesPatterns(id, patterns) {
-  return patterns.some((pattern) => globToRegex(pattern).test(id));
-}
-function filterTools(tools, options) {
-  const allowPatterns = options.allow ?? [];
-  const denyPatterns = options.deny ?? [];
-  return tools.filter((tool) => {
-    const matchesAllow = allowPatterns.length === 0 || matchesPatterns(tool.id, allowPatterns);
-    if (!matchesAllow) {
-      return false;
-    }
-    const matchesDeny = denyPatterns.length > 0 && matchesPatterns(tool.id, denyPatterns);
-    if (matchesDeny && allowPatterns.length === 0) {
-      return false;
-    }
-    return true;
-  });
-}
-
-// src/presets/apply.ts
-function applyPreset(preset, availableTools, baseSystemPrompt) {
-  const tools = filterTools(availableTools, {
-    allow: preset.allowTools,
-    deny: preset.denyTools
-  });
-  let systemPrompt = preset.systemPrompt;
-  if (systemPrompt && baseSystemPrompt) {
-    systemPrompt = systemPrompt.replace("{basePrompt}", baseSystemPrompt);
-  }
-  return {
-    name: preset.name,
-    systemPrompt,
-    tools: tools.length > 0 ? tools : void 0,
-    temperature: preset.temperature,
-    maxSteps: preset.maxSteps,
-    reasoningLevel: preset.reasoningLevel,
-    model: preset.model
-  };
-}
-function mergePresets(...presets) {
-  if (presets.length === 0) {
-    throw new Error("mergePresets requires at least one preset");
-  }
-  if (presets.length === 1) {
-    return presets[0];
-  }
-  const [first, ...rest] = presets;
-  const allAllow = [];
-  const allDeny = [];
-  for (const preset of presets) {
-    if (preset.allowTools?.length) {
-      allAllow.push(preset.allowTools);
-    }
-    if (preset.denyTools?.length) {
-      allDeny.push(...preset.denyTools);
-    }
-  }
-  const combinedAllow = allAllow.length > 0 ? allAllow.reduce(
-    (left, right) => left.length <= right.length ? left : right
-  ) : void 0;
-  return {
-    name: presets.map((preset) => preset.name).join("+"),
-    description: presets.map((preset) => preset.description).join(" | "),
-    allowTools: combinedAllow,
-    denyTools: allDeny.length > 0 ? [...new Set(allDeny)] : void 0,
-    systemPrompt: rest.reduce(
-      (value, preset) => preset.systemPrompt ?? value,
-      first.systemPrompt
-    ),
-    temperature: rest.reduce(
-      (value, preset) => preset.temperature ?? value,
-      first.temperature
-    ),
-    maxSteps: rest.reduce(
-      (value, preset) => preset.maxSteps ?? value,
-      first.maxSteps
-    ),
-    reasoningLevel: rest.reduce(
-      (value, preset) => preset.reasoningLevel ?? value,
-      first.reasoningLevel
-    ),
-    model: rest.reduce((value, preset) => preset.model ?? value, first.model)
-  };
-}
-function createPreset(options) {
-  return {
-    description: options.description ?? `Custom preset: ${options.name}`,
-    ...options
-  };
+    })()
+  );
 }
 
-// src/presets/builtins.ts
-var explore = {
-  name: "explore",
-  description: "Read-only exploration mode for understanding content",
-  allowTools: ["read*", "search*", "glob*", "grep*", "list*", "find*"],
-  denyTools: ["write*", "edit*", "delete*", "bash*", "exec*", "run*"],
-  systemPrompt: `{basePrompt}
-
-## EXPLORATION MODE
-
-You are in **exploration mode**. Your goal is to thoroughly understand the content.
-
-Guidelines:
-- **Always start with glob or grep to discover correct paths** \u2014 never assume directory structure
-- Use search and read tools extensively to build understanding
-- Map out structures, dependencies, and patterns
-- Look for conventions, common patterns, and documentation
-- DO NOT modify anything \u2014 only read and analyse
-- Summarise findings clearly with references to specific locations
-
-Error recovery:
-- If a tool returns an error (ENOENT, not found, etc.), try a different path or approach
-- Use glob with broader patterns to discover the correct location
-- Keep going until you have a thorough answer \u2014 do not give up after one failure
-- You have multiple steps available \u2014 use them all if needed`,
-  temperature: 0.3,
-  maxSteps: 30
-};
-var plan = {
-  name: "plan",
-  description: "Planning mode for analyzing tasks and creating detailed plans",
-  allowTools: ["read*", "search*", "glob*", "grep*", "list*", "find*"],
-  denyTools: ["write*", "edit*", "delete*", "bash*", "exec*", "run*"],
-  systemPrompt: `{basePrompt}
-
-## PLANNING MODE
-
-You are in **planning mode**. Your goal is to analyze and plan before implementation.
-
-Guidelines:
-- Analyse the task requirements thoroughly
-- Research existing patterns and conventions
-- Identify potential impacts and dependencies
-- Create a clear, step-by-step implementation plan
-- DO NOT implement anything \u2014 only plan and document
-- Output a numbered list of specific, actionable steps`,
-  temperature: 0.2,
-  maxSteps: 20
-};
-var review = {
-  name: "review",
-  description: "Thorough review and analysis mode",
-  allowTools: ["read*", "grep*", "search*", "glob*", "list*"],
-  denyTools: ["*"],
-  systemPrompt: `{basePrompt}
-
-## REVIEW MODE
-
-You are in **review mode**. Your goal is to perform a thorough analysis.
-
-Review checklist:
-- [ ] Logic errors and edge cases
-- [ ] Security vulnerabilities
-- [ ] Performance issues
-- [ ] Error handling and recovery
-- [ ] Clarity and maintainability
-- [ ] Coverage gaps
-
-Guidelines:
-- Be thorough and systematic
-- Cite specific locations and details
-- Explain WHY something is an issue
-- Suggest concrete fixes
-- Rate severity: Critical / High / Medium / Low`,
-  temperature: 0.1,
-  maxSteps: 25
-};
-var quick = {
-  name: "quick",
-  description: "Fast mode for simple questions and quick operations",
-  systemPrompt: `{basePrompt}
-
-## QUICK MODE
-
-You are in **quick mode**. Be fast and focused.
-
-Guidelines:
-- Answer directly without lengthy explanations
-- Use minimal tool calls (1-3 max)
-- If you can't answer quickly, say so
-- Prioritize speed over thoroughness`,
-  temperature: 0,
-  maxSteps: 5
-};
-var careful = {
-  name: "careful",
-  description: "Extra cautious mode for sensitive operations",
-  denyTools: ["bash*", "exec*", "run*", "delete*", "remove*"],
-  systemPrompt: `{basePrompt}
-
-## CAREFUL MODE
-
-You are in **careful mode**. Every action must be verified.
-
-Guidelines:
-- Double-check before any file modifications
-- Explain what you're about to do BEFORE doing it
-- Prefer smaller, incremental changes
-- Always verify changes after making them
-- If uncertain, ask for clarification rather than guessing`,
-  temperature: 0,
-  maxSteps: 50
-};
-var code = {
-  name: "code",
-  description: "Full-power implementation mode for writing and modifying code",
-  systemPrompt: `{basePrompt}
-
-## IMPLEMENTATION MODE
-
-You are a focused **implementation agent**. Your goal is to complete the assigned task fully and correctly.
-
-Guidelines:
-- Read existing code first to understand context and conventions before making changes
-- Follow the project's existing patterns, naming conventions, and style
-- Make minimal, targeted changes \u2014 do not refactor unrelated code
-- Verify your work: re-read modified files, run tests or lint if available
-- If the task requires multiple files, handle them systematically one at a time
-
-Error recovery:
-- If a command fails, read the error output carefully and fix the root cause
-- If a test fails, read the failure details and iterate until it passes
-- If you cannot find a file, use glob or grep to discover the correct path
-- Keep iterating until the task is DONE \u2014 do not stop at a partial solution
-- You have many steps available \u2014 use them all if needed`,
-  temperature: 0,
-  maxSteps: 50
-};
-var watch = {
-  name: "watch",
-  description: "Process monitoring mode for running and watching long commands",
-  allowTools: ["bash*", "exec*", "run*", "read*", "grep*", "glob*", "list*", "find*"],
-  denyTools: ["write*", "edit*", "delete*", "remove*"],
-  systemPrompt: `{basePrompt}
-
-## WATCH MODE
-
-You are a **process monitor**. Your goal is to execute a command, observe its output, and report the result.
-
-Guidelines:
-- Run the command as given \u2014 do not modify or "improve" it
-- Wait for completion and capture the full output
-- Parse the output for success/failure status, error counts, warnings
-- Report a clear summary: what ran, whether it passed, key details
-- If the process fails, include the relevant error output verbatim
-- Do NOT attempt to fix issues \u2014 only observe and report`,
-  temperature: 0,
-  maxSteps: 10,
-  reasoningLevel: "low"
-};
-var Presets = {
-  explore,
-  plan,
-  review,
-  quick,
-  careful,
-  code,
-  watch
-};
-
 // src/agent/fork.ts
 function resolveForkOptions(options, parentTools, systemPrompt) {
   if (!options.preset) {
@@ -787,7 +607,7 @@ function createForkedAgentConfig(options) {
   };
 }
 
-// src/agent/mcp.ts
+// src/agent/mcp-bridge.ts
 async function ensureMcpTools(state) {
   if (!state.manager) {
     return { connected: false, cachedTools: void 0 };
@@ -878,7 +698,7 @@ async function createSubAgentRunSession(options) {
   return sessionId;
 }
 
-// src/intervention/controller.ts
+// src/agent/intervention.ts
 var InterventionController = class {
   /** Immediate interventions — applied at the next step boundary */
   immediate = [];
@@ -982,417 +802,14 @@ var InterventionController = class {
   }
 };
 
-// src/host/local.ts
-import { spawn } from "child_process";
-import fs from "fs/promises";
-import { existsSync } from "fs";
-import path from "path";
-import process2 from "process";
-function getShell() {
-  if (process2.platform === "win32") {
-    return { shell: "cmd.exe", args: ["/c"] };
-  }
-  const userShell = process2.env.SHELL ?? "/bin/bash";
-  return { shell: userShell, args: ["-c"] };
-}
-async function killProcessTree(pid) {
-  try {
-    if (process2.platform !== "win32") {
-      process2.kill(-pid, "SIGKILL");
-    } else {
-      const { exec: execCb } = await import("child_process");
-      execCb(`taskkill /pid ${pid} /t /f`, () => {
-      });
-    }
-  } catch {
-    try {
-      process2.kill(pid, "SIGKILL");
-    } catch {
-    }
-  }
-}
-function localHost(defaultCwd) {
-  const cwd = defaultCwd ?? process2.cwd();
-  return {
-    name: "local",
-    // --------------------------------------------------------------------------
-    // File system
-    // --------------------------------------------------------------------------
-    async readFile(filePath) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      return fs.readFile(abs, "utf-8");
-    },
-    async readBytes(filePath, offset, length) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      const fh = await fs.open(abs, "r");
-      try {
-        const buf = Buffer.alloc(length);
-        await fh.read(buf, 0, length, offset);
-        return buf;
-      } finally {
-        await fh.close();
-      }
-    },
-    async writeFile(filePath, content) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      await fs.mkdir(path.dirname(abs), { recursive: true });
-      await fs.writeFile(abs, content, "utf-8");
-    },
-    async exists(filePath) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      return existsSync(abs);
-    },
-    async stat(filePath) {
-      const abs = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-      const s = await fs.stat(abs);
-      return {
-        size: s.size,
-        mtime: s.mtime,
-        isDirectory: s.isDirectory(),
-        isFile: s.isFile()
-      };
-    },
-    async readdir(dirPath) {
-      const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
-      const entries = await fs.readdir(abs, { withFileTypes: true });
-      return entries.map((e) => ({
-        name: e.name,
-        isDirectory: e.isDirectory(),
-        isFile: e.isFile()
-      }));
-    },
-    async mkdir(dirPath) {
-      const abs = path.isAbsolute(dirPath) ? dirPath : path.resolve(cwd, dirPath);
-      await fs.mkdir(abs, { recursive: true });
-    },
-    // --------------------------------------------------------------------------
-    // Process execution
-    // --------------------------------------------------------------------------
-    exec(command, options) {
-      const { shell, args } = getShell();
-      const execCwd = options?.cwd ?? cwd;
-      const env = {
-        ...process2.env,
-        ...options?.env,
-        // Disable pagers — tools collect output, not interactive
-        PAGER: "cat",
-        GIT_PAGER: "cat"
-      };
-      return new Promise((resolve, reject) => {
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-        let settled = false;
-        const child = spawn(shell, [...args, command], {
-          cwd: execCwd,
-          detached: process2.platform !== "win32",
-          env,
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        child.stdout?.on("data", (data) => {
-          stdout += data.toString();
-          options?.onStdout?.(data);
-        });
-        child.stderr?.on("data", (data) => {
-          stderr += data.toString();
-          options?.onStderr?.(data);
-        });
-        let timer;
-        if (options?.timeout && options.timeout > 0) {
-          timer = setTimeout(() => {
-            timedOut = true;
-            if (child.pid) killProcessTree(child.pid);
-          }, options.timeout);
-        }
-        const onAbort = () => {
-          if (child.pid) killProcessTree(child.pid);
-        };
-        options?.signal?.addEventListener("abort", onAbort, { once: true });
-        child.on("close", (code2) => {
-          if (settled) return;
-          settled = true;
-          if (timer) clearTimeout(timer);
-          options?.signal?.removeEventListener("abort", onAbort);
-          resolve({ stdout, stderr, exitCode: code2, timedOut });
-        });
-        child.on("error", (err) => {
-          if (settled) return;
-          settled = true;
-          if (timer) clearTimeout(timer);
-          options?.signal?.removeEventListener("abort", onAbort);
-          reject(err);
-        });
-      });
-    }
-  };
-}
-
-// src/host/docker/exec.ts
-async function loadDockerode() {
-  try {
-    const module = await import("dockerode");
-    return module.default ?? module;
-  } catch {
-    throw new Error(
-      "dockerHost requires the 'dockerode' package. Install it with: npm install dockerode"
-    );
-  }
-}
-async function resolveDockerRuntime(options) {
-  const Dockerode = await loadDockerode();
-  if (typeof options.container === "string") {
-    const docker = new Dockerode(options.dockerOptions);
-    const container2 = docker.getContainer(options.container);
-    return {
-      docker,
-      container: container2,
-      label: options.container
-    };
-  }
-  const container = options.container;
-  return {
-    docker: { modem: container.modem },
-    container,
-    label: container.id?.slice(0, 12) ?? "unknown"
-  };
-}
-async function containerExec(runtime, command, options = {}) {
-  const envEntries = options.env ? Object.entries(options.env).filter((entry) => entry[1] !== void 0).map(([key, value]) => `${key}=${value}`) : void 0;
-  const exec = await runtime.container.exec({
-    Cmd: ["sh", "-c", command],
-    ...options.user ? { User: options.user } : {},
-    ...options.workdir ? { WorkingDir: options.workdir } : {},
-    ...envEntries && envEntries.length > 0 ? { Env: envEntries } : {},
-    AttachStdout: true,
-    AttachStderr: true
-  });
-  const stream = await exec.start({});
-  let timedOut = false;
-  let aborted = false;
-  return await new Promise((resolve, reject) => {
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    runtime.docker.modem.demuxStream(
-      stream,
-      {
-        write: (chunk) => {
-          stdoutChunks.push(chunk);
-          options.onStdout?.(chunk);
-          return true;
-        },
-        end: function() {
-          return this;
-        }
-      },
-      {
-        write: (chunk) => {
-          stderrChunks.push(chunk);
-          options.onStderr?.(chunk);
-          return true;
-        },
-        end: function() {
-          return this;
-        }
-      }
-    );
-    let timer;
-    if (options.timeout && options.timeout > 0) {
-      timer = setTimeout(() => {
-        timedOut = true;
-        stream.destroy?.();
-      }, options.timeout);
-    }
-    const onAbort = () => {
-      aborted = true;
-      stream.destroy?.();
-    };
-    options.signal?.addEventListener("abort", onAbort, { once: true });
-    stream.on("end", async () => {
-      if (timer) {
-        clearTimeout(timer);
-      }
-      options.signal?.removeEventListener("abort", onAbort);
-      try {
-        const info = await exec.inspect();
-        resolve({
-          stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
-          stderr: Buffer.concat(stderrChunks).toString("utf-8"),
-          exitCode: timedOut || aborted ? null : info.ExitCode ?? 0,
-          timedOut
-        });
-      } catch (error) {
-        reject(error);
-      }
-    });
-    stream.on("error", (error) => {
-      if (timer) {
-        clearTimeout(timer);
-      }
-      options.signal?.removeEventListener("abort", onAbort);
-      if (timedOut || aborted) {
-        resolve({
-          stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
-          stderr: Buffer.concat(stderrChunks).toString("utf-8"),
-          exitCode: null,
-          timedOut
-        });
-        return;
-      }
-      reject(error);
-    });
-  });
-}
-async function runDockerCommand(options) {
-  const { runtime, command, defaultUser, defaultWorkdir, execOptions } = options;
-  return await containerExec(runtime, command, {
-    user: defaultUser,
-    workdir: execOptions?.workdir ?? execOptions?.cwd ?? defaultWorkdir,
-    env: execOptions?.env,
-    timeout: execOptions?.timeout,
-    signal: execOptions?.signal,
-    onStdout: execOptions?.onStdout,
-    onStderr: execOptions?.onStderr
-  });
-}
-
-// src/host/docker/shell.ts
-function sq(value) {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-function resolveDockerPath(path2, defaultWorkdir) {
-  if (path2.startsWith("/")) {
-    return path2;
-  }
-  const base = defaultWorkdir.endsWith("/") ? defaultWorkdir : `${defaultWorkdir}/`;
-  return `${base}${path2}`;
-}
-
-// src/host/docker/host.ts
-async function dockerHost(options) {
-  const runtime = await resolveDockerRuntime(options);
-  const defaultUser = options.user;
-  const defaultWorkdir = options.workdir ?? "/";
-  async function run(command, execOptions) {
-    return await runDockerCommand({
-      runtime,
-      command,
-      defaultUser,
-      defaultWorkdir,
-      execOptions
-    });
-  }
-  return {
-    name: `docker:${runtime.label}`,
-    async readFile(filePath) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const result = await run(`cat ${sq(absPath)}`);
-      if (result.exitCode !== 0) {
-        throw new Error(`readFile failed (${absPath}): ${result.stderr.trim()}`);
-      }
-      return result.stdout;
-    },
-    async readBytes(filePath, offset, length) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const result = await run(
-        `dd if=${sq(absPath)} bs=1 skip=${offset} count=${length} 2>/dev/null`
-      );
-      if (result.exitCode !== 0) {
-        throw new Error(
-          `readBytes failed (${absPath}): ${result.stderr.trim()}`
-        );
-      }
-      return Buffer.from(result.stdout, "binary");
-    },
-    async writeFile(filePath, content) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const dir = absPath.substring(0, absPath.lastIndexOf("/")) || "/";
-      await run(`mkdir -p ${sq(dir)}`);
-      const encoded = Buffer.from(content, "utf-8").toString("base64");
-      const result = await run(`echo ${sq(encoded)} | base64 -d > ${sq(absPath)}`);
-      if (result.exitCode !== 0) {
-        throw new Error(
-          `writeFile failed (${absPath}): ${result.stderr.trim()}`
-        );
-      }
-    },
-    async exists(filePath) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const result = await run(`test -e ${sq(absPath)}`);
-      return result.exitCode === 0;
-    },
-    async stat(filePath) {
-      const absPath = resolveDockerPath(filePath, defaultWorkdir);
-      const result = await run(
-        `stat -c '%s %Y %F' ${sq(absPath)} 2>/dev/null || stat -f '%z %m %HT' ${sq(absPath)}`
-      );
-      if (result.exitCode !== 0) {
-        throw new Error(`stat failed (${absPath}): ${result.stderr.trim()}`);
-      }
-      const parts = result.stdout.trim().split(/\s+/);
-      if (parts.length < 3) {
-        throw new Error(
-          `stat: unexpected output format for ${absPath}: ${result.stdout}`
-        );
-      }
-      const size = parseInt(parts[0], 10);
-      const mtimeSec = parseInt(parts[1], 10);
-      const typeStr = parts.slice(2).join(" ").toLowerCase();
-      return {
-        size,
-        mtime: new Date(mtimeSec * 1e3),
-        isDirectory: typeStr.includes("directory"),
-        isFile: typeStr.includes("regular") || typeStr.includes("file")
-      };
-    },
-    async readdir(dirPath) {
-      const absPath = resolveDockerPath(dirPath, defaultWorkdir);
-      const result = await run(
-        `find ${sq(absPath)} -maxdepth 1 -mindepth 1 -printf '%f\\t%y\\n' 2>/dev/null || for f in ${sq(absPath)}/*; do [ -e "$f" ] || continue; n=$(basename "$f"); if [ -d "$f" ]; then printf '%s\\td\\n' "$n"; else printf '%s\\tf\\n' "$n"; fi; done`
-      );
-      if (result.exitCode !== 0) {
-        throw new Error(
-          `readdir failed (${absPath}): ${result.stderr.trim()}`
-        );
-      }
-      return result.stdout.trim().split("\n").filter(Boolean).map((line) => {
-        const [name, type] = line.split("	");
-        return {
-          name,
-          isDirectory: type === "d",
-          isFile: type === "f"
-        };
-      });
-    },
-    async mkdir(dirPath) {
-      const absPath = resolveDockerPath(dirPath, defaultWorkdir);
-      const result = await run(`mkdir -p ${sq(absPath)}`);
-      if (result.exitCode !== 0) {
-        throw new Error(`mkdir failed (${absPath}): ${result.stderr.trim()}`);
-      }
-    },
-    async exec(command, execOptions) {
-      return await run(command, execOptions);
-    }
-  };
-}
-
-// src/agent/model-detection.ts
+// src/agent/stream-provider.ts
 var DEFAULT_CUSTOM_STREAM_MODELS = [
   "computer-use-preview",
   "computer-use-preview-2025-03-11"
 ];
-function getModelId2(model) {
-  if (typeof model === "string") {
-    return model;
-  }
-  if (typeof model === "object" && model !== null && "modelId" in model) {
-    return String(model.modelId);
-  }
-  return void 0;
-}
 function needsCustomStreamProvider(model, customPatterns) {
-  const modelId = getModelId2(model);
-  if (!modelId) return false;
+  const modelId = getModelId(model);
+  if (!modelId || modelId === "[object Object]") return false;
   const patterns = customPatterns ?? DEFAULT_CUSTOM_STREAM_MODELS;
   return patterns.some((pattern) => modelId.includes(pattern));
 }
@@ -1407,7 +824,7 @@ function autoDetectStreamProvider(model, tools, explicitProvider) {
   const enhancedTools = tools;
   const customPatterns = enhancedTools.__customStreamModels;
   if (needsCustomStreamProvider(model, customPatterns) && hasStreamProviderFactory(enhancedTools)) {
-    const modelId = getModelId2(model);
+    const modelId = getModelId(model);
     if (modelId) {
       const streamConfig = {
         apiKey: process.env.OPENAI_API_KEY,
@@ -1452,10 +869,11 @@ function createEffectiveAgentConfig(config) {
   return {
     systemPrompt: DEFAULT_SYSTEM_PROMPT,
     cwd: process.cwd(),
-    maxOutputTokens: DEFAULT_MAX_TOKENS,
-    maxSteps: DEFAULT_MAX_STEPS,
     reasoningLevel: "off",
     ...config,
+    // Re-apply defaults after spread so explicit `undefined` from callers doesn't win.
+    maxSteps: config.maxSteps ?? DEFAULT_MAX_STEPS,
+    maxOutputTokens: config.maxOutputTokens ?? DEFAULT_MAX_TOKENS,
     streamProvider: effectiveStreamProvider
   };
 }
@@ -1482,10 +900,17 @@ function createAgentState(config) {
 }
 function createAgentContextManager(config) {
   const compactionConfig = config.compaction ?? {};
+  const modelId = getModelId(config.model);
+  const inferredWindow = inferContextWindow(modelId);
+  const contextWindow = config.contextWindow ?? inferredWindow ?? DEFAULT_CONTEXT_LIMITS.contextWindow;
+  const reserveTokens = Math.min(
+    32e3,
+    Math.max(8e3, Math.round(contextWindow * 0.12))
+  );
   return new ContextManager({
     limits: {
-      contextWindow: config.contextWindow ?? DEFAULT_CONTEXT_LIMITS.contextWindow,
-      reserveTokens: DEFAULT_CONTEXT_LIMITS.reserveTokens,
+      contextWindow,
+      reserveTokens,
       protectedTokens: compactionConfig.protectedTokens ?? DEFAULT_CONTEXT_LIMITS.protectedTokens,
       pruneMinimum: compactionConfig.pruneMinimum ?? DEFAULT_CONTEXT_LIMITS.pruneMinimum
     },
@@ -1631,6 +1056,8 @@ var Agent = class _Agent {
   mcpManager;
   /** Whether MCP has been connected (lazy init) */
   mcpConnected = false;
+  /** Whether skill tools have been resolved (lazy init) */
+  skillToolsResolved = false;
   /** Cached MCP tools (refreshed on connect) */
   mcpToolsCache;
   /** Prompt pipeline builder (when using layered prompt mode) */
@@ -1645,6 +1072,8 @@ var Agent = class _Agent {
   telemetrySettings;
   /** Tracing shutdown function (from `tracing` config auto-setup) */
   tracingShutdown;
+  /** Multi-consumer event dispatch */
+  _signal;
   constructor(config) {
     const setup = createAgentSetup(config);
     this.config = setup.config;
@@ -1660,6 +1089,17 @@ var Agent = class _Agent {
     this.middlewareRunner = setup.middlewareRunner;
     this.telemetrySettings = setup.telemetrySettings;
     this.tracingShutdown = setup.tracingShutdown;
+    this._signal = config.signal ?? new LocalSignal();
+  }
+  /**
+   * Event signal — subscribe to events without consuming the generator.
+   *
+   * Every event yielded by `chat()` is also dispatched here, allowing
+   * multiple passive observers (SSE routes, TUI, plugins) to listen
+   * concurrently.
+   */
+  get signal() {
+    return this._signal;
   }
   /** Agent name (identity for spans, Dapr workflows, etc.) */
   get name() {
@@ -1706,6 +1146,22 @@ var Agent = class _Agent {
   supportsReasoning() {
     return supportsReasoningSync(this.state.model);
   }
+  /**
+   * Ensure skill tools are registered when `prompt.skills` is configured.
+   * Lazy initialization — resolves the registry and adds tools on first use.
+   */
+  async ensureSkillTools() {
+    if (this.skillToolsResolved || !this.promptBuilder) return;
+    this.skillToolsResolved = true;
+    const registry = await this.promptBuilder.getSkillRegistry(this.config.cwd);
+    if (registry.size > 0) {
+      for (const tool of createSkillTools(registry)) {
+        if (!this.tools.has(tool.id)) {
+          this.tools.set(tool.id, tool);
+        }
+      }
+    }
+  }
   /**
    * Ensure MCP is connected and return tools
    * Lazy initialization - only connects on first use
@@ -1757,12 +1213,13 @@ var Agent = class _Agent {
    */
   async *chat(sessionId, message, options) {
     await this.ensureSession(sessionId);
+    await this.ensureSkillTools();
     const abort = options?.abort ?? new AbortController().signal;
     const turnId = `${sessionId}-turn-${++this.turnCounter}`;
     this.turnTracker.startTurn(turnId);
     await this.repairOrphanedToolCalls();
     const mcpTools = await this.ensureMCPConnected();
-    yield* runChatLoop({
+    const loop = runChatLoop({
       sessionId,
       message,
       abort,
@@ -1785,6 +1242,10 @@ var Agent = class _Agent {
         this.state.isStreaming = v;
       }
     });
+    for await (const event of loop) {
+      this._signal.emit(event);
+      yield event;
+    }
   }
   /**
    * Ensure a session is loaded or created
@@ -2115,6 +1576,17 @@ var Agent = class _Agent {
   setModel(model) {
     this.config.model = model;
     this.state.model = model;
+    if (this.config.contextWindow === void 0) {
+      const modelId = getModelId(model);
+      const inferred = inferContextWindow(modelId);
+      if (inferred) {
+        const reserveTokens = Math.min(
+          32e3,
+          Math.max(8e3, Math.round(inferred * 0.12))
+        );
+        this.contextManager.setLimits({ contextWindow: inferred, reserveTokens });
+      }
+    }
   }
   /**
    * Get the prompt builder (when using pipeline mode).
@@ -2332,6 +1804,7 @@ var Agent = class _Agent {
    * After calling close(), the agent should not be used.
    */
   async close() {
+    this._signal.clear();
     if (this.tracingShutdown) {
       await this.tracingShutdown();
     }
@@ -2370,6 +1843,8 @@ export {
   AgentTurnEngine,
   ApprovalDeniedError,
   ApprovalTimeoutError,
+  CacheCapabilitySource,
+  CapabilityCache,
   ContextManager,
   ContextOverflowError,
   DEFAULT_CONTEXT_LIMITS,
@@ -2378,16 +1853,25 @@ export {
   DEFAULT_MAX_CONCURRENT,
   DEFAULT_MAX_DEPTH,
   DEFAULT_MAX_FILE_SIZE,
+  DEFAULT_MAX_OUTPUT_TOKENS,
   DEFAULT_MAX_SCAN_DEPTH,
   DEFAULT_MAX_SPAWN_DEPTH,
+  DEFAULT_MAX_STEPS,
+  DEFAULT_MAX_TOKENS,
+  DEFAULT_RESOLVER_OPTIONS,
   DEFAULT_RETRY_CONFIG,
   DEFAULT_SESSION_TITLE_PREFIX,
   DEFAULT_SKILL_MAX_SIZE,
+  DEFAULT_SYSTEM_PROMPT,
   DoomLoopError,
+  EXTENDED_LEVELS,
+  FIXED_LEVELS,
   FileStorage,
+  Inference,
   InterventionController,
   LLM,
   LLMError,
+  LocalSignal,
   MAX_BYTES,
   MAX_LINES,
   MemoryStorage,
@@ -2400,12 +1884,18 @@ export {
   PRIORITY_INSTRUCTIONS,
   PRIORITY_OVERRIDE,
   PRIORITY_SKILLS,
+  PRUNE_PROTECTED_TOOLS,
+  PatternCapabilitySource,
   Presets,
   PromptBuilder,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
   SKILL_FILENAME,
+  STANDARD_LEVELS,
   STORAGE_VERSION,
   SessionManager,
   SkillRegistry,
+  SourcePriority,
   SubAgentTracker,
   TRUNCATE_DIR,
   TRUNCATE_GLOB,
@@ -2417,14 +1907,27 @@ export {
   applyAgentWorkflowModelStepResult,
   applyAgentWorkflowToolBatchResult,
   applyAgentWorkflowToolCallResult,
+  applyCapabilityOverride,
   applyPreset,
   approvalMiddleware,
+  autoDetectStreamProvider,
+  buildAnthropicOptions,
+  buildBedrockOptions,
+  buildEntryPath,
+  buildGoogleOptions,
+  buildGroqOptions,
   buildMessagesFromEntries,
+  buildOpenAIOptions,
+  buildOpenRouterOptions,
   buildReasoningOptions,
   buildReasoningOptionsSync,
+  buildToolSet,
+  buildXAIOptions,
   calculateDelay,
+  careful,
   clearCheckpoints,
   cloneAgentWorkflowTurnState,
+  code,
   commitOutput,
   commitStep,
   configureDefaultSessionManager,
@@ -2439,11 +1942,14 @@ export {
   createApprovalHandler,
   createCheckpointManager,
   createMCPManager,
+  createMessageEntry,
+  createMetadataEntry,
   createPreset,
   createPromptBuilder,
   createResolver,
   createRetryHandler,
   createRetryState,
+  createScope,
   createSkillRegistry,
   createSkillResourceTool,
   createSkillTool,
@@ -2451,6 +1957,7 @@ export {
   createSubAgentTools,
   createTelemetryConfig,
   createTurnTracker,
+  currentScope,
   defaultAgentTaskCheckpointStrategy,
   defaultRegistry,
   defineServer,
@@ -2465,10 +1972,15 @@ export {
   estimateMessageTokens,
   estimateTokens,
   executeAgentToolCall,
+  explore,
   extractFilePathsFromArgs,
+  extractModelId,
+  extractProvider,
+  extractSessionInfo,
   failAgentTurnState,
   failAgentWorkflowTurnState,
   filterTools,
+  findCapabilityOverride,
   findCutPoint,
   formatEnvironment,
   formatInstructions,
@@ -2481,57 +1993,82 @@ export {
   getDefaultResolver,
   getDefaultSessionManager,
   getErrorCategory,
+  getGitRootHash,
   getLeafId,
   getModelId,
   getNetworkStatus,
+  getProjectId,
   getProjectSessionsDir,
+  getProviderCompatibility,
   getProviderId,
+  getProviderOptionsKey,
   getReasoningConfig,
   getReasoningConfigSync,
   getRetryDelay,
   getSessionsDir,
   getTemplate,
   getToolRisk,
+  hasStreamProviderFactory,
   httpServer,
+  inferContextWindow,
+  inferProvider,
   inferResourceType,
   isContextOverflowing,
   isRetryable,
   isRetryableCategory,
+  likelySupportsReasoning,
   loadGlobalInstructions,
   loadResourceContent,
   loadSkillContent,
   loadSkillMetadata,
   localHost,
   mergePresets,
+  needsCustomStreamProvider,
   normalizeToolReplayPolicy,
   otelMiddleware,
   parseFrontmatter,
   parseJSONL,
+  parseRetryDelay,
+  plan,
   planNextAgentWorkflowOperation,
   prepareModelStep,
+  processStepStream,
   processStream,
+  promptCacheMiddleware,
   pruneContext,
   pruneToolResults,
+  quick,
   recordAgentWorkflowReplayDecision,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,
+  restoreScope,
+  review,
+  runChatLoop,
   runConcurrent,
   runModelStep,
   runToolBatch,
   serializeMessage,
   shouldCaptureBaseline,
+  shouldIncludeReasoningSummary,
   shouldPruneContext,
   shouldRetry,
   sleep,
   snapshotAgentWorkflowMessage,
   snapshotAgentWorkflowMessages,
+  snapshotScope,
   sseServer,
   stdioServer,
+  stream,
+  streamOnce,
+  streamStep,
   summarizeEnvironment,
   supportsReasoning,
   supportsReasoningSync,
   toJSONL,
+  toJSONLBatch,
   truncateOutput,
+  watch,
   withFileTracking,
-  withRetry
+  withRetry,
+  withinScope
 };