@cuylabs/agent-core 0.7.0 → 0.9.0

package/dist/index.js

@@ -1,3 +1,66 @@
+import {
+  DEFAULT_MAX_CONCURRENT,
+  DEFAULT_MAX_SPAWN_DEPTH,
+  DEFAULT_SESSION_TITLE_PREFIX,
+  SubAgentTracker,
+  createSubAgentTools,
+  discoverAgentProfiles,
+  getProjectAgentsDir,
+  getUserAgentsDir,
+  isMarkdownProfile,
+  parseAgentFrontmatter,
+  parseMarkdownAgent,
+  parseToolSpec,
+  toAgentProfile
+} from "./chunk-JLXG2SH7.js";
+import {
+  ToolRegistry,
+  defaultRegistry
+} from "./chunk-SDSBEQXG.js";
+import {
+  TurnChangeTracker,
+  clearCheckpoints,
+  createCheckpointManager,
+  createTurnTracker
+} from "./chunk-OFDKHNCX.js";
+import {
+  applyPreset,
+  createPreset,
+  filterTools,
+  mergePresets
+} from "./chunk-IYWQOJMQ.js";
+import {
+  Presets,
+  careful,
+  code,
+  explore,
+  plan,
+  quick,
+  review,
+  watch
+} from "./chunk-EKR6PKXU.js";
+import {
+  DEFAULT_INSTRUCTION_PATTERNS,
+  DEFAULT_MAX_DEPTH,
+  DEFAULT_MAX_FILE_SIZE,
+  PRIORITY_BASE,
+  PRIORITY_CUSTOM,
+  PRIORITY_ENVIRONMENT,
+  PRIORITY_INSTRUCTIONS,
+  PRIORITY_OVERRIDE,
+  PRIORITY_SKILLS,
+  PromptBuilder,
+  createPromptBuilder,
+  detectModelFamily,
+  discoverInstructions,
+  formatEnvironment,
+  formatInstructions,
+  gatherEnvironment,
+  getAvailableFamilies,
+  getTemplate,
+  loadGlobalInstructions,
+  summarizeEnvironment
+} from "./chunk-GFTW23FV.js";
 import {
   AgentTurnEngine,
   ContextOverflowError,
@@ -30,12 +93,41 @@ import {
   runToolBatch,
   snapshotAgentWorkflowMessage,
   snapshotAgentWorkflowMessages
-} from "./chunk-3HNO5SVI.js";
+} from "./chunk-J4QDGZIA.js";
+import {
+  LocalSignal
+} from "./chunk-DXFBQMXP.js";
 import {
   createSkillResourceTool,
   createSkillTool,
   createSkillTools
-} from "./chunk-YUUJK53A.js";
+} from "./chunk-RKEW5WXI.js";
+import {
+  MAX_BYTES,
+  MAX_LINES,
+  TRUNCATE_DIR,
+  TRUNCATE_GLOB,
+  Tool,
+  defineTool,
+  formatSize,
+  normalizeToolReplayPolicy,
+  truncateOutput
+} from "./chunk-MHKK374K.js";
+import {
+  DEFAULT_EXTERNAL_DIRS,
+  DEFAULT_MAX_SCAN_DEPTH,
+  DEFAULT_SKILL_MAX_SIZE,
+  SKILL_FILENAME,
+  SkillRegistry,
+  createSkillRegistry,
+  discoverSkills,
+  emptySkillRegistry,
+  inferResourceType,
+  loadResourceContent,
+  loadSkillContent,
+  loadSkillMetadata,
+  parseFrontmatter
+} from "./chunk-SPILYYDF.js";
 import {
   FileStorage,
   MemoryStorage,
@@ -60,35 +152,7 @@ import {
   serializeMessage,
   toJSONL,
   toJSONLBatch
-} from "./chunk-BDBZ3SLK.js";
-import {
-  DEFAULT_MAX_CONCURRENT,
-  DEFAULT_MAX_SPAWN_DEPTH,
-  DEFAULT_SESSION_TITLE_PREFIX,
-  SubAgentTracker,
-  createSubAgentTools
-} from "./chunk-7MUFEN4K.js";
-import {
-  ToolRegistry,
-  defaultRegistry
-} from "./chunk-SDSBEQXG.js";
-import {
-  MAX_BYTES,
-  MAX_LINES,
-  TRUNCATE_DIR,
-  TRUNCATE_GLOB,
-  Tool,
-  defineTool,
-  formatSize,
-  normalizeToolReplayPolicy,
-  truncateOutput
-} from "./chunk-P6YF7USR.js";
-import {
-  TurnChangeTracker,
-  clearCheckpoints,
-  createCheckpointManager,
-  createTurnTracker
-} from "./chunk-VBWWUHWI.js";
+} from "./chunk-UHCJEM2E.js";
 import {
   ContextManager,
   DEFAULT_CONTEXT_LIMITS,
@@ -102,7 +166,7 @@ import {
   pruneContext,
   pruneToolResults,
   shouldPruneContext
-} from "./chunk-BNSHUWCV.js";
+} from "./chunk-WWYYNWEW.js";
 import {
   dockerHost,
   localHost
@@ -112,28 +176,72 @@ import {
   DEFAULT_RETRY_CONFIG,
   Inference,
   LLM,
-  LLMError,
   OUTPUT_TOKEN_MAX,
   buildToolSet,
   calculateDelay,
   createRetryHandler,
   createRetryState,
-  getErrorCategory,
-  getRetryDelay,
-  isRetryable,
-  isRetryableCategory,
-  parseRetryDelay,
   shouldRetry,
   sleep,
   stream,
   streamOnce,
   streamStep,
   withRetry
-} from "./chunk-5K7AQVOU.js";
+} from "./chunk-WKHDSSXG.js";
+import {
+  executeAgentToolCall
+} from "./chunk-H3FUYU52.js";
+import {
+  extractFilePathsFromArgs,
+  shouldCaptureBaseline,
+  withFileTracking
+} from "./chunk-VEKUXUVF.js";
+import {
+  LLMError,
+  getErrorCategory,
+  getRetryDelay,
+  isRetryable,
+  isRetryableCategory,
+  parseRetryDelay
+} from "./chunk-4QFNWPIF.js";
+import {
+  createScope,
+  currentScope,
+  restoreScope,
+  snapshotScope,
+  streamWithinScope,
+  withinScope
+} from "./chunk-N7P4PN3O.js";
+import {
+  createMCPManager,
+  defineServer,
+  httpServer,
+  sseServer,
+  stdioServer
+} from "./chunk-ZXAKHMWH.js";
+import {
+  MiddlewareRunner,
+  approvalMiddleware,
+  createTelemetryConfig,
+  otelMiddleware,
+  promptCacheMiddleware
+} from "./chunk-MAZ5DY5B.js";
+import {
+  ApprovalDeniedError,
+  ApprovalTimeoutError,
+  createApprovalHandler,
+  getToolRisk
+} from "./chunk-5ARZJWD2.js";
 import {
+  CacheCapabilitySource,
+  CapabilityCache,
   EXTENDED_LEVELS,
   FIXED_LEVELS,
+  ModelCapabilityResolver,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
   STANDARD_LEVELS,
+  applyCapabilityOverride,
   buildAnthropicOptions,
   buildBedrockOptions,
   buildGoogleOptions,
@@ -143,158 +251,373 @@ import {
   buildReasoningOptions,
   buildReasoningOptionsSync,
   buildXAIOptions,
+  configureResolver,
+  createResolver,
+  findCapabilityOverride,
+  getDefaultResolver,
+  getNetworkStatus,
   getProviderOptionsKey,
   getReasoningConfig,
   getReasoningConfigSync,
   shouldIncludeReasoningSummary,
   supportsReasoning,
   supportsReasoningSync
-} from "./chunk-ZPMACVZK.js";
-import {
-  executeAgentToolCall
-} from "./chunk-IEFIQENH.js";
-import {
-  streamWithinScope
-} from "./chunk-N7P4PN3O.js";
-import {
-  extractFilePathsFromArgs,
-  shouldCaptureBaseline,
-  withFileTracking
-} from "./chunk-VEKUXUVF.js";
-import {
-  ApprovalDeniedError,
-  ApprovalTimeoutError,
-  MiddlewareRunner,
-  approvalMiddleware,
-  createApprovalHandler,
-  createTelemetryConfig,
-  getToolRisk,
-  otelMiddleware,
-  promptCacheMiddleware
-} from "./chunk-CDTV2UYU.js";
+} from "./chunk-UDCZ673N.js";
 import {
-  CacheCapabilitySource,
-  CapabilityCache,
   DEFAULT_RESOLVER_OPTIONS,
-  ModelCapabilityResolver,
   PatternCapabilitySource,
-  RemoteCapabilityFetcher,
-  RemoteCapabilitySource,
   SourcePriority,
-  applyCapabilityOverride,
-  configureResolver,
-  createResolver,
   extractModelId,
   extractProvider,
-  findCapabilityOverride,
-  getDefaultResolver,
   getModelId,
-  getNetworkStatus,
   getProviderCompatibility,
   getProviderId,
+  inferContextWindow,
   inferProvider,
   likelySupportsReasoning
-} from "./chunk-QGOGIP7T.js";
-import {
-  createMCPManager,
-  defineServer,
-  httpServer,
-  sseServer,
-  stdioServer
-} from "./chunk-ZXAKHMWH.js";
-import {
-  DEFAULT_INSTRUCTION_PATTERNS,
-  DEFAULT_MAX_DEPTH,
-  DEFAULT_MAX_FILE_SIZE,
-  PRIORITY_BASE,
-  PRIORITY_CUSTOM,
-  PRIORITY_ENVIRONMENT,
-  PRIORITY_INSTRUCTIONS,
-  PRIORITY_OVERRIDE,
-  PRIORITY_SKILLS,
-  PromptBuilder,
-  createPromptBuilder,
-  detectModelFamily,
-  discoverInstructions,
-  formatEnvironment,
-  formatInstructions,
-  gatherEnvironment,
-  getAvailableFamilies,
-  getTemplate,
-  loadGlobalInstructions,
-  summarizeEnvironment
-} from "./chunk-IVUJDISU.js";
+} from "./chunk-I6PKJ7XQ.js";
 import {
-  DEFAULT_EXTERNAL_DIRS,
-  DEFAULT_MAX_SCAN_DEPTH,
-  DEFAULT_SKILL_MAX_SIZE,
-  SKILL_FILENAME,
-  SkillRegistry,
-  createSkillRegistry,
-  discoverSkills,
-  emptySkillRegistry,
-  inferResourceType,
-  loadResourceContent,
-  loadSkillContent,
-  loadSkillMetadata,
-  parseFrontmatter
-} from "./chunk-LRHOS4ZN.js";
-
-// src/agent/chat-loop/commit.ts
-function createChatLoopCommitBatchApplier(params) {
-  const { turnEngine, sessions, middlewareRunner } = params;
-  return async function* applyCommitBatch(batch, options = {}) {
-    turnEngine.recordEvent(batch.startBoundary, (/* @__PURE__ */ new Date()).toISOString());
-    middlewareRunner.emitEvent(batch.startBoundary);
-    yield batch.startBoundary;
-    await sessions.addMessages(batch.messages);
-    turnEngine.recordEvent(batch.finishBoundary, (/* @__PURE__ */ new Date()).toISOString());
-    middlewareRunner.emitEvent(batch.finishBoundary);
-    yield batch.finishBoundary;
-    if (options.emitMessages) {
-      for (const committedMessage of batch.messages) {
-        yield { type: "message", message: committedMessage };
-      }
-    }
-  };
-}
-
-// src/agent/chat-loop/compaction.ts
-async function runAutoCompaction(params) {
-  const { contextManager, messages } = params;
-  if (!contextManager.shouldPrune(messages)) {
-    return [];
-  }
-  const events = [{ type: "status", status: "processing" }];
-  const pruneResult = await contextManager.prune(messages);
-  if (pruneResult.removedCount > 0 || pruneResult.summarized) {
-    const limits = contextManager.getLimits();
-    events.push({
-      type: "context-overflow",
-      inputTokens: estimateConversationTokens(messages),
-      limit: limits.contextWindow - limits.reserveTokens
-    });
-  }
-  return events;
-}
+  LayeredSettings,
+  NullSettings,
+  PluginEventBus,
+  PluginRegistry,
+  StaticSettings,
+  ValidatedSettings,
+  definePlugin,
+  discoverPlugins,
+  getPluginLoader,
+  isDefinedPlugin,
+  loadPluginModule,
+  resetFrameworkAliases,
+  resetPluginLoader,
+  resolveFrameworkAliases
+} from "./chunk-WGZAPU6N.js";
 
-// src/agent/chat-loop/prompts.ts
-async function buildChatSystemPrompts(params) {
+// src/agent/intervention.ts
+var InterventionController = class {
+  /** Immediate interventions — applied at the next step boundary */
+  immediate = [];
+  /** Deferred messages — held until the turn completes */
+  deferred = [];
+  /**
+   * Callback fired when an intervention is wired into a step.
+   * Set by the Agent before starting a chat turn, cleared after.
+   */
+  onApplied;
+  // ---------------------------------------------------------------------------
+  // Immediate interventions (mid-turn redirect)
+  // ---------------------------------------------------------------------------
+  /**
+   * Inject a message at the next LLM step boundary.
+   *
+   * The message is appended as a user message to the conversation
+   * before the next LLM call in the current multi-step turn. The
+   * LLM will see it and can adjust its behavior accordingly.
+   *
+   * Safe to call from any async context while `chat()` is running.
+   * If called when no turn is active, the message will be picked up
+   * by the first step of the next `chat()` call.
+   *
+   * @param message - The user message to inject
+   * @returns Intervention ID for tracking
+   */
+  intervene(message) {
+    const id = crypto.randomUUID();
+    this.immediate.push(
+      Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() })
+    );
+    return id;
+  }
+  /**
+   * Drain and return all pending immediate interventions.
+   * The internal queue is cleared atomically.
+   *
+   * @internal Called by the LLM stream's `prepareStep` hook
+   */
+  drainImmediate() {
+    if (this.immediate.length === 0) return [];
+    return this.immediate.splice(0);
+  }
+  /** Adopt existing immediate interventions without changing their IDs. */
+  adoptImmediate(items) {
+    if (items.length === 0) return;
+    this.immediate.push(...items);
+  }
+  /** Whether there are pending immediate interventions */
+  get hasPending() {
+    return this.immediate.length > 0;
+  }
+  /** Number of pending immediate interventions */
+  get pendingCount() {
+    return this.immediate.length;
+  }
+  // ---------------------------------------------------------------------------
+  // Deferred messages (after-turn follow-ups)
+  // ---------------------------------------------------------------------------
+  /**
+   * Queue a message for after the current turn completes.
+   *
+   * Unlike `intervene()`, this does **not** inject mid-turn. The
+   * message is held and available via `drainDeferred()` after
+   * `chat()` finishes. The consumer decides whether to send it
+   * as a new turn.
+   *
+   * @param message - The message to queue
+   * @returns Intervention ID for tracking
+   */
+  queueNext(message) {
+    const id = crypto.randomUUID();
+    this.deferred.push(
+      Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() })
+    );
+    return id;
+  }
+  /**
+   * Drain and return all deferred messages.
+   * The internal queue is cleared atomically.
+   */
+  drainDeferred() {
+    if (this.deferred.length === 0) return [];
+    return this.deferred.splice(0);
+  }
+  /** Adopt existing deferred interventions without changing their IDs. */
+  adoptDeferred(items) {
+    if (items.length === 0) return;
+    this.deferred.push(...items);
+  }
+  /** Whether there are deferred messages */
+  get hasDeferred() {
+    return this.deferred.length > 0;
+  }
+  /** Number of deferred messages */
+  get deferredCount() {
+    return this.deferred.length;
+  }
+  // ---------------------------------------------------------------------------
+  // Housekeeping
+  // ---------------------------------------------------------------------------
+  /** Clear all queues (immediate + deferred) */
+  clear() {
+    this.immediate.length = 0;
+    this.deferred.length = 0;
+  }
+  /** Reset the controller for a new turn (clears onApplied, keeps queues) */
+  resetCallbacks() {
+    this.onApplied = void 0;
+  }
+};
+
+// src/agent/chat-loop/commit.ts
+function createChatLoopCommitBatchApplier(params) {
+  const { turnEngine, sessions, middlewareRunner } = params;
+  return async function* applyCommitBatch(batch, options = {}) {
+    turnEngine.recordEvent(batch.startBoundary, (/* @__PURE__ */ new Date()).toISOString());
+    middlewareRunner.emitEvent(batch.startBoundary);
+    yield batch.startBoundary;
+    await sessions.addMessages(batch.messages);
+    turnEngine.recordEvent(batch.finishBoundary, (/* @__PURE__ */ new Date()).toISOString());
+    middlewareRunner.emitEvent(batch.finishBoundary);
+    yield batch.finishBoundary;
+    if (options.emitMessages) {
+      for (const committedMessage of batch.messages) {
+        yield { type: "message", message: committedMessage };
+      }
+    }
+  };
+}
+
+// src/agent/session.ts
+async function ensureSessionLoaded(options) {
+  const { sessionId, sessions, cwd } = options;
+  if (sessions.getSessionId() === sessionId) {
+    return;
+  }
+  const exists = await sessions.sessionExists(sessionId);
+  if (exists) {
+    await sessions.load(sessionId);
+  } else {
+    await sessions.create({ id: sessionId, cwd });
+  }
+}
+async function repairOrphanedToolCalls(sessions) {
+  const messages = sessions.getMessages();
+  const pendingCallIds = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role === "assistant" && message.toolCalls) {
+      for (const toolCall of message.toolCalls) {
+        pendingCallIds.set(toolCall.toolCallId, { toolName: toolCall.toolName });
+      }
+    }
+    if (message.role === "tool" && message.toolCallId) {
+      pendingCallIds.delete(message.toolCallId);
+    }
+  }
+  for (const [toolCallId, { toolName }] of pendingCallIds) {
+    const toolMessage = {
+      id: crypto.randomUUID(),
+      role: "tool",
+      content: "Error: tool execution failed (result was not recorded)",
+      toolCallId,
+      toolName,
+      result: "Error: tool execution failed (result was not recorded)",
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await sessions.addMessage(toolMessage);
+  }
+}
+async function createSubAgentRunSession(options) {
+  const sessionId = options.parentSessionId ? `${options.parentSessionId}:sub:${crypto.randomUUID().slice(0, 8)}` : `sub:${crypto.randomUUID().slice(0, 8)}`;
+  await options.sessions.create({
+    id: sessionId,
+    cwd: options.cwd,
+    title: options.title ?? "Sub-agent task",
+    parentSessionId: options.parentSessionId
+  });
+  return sessionId;
+}
+function getVisibleSessionMessages(sessions) {
+  const leafId = sessions.getLeafId();
+  if (!leafId) {
+    return [];
+  }
+  const path = buildEntryPath(
+    sessions.getEntries(),
+    leafId
+  );
+  const visible = [];
+  let skipUntilId;
+  for (const entry of path) {
+    if (entry.type === "compaction") {
+      visible.push({
+        message: {
+          id: entry.id,
+          role: "system",
+          content: `## Previous Conversation Summary
+
+${entry.summary}`,
+          createdAt: new Date(entry.timestamp)
+        }
+      });
+      skipUntilId = entry.firstKeptEntryId;
+      continue;
+    }
+    if (skipUntilId && entry.id !== skipUntilId) {
+      continue;
+    }
+    if (entry.id === skipUntilId) {
+      skipUntilId = void 0;
+    }
+    if (entry.type === "message") {
+      visible.push({
+        message: deserializeMessage(entry.message)
+      });
+    }
+  }
+  return visible;
+}
+
+// src/agent/runtime-config.ts
+function createAgentToolRecord(tools) {
+  const toolRecord = {};
+  for (const [id, tool] of tools) {
+    toolRecord[id] = tool;
+  }
+  return toolRecord;
+}
+function getAgentContextStats(contextManager, messages) {
+  return contextManager.getStats(messages);
+}
+function buildFallbackCompactionSummary(messages) {
+  const excerpt = messages.map((message) => {
+    const role = message.role.toUpperCase();
+    const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+    return `[${role}] ${content}`;
+  }).join("\n\n");
+  const trimmed = excerpt.length > 8e3 ? `${excerpt.slice(0, 8e3)}
+
+...[truncated during compaction]` : excerpt;
+  return trimmed.length > 0 ? trimmed : "Earlier conversation context was compacted.";
+}
+async function compactAgentContext(options) {
+  const { contextManager, sessions } = options;
+  const visibleMessages = getVisibleSessionMessages(sessions);
+  const messages = visibleMessages.map((item) => item.message);
+  if (!contextManager.shouldPrune(messages)) {
+    return {
+      removedCount: 0,
+      tokensRemoved: 0,
+      summarized: false,
+      summary: void 0
+    };
+  }
+  const tokensBefore = estimateConversationTokens(messages);
+  let removedCount = 0;
+  let summarized = false;
+  let summary;
+  try {
+    const result = await contextManager.prune(messages);
+    removedCount = result.removedCount;
+    summarized = result.summarized;
+    summary = result.summary;
+  } catch {
+  }
+  if (removedCount === 0) {
+    removedCount = findCutPoint(
+      messages,
+      contextManager.getLimits().protectedTokens
+    );
+  }
+  if (removedCount === 0) {
+    return {
+      removedCount: 0,
+      tokensRemoved: 0,
+      summarized: false,
+      summary: void 0
+    };
+  }
+  const summaryText = summary ?? buildFallbackCompactionSummary(messages.slice(0, removedCount));
+  const keptMessages = messages.slice(removedCount);
+  const persistedMessages = [
+    {
+      id: "compaction-preview",
+      role: "system",
+      content: `## Previous Conversation Summary
+
+${summaryText}`,
+      createdAt: /* @__PURE__ */ new Date()
+    },
+    ...keptMessages
+  ];
+  const tokensAfter = estimateConversationTokens(persistedMessages);
+  await sessions.replaceWithCompaction({
+    summary: summaryText,
+    messages: keptMessages,
+    tokensBefore,
+    tokensAfter
+  });
+  return {
+    removedCount,
+    tokensRemoved: Math.max(0, tokensBefore - tokensAfter),
+    summarized,
+    summary: summaryText
+  };
+}
+async function buildAgentSystemPrompts(options) {
   const {
-    promptBuilder,
-    middlewareRunner,
-    systemOverride,
-    sessionId,
     config,
-    tools
-  } = params;
+    toolIds,
+    sessionId,
+    override,
+    promptBuilder,
+    middlewareRunner
+  } = options;
   if (promptBuilder) {
     const composedPrompt = await promptBuilder.build(
       {
         cwd: config.cwd,
         model: config.model,
-        toolNames: Object.keys(tools),
-        override: systemOverride,
+        toolNames: toolIds,
+        ...override ? { override } : {},
         sessionId
       },
       middlewareRunner
@@ -302,36 +625,88 @@ async function buildChatSystemPrompts(params) {
     return [composedPrompt];
   }
   const prompts = [config.systemPrompt];
-  if (systemOverride) {
-    prompts.push(systemOverride);
+  if (override) {
+    prompts.push(override);
   }
   return prompts;
 }
-
-// src/agent/chat-loop/usage.ts
-function accumulateUsage(current, next) {
-  if (!next) return current;
-  if (!current) {
-    return {
-      inputTokens: next.inputTokens ?? 0,
-      outputTokens: next.outputTokens ?? 0,
-      totalTokens: next.totalTokens ?? 0
-    };
-  }
+function createAgentTurnRuntimeConfig(options) {
+  const { config, telemetrySettings } = options;
   return {
-    inputTokens: (current.inputTokens ?? 0) + (next.inputTokens ?? 0),
-    outputTokens: (current.outputTokens ?? 0) + (next.outputTokens ?? 0),
-    totalTokens: (current.totalTokens ?? 0) + (next.totalTokens ?? 0)
-  };
-}
-
-// src/agent/chat-loop/loop.ts
-async function* runChatLoop(deps) {
-  yield* streamWithinScope(
-    {
-      kind: "turn",
-      name: "agent-turn",
-      sessionId: deps.sessionId
+    model: config.model,
+    cwd: config.cwd,
+    ...config.temperature !== void 0 ? { temperature: config.temperature } : {},
+    ...config.topP !== void 0 ? { topP: config.topP } : {},
+    ...config.maxOutputTokens !== void 0 ? { maxOutputTokens: config.maxOutputTokens } : {},
+    maxSteps: config.maxSteps,
+    ...config.doomLoopThreshold !== void 0 ? { doomLoopThreshold: config.doomLoopThreshold } : {},
+    ...config.enforceDoomLoop !== void 0 ? { enforceDoomLoop: config.enforceDoomLoop } : {},
+    ...config.onDoomLoop ? { onDoomLoop: config.onDoomLoop } : {},
+    ...config.contextWindow !== void 0 ? { contextWindow: config.contextWindow } : {},
+    ...config.streamProvider ? { streamProvider: config.streamProvider } : {},
+    ...telemetrySettings ? { telemetry: telemetrySettings } : {}
+  };
+}
+
+// src/agent/chat-loop/compaction.ts
+async function runAutoCompaction(params) {
+  const { contextManager, sessions } = params;
+  const messages = sessions.getMessages();
+  if (!contextManager.shouldPrune(messages)) {
+    return [];
+  }
+  const events = [{ type: "status", status: "processing" }];
+  const pruneResult = await compactAgentContext({
+    contextManager,
+    sessions
+  });
+  if (pruneResult.removedCount > 0 || pruneResult.summarized) {
+    const limits = contextManager.getLimits();
+    events.push({
+      type: "context-overflow",
+      inputTokens: estimateConversationTokens(messages),
+      limit: limits.contextWindow - limits.reserveTokens
+    });
+  }
+  return events;
+}
+
+// src/agent/chat-loop/prompts.ts
+async function buildChatSystemPrompts(params) {
+  return buildAgentSystemPrompts({
+    config: params.config,
+    toolIds: Object.keys(params.tools),
+    sessionId: params.sessionId,
+    override: params.systemOverride,
+    promptBuilder: params.promptBuilder,
+    middlewareRunner: params.middlewareRunner
+  });
+}
+
+// src/agent/chat-loop/usage.ts
+function accumulateUsage(current, next) {
+  if (!next) return current;
+  if (!current) {
+    return {
+      inputTokens: next.inputTokens ?? 0,
+      outputTokens: next.outputTokens ?? 0,
+      totalTokens: next.totalTokens ?? 0
+    };
+  }
+  return {
+    inputTokens: (current.inputTokens ?? 0) + (next.inputTokens ?? 0),
+    outputTokens: (current.outputTokens ?? 0) + (next.outputTokens ?? 0),
+    totalTokens: (current.totalTokens ?? 0) + (next.totalTokens ?? 0)
+  };
+}
+
+// src/agent/chat-loop/loop.ts
+async function* runChatLoop(deps) {
+  yield* streamWithinScope(
+    {
+      kind: "turn",
+      name: "agent-turn",
+      sessionId: deps.sessionId
     },
     (async function* () {
       const {
@@ -454,7 +829,7 @@ async function* runChatLoop(deps) {
         if (config.compaction?.auto !== false) {
           const compactionEvents = await runAutoCompaction({
             contextManager,
-            messages: sessions.getMessages()
+            sessions
           });
           for (const event of compactionEvents) {
             yield event;
@@ -484,6 +859,12 @@ async function* runChatLoop(deps) {
         };
       } catch (error) {
         chatError = error instanceof Error ? error : new Error(String(error));
+        const statusEvent = { type: "status", status: "error" };
+        middlewareRunner.emitEvent(statusEvent);
+        yield statusEvent;
+        const errorEvent = { type: "error", error: chatError };
+        middlewareRunner.emitEvent(errorEvent);
+        yield errorEvent;
         throw error;
       } finally {
         setIsStreaming(false);
@@ -500,272 +881,6 @@ async function* runChatLoop(deps) {
   );
 }
 
-// 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) {
@@ -783,279 +898,115 @@ function resolveChildPromptConfig(options) {
   if (forkOptions.systemPrompt) {
     return { systemPrompt: forkOptions.systemPrompt };
   }
-  if (forkOptions.prompt) {
-    return { prompt: forkOptions.prompt };
-  }
-  if (promptBuilder) {
-    return { prompt: parentPromptConfig ?? {} };
-  }
-  return { systemPrompt: parentSystemPrompt };
-}
-function resolveForkMiddleware(options, middlewareRunner) {
-  if (options.middleware) {
-    return options.middleware;
-  }
-  if (options.additionalMiddleware) {
-    return [
-      ...middlewareRunner.getMiddleware(),
-      ...options.additionalMiddleware
-    ];
-  }
-  return [...middlewareRunner.getMiddleware()];
-}
-function createForkedAgentConfig(options) {
-  const {
-    forkOptions,
-    parentConfig,
-    parentTools,
-    reasoningLevel,
-    host,
-    sessions,
-    mcpManager,
-    middlewareRunner,
-    promptBuilder
-  } = options;
-  const tools = forkOptions.tools ?? parentTools;
-  const childPrompt = resolveChildPromptConfig({
-    forkOptions,
-    promptBuilder,
-    parentPromptConfig: parentConfig.prompt,
-    parentSystemPrompt: parentConfig.systemPrompt
-  });
-  return {
-    model: forkOptions.model ?? parentConfig.model,
-    cwd: parentConfig.cwd,
-    host,
-    maxOutputTokens: parentConfig.maxOutputTokens,
-    maxSteps: forkOptions.maxSteps ?? parentConfig.maxSteps,
-    temperature: forkOptions.temperature ?? parentConfig.temperature,
-    topP: parentConfig.topP,
-    reasoningLevel: forkOptions.reasoningLevel ?? reasoningLevel,
-    ...childPrompt,
-    sessionManager: new SessionManager(sessions.getStorage()),
-    tools,
-    onDoomLoop: parentConfig.onDoomLoop,
-    enforceDoomLoop: parentConfig.enforceDoomLoop,
-    doomLoopThreshold: parentConfig.doomLoopThreshold,
-    compaction: parentConfig.compaction,
-    contextWindow: parentConfig.contextWindow,
-    mcp: mcpManager,
-    middleware: resolveForkMiddleware(forkOptions, middlewareRunner)
-  };
-}
-
-// src/agent/mcp.ts
-async function ensureMcpTools(state) {
-  if (!state.manager) {
-    return { connected: false, cachedTools: void 0 };
-  }
-  if (state.connected && state.cachedTools) {
-    return {
-      connected: state.connected,
-      cachedTools: state.cachedTools
-    };
-  }
-  const statuses = await state.manager.connect();
-  let connectedCount = 0;
-  for (const [name, status] of statuses) {
-    if (status.status === "connected") {
-      connectedCount++;
-    } else if (status.status === "error") {
-      console.warn(`[mcp] Failed to connect to ${name}: ${status.error}`);
-    }
-  }
-  if (connectedCount === 0 && statuses.size > 0) {
-    console.warn("[mcp] No MCP servers connected successfully");
-  }
-  const cachedTools = await state.manager.getTools();
-  return {
-    connected: true,
-    cachedTools
-  };
-}
-async function closeMcpManager(manager) {
-  if (manager) {
-    await manager.close();
-  }
-  return {
-    connected: false,
-    cachedTools: void 0
-  };
-}
-
-// src/agent/session.ts
-async function ensureSessionLoaded(options) {
-  const { sessionId, sessions, loadedSessions, cwd } = options;
-  if (loadedSessions.has(sessionId) && sessions.getSessionId() === sessionId) {
-    return;
-  }
-  const exists = await sessions.sessionExists(sessionId);
-  if (exists) {
-    await sessions.load(sessionId);
-  } else {
-    await sessions.create({ id: sessionId, cwd });
-  }
-  loadedSessions.add(sessionId);
-}
-async function repairOrphanedToolCalls(sessions) {
-  const messages = sessions.getMessages();
-  const pendingCallIds = /* @__PURE__ */ new Map();
-  for (const message of messages) {
-    if (message.role === "assistant" && message.toolCalls) {
-      for (const toolCall of message.toolCalls) {
-        pendingCallIds.set(toolCall.toolCallId, { toolName: toolCall.toolName });
-      }
-    }
-    if (message.role === "tool" && message.toolCallId) {
-      pendingCallIds.delete(message.toolCallId);
-    }
-  }
-  for (const [toolCallId, { toolName }] of pendingCallIds) {
-    const toolMessage = {
-      id: crypto.randomUUID(),
-      role: "tool",
-      content: "Error: tool execution failed (result was not recorded)",
-      toolCallId,
-      toolName,
-      result: "Error: tool execution failed (result was not recorded)",
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    await sessions.addMessage(toolMessage);
-  }
-}
-async function createSubAgentRunSession(options) {
-  const sessionId = options.parentSessionId ? `${options.parentSessionId}:sub:${crypto.randomUUID().slice(0, 8)}` : `sub:${crypto.randomUUID().slice(0, 8)}`;
-  await options.sessions.create({
-    id: sessionId,
-    cwd: options.cwd,
-    title: options.title ?? "Sub-agent task",
-    parentSessionId: options.parentSessionId
-  });
-  options.loadedSessions.add(sessionId);
-  return sessionId;
-}
-
-// src/agent/intervention.ts
-var InterventionController = class {
-  /** Immediate interventions — applied at the next step boundary */
-  immediate = [];
-  /** Deferred messages — held until the turn completes */
-  deferred = [];
-  /**
-   * Callback fired when an intervention is wired into a step.
-   * Set by the Agent before starting a chat turn, cleared after.
-   */
-  onApplied;
-  // ---------------------------------------------------------------------------
-  // Immediate interventions (mid-turn redirect)
-  // ---------------------------------------------------------------------------
-  /**
-   * Inject a message at the next LLM step boundary.
-   *
-   * The message is appended as a user message to the conversation
-   * before the next LLM call in the current multi-step turn. The
-   * LLM will see it and can adjust its behavior accordingly.
-   *
-   * Safe to call from any async context while `chat()` is running.
-   * If called when no turn is active, the message will be picked up
-   * by the first step of the next `chat()` call.
-   *
-   * @param message - The user message to inject
-   * @returns Intervention ID for tracking
-   */
-  intervene(message) {
-    const id = crypto.randomUUID();
-    this.immediate.push(
-      Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() })
-    );
-    return id;
-  }
-  /**
-   * Drain and return all pending immediate interventions.
-   * The internal queue is cleared atomically.
-   *
-   * @internal Called by the LLM stream's `prepareStep` hook
-   */
-  drainImmediate() {
-    if (this.immediate.length === 0) return [];
-    return this.immediate.splice(0);
-  }
-  /** Whether there are pending immediate interventions */
-  get hasPending() {
-    return this.immediate.length > 0;
-  }
-  /** Number of pending immediate interventions */
-  get pendingCount() {
-    return this.immediate.length;
-  }
-  // ---------------------------------------------------------------------------
-  // Deferred messages (after-turn follow-ups)
-  // ---------------------------------------------------------------------------
-  /**
-   * Queue a message for after the current turn completes.
-   *
-   * Unlike `intervene()`, this does **not** inject mid-turn. The
-   * message is held and available via `drainDeferred()` after
-   * `chat()` finishes. The consumer decides whether to send it
-   * as a new turn.
-   *
-   * @param message - The message to queue
-   * @returns Intervention ID for tracking
-   */
-  queueNext(message) {
-    const id = crypto.randomUUID();
-    this.deferred.push(
-      Object.freeze({ id, message, createdAt: /* @__PURE__ */ new Date() })
-    );
-    return id;
-  }
-  /**
-   * Drain and return all deferred messages.
-   * The internal queue is cleared atomically.
-   */
-  drainDeferred() {
-    if (this.deferred.length === 0) return [];
-    return this.deferred.splice(0);
+  if (forkOptions.prompt) {
+    return { prompt: forkOptions.prompt };
   }
-  /** Whether there are deferred messages */
-  get hasDeferred() {
-    return this.deferred.length > 0;
+  if (promptBuilder) {
+    return { prompt: parentPromptConfig ?? {} };
   }
-  /** Number of deferred messages */
-  get deferredCount() {
-    return this.deferred.length;
+  return { systemPrompt: parentSystemPrompt };
+}
+function resolveForkMiddleware(options, middlewareRunner) {
+  if (options.middleware) {
+    return options.middleware;
   }
-  // ---------------------------------------------------------------------------
-  // Housekeeping
-  // ---------------------------------------------------------------------------
-  /** Clear all queues (immediate + deferred) */
-  clear() {
-    this.immediate.length = 0;
-    this.deferred.length = 0;
+  if (options.additionalMiddleware) {
+    return [
+      ...middlewareRunner.getMiddleware(),
+      ...options.additionalMiddleware
+    ];
   }
-  /** Reset the controller for a new turn (clears onApplied, keeps queues) */
-  resetCallbacks() {
-    this.onApplied = void 0;
+  return [...middlewareRunner.getMiddleware()];
+}
+function createForkedAgentConfig(options) {
+  const {
+    forkOptions,
+    parentConfig,
+    parentTools,
+    reasoningLevel,
+    host,
+    ownsHost,
+    sessions,
+    mcpManager,
+    middlewareRunner,
+    promptBuilder
+  } = options;
+  const tools = forkOptions.tools ?? parentTools;
+  const childPrompt = resolveChildPromptConfig({
+    forkOptions,
+    promptBuilder,
+    parentPromptConfig: parentConfig.prompt,
+    parentSystemPrompt: parentConfig.systemPrompt
+  });
+  return {
+    model: forkOptions.model ?? parentConfig.model,
+    cwd: parentConfig.cwd,
+    ...ownsHost ? {} : { host },
+    maxOutputTokens: parentConfig.maxOutputTokens,
+    maxSteps: forkOptions.maxSteps ?? parentConfig.maxSteps,
+    temperature: forkOptions.temperature ?? parentConfig.temperature,
+    topP: parentConfig.topP,
+    reasoningLevel: forkOptions.reasoningLevel ?? reasoningLevel,
+    ...childPrompt,
+    sessionManager: new SessionManager(sessions.getStorage()),
+    tools,
+    onDoomLoop: parentConfig.onDoomLoop,
+    enforceDoomLoop: parentConfig.enforceDoomLoop,
+    doomLoopThreshold: parentConfig.doomLoopThreshold,
+    compaction: parentConfig.compaction,
+    contextWindow: parentConfig.contextWindow,
+    mcp: mcpManager,
+    middleware: resolveForkMiddleware(forkOptions, middlewareRunner)
+  };
+}
+
+// src/agent/mcp-bridge.ts
+async function ensureMcpTools(state) {
+  if (!state.manager) {
+    return { connected: false, cachedTools: void 0 };
   }
-};
+  if (state.connected && state.cachedTools) {
+    return {
+      connected: state.connected,
+      cachedTools: state.cachedTools
+    };
+  }
+  const statuses = await state.manager.connect();
+  let connectedCount = 0;
+  for (const [name, status] of statuses) {
+    if (status.status === "connected") {
+      connectedCount++;
+    } else if (status.status === "error") {
+      console.warn(`[mcp] Failed to connect to ${name}: ${status.error}`);
+    }
+  }
+  if (connectedCount === 0 && statuses.size > 0) {
+    console.warn("[mcp] No MCP servers connected successfully");
+  }
+  const cachedTools = await state.manager.getTools();
+  return {
+    connected: true,
+    cachedTools
+  };
+}
+async function closeMcpManager(manager) {
+  if (manager) {
+    await manager.close();
+  }
+  return {
+    connected: false,
+    cachedTools: void 0
+  };
+}
 
-// 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 = extractModelId(model);
+  if (!modelId || modelId === "[object Object]") return false;
   const patterns = customPatterns ?? DEFAULT_CUSTOM_STREAM_MODELS;
   return patterns.some((pattern) => modelId.includes(pattern));
 }
@@ -1070,7 +1021,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 = extractModelId(model);
     if (modelId) {
       const streamConfig = {
         apiKey: process.env.OPENAI_API_KEY,
@@ -1115,10 +1066,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
   };
 }
@@ -1145,17 +1097,39 @@ function createAgentState(config) {
 }
 function createAgentContextManager(config) {
   const compactionConfig = config.compaction ?? {};
+  const modelId = extractModelId(config.model);
+  const inferredWindow = inferContextWindow(modelId);
+  const contextWindow = config.contextWindow ?? inferredWindow ?? DEFAULT_CONTEXT_LIMITS.contextWindow;
   return new ContextManager({
     limits: {
-      contextWindow: config.contextWindow ?? DEFAULT_CONTEXT_LIMITS.contextWindow,
-      reserveTokens: DEFAULT_CONTEXT_LIMITS.reserveTokens,
-      protectedTokens: compactionConfig.protectedTokens ?? DEFAULT_CONTEXT_LIMITS.protectedTokens,
-      pruneMinimum: compactionConfig.pruneMinimum ?? DEFAULT_CONTEXT_LIMITS.pruneMinimum
+      contextWindow,
+      ...resolveAgentContextLimits(contextWindow, compactionConfig)
     },
     model: compactionConfig.summaryModel ?? config.model,
     summaryPrompt: compactionConfig.summaryPrompt
   });
 }
+function resolveAgentContextLimits(contextWindow, compactionConfig = {}) {
+  const proportionalReserve = Math.round(contextWindow * 0.12);
+  const reserveTokens = contextWindow >= 64e3 ? Math.min(32e3, Math.max(8e3, proportionalReserve)) : Math.min(
+    Math.max(1024, Math.round(contextWindow * 0.25)),
+    Math.max(512, proportionalReserve)
+  );
+  const usableWindow = Math.max(512, contextWindow - reserveTokens);
+  const requestedProtected = compactionConfig.protectedTokens ?? DEFAULT_CONTEXT_LIMITS.protectedTokens;
+  const requestedPruneMinimum = compactionConfig.pruneMinimum ?? DEFAULT_CONTEXT_LIMITS.pruneMinimum;
+  return {
+    reserveTokens,
+    protectedTokens: Math.min(
+      requestedProtected,
+      Math.max(512, Math.round(usableWindow * 0.6))
+    ),
+    pruneMinimum: Math.min(
+      requestedPruneMinimum,
+      Math.max(256, Math.round(usableWindow * 0.5))
+    )
+  };
+}
 function createMiddlewareSetup(input, config) {
   let effectiveMiddleware = input.middleware;
   let telemetrySettings;
@@ -1200,78 +1174,13 @@ function createAgentSetup(input) {
     ...promptBuilder ? { promptBuilder } : {},
     interventionCtrl: new InterventionController(),
     host: input.host ?? localHost(config.cwd),
+    ownsHost: input.host === void 0,
     middlewareRunner: middlewareSetup.middlewareRunner,
     ...middlewareSetup.telemetrySettings ? { telemetrySettings: middlewareSetup.telemetrySettings } : {},
     ...middlewareSetup.tracingShutdown ? { tracingShutdown: middlewareSetup.tracingShutdown } : {}
   };
 }
 
-// src/agent/runtime-config.ts
-function createAgentToolRecord(tools) {
-  const toolRecord = {};
-  for (const [id, tool] of tools) {
-    toolRecord[id] = tool;
-  }
-  return toolRecord;
-}
-function getAgentContextStats(contextManager, messages) {
-  return contextManager.getStats(messages);
-}
-async function compactAgentContext(contextManager, messages) {
-  const result = await contextManager.prune(messages);
-  return {
-    removedCount: result.removedCount,
-    tokensRemoved: result.tokensRemoved,
-    summarized: result.summarized,
-    summary: result.summary
-  };
-}
-async function buildAgentSystemPrompts(options) {
-  const {
-    config,
-    toolIds,
-    sessionId,
-    override,
-    promptBuilder,
-    middlewareRunner
-  } = options;
-  if (promptBuilder) {
-    const composedPrompt = await promptBuilder.build(
-      {
-        cwd: config.cwd,
-        model: config.model,
-        toolNames: toolIds,
-        ...override ? { override } : {},
-        sessionId
-      },
-      middlewareRunner
-    );
-    return [composedPrompt];
-  }
-  const prompts = [config.systemPrompt];
-  if (override) {
-    prompts.push(override);
-  }
-  return prompts;
-}
-function createAgentTurnRuntimeConfig(options) {
-  const { config, telemetrySettings } = options;
-  return {
-    model: config.model,
-    cwd: config.cwd,
-    ...config.temperature !== void 0 ? { temperature: config.temperature } : {},
-    ...config.topP !== void 0 ? { topP: config.topP } : {},
-    ...config.maxOutputTokens !== void 0 ? { maxOutputTokens: config.maxOutputTokens } : {},
-    maxSteps: config.maxSteps,
-    ...config.doomLoopThreshold !== void 0 ? { doomLoopThreshold: config.doomLoopThreshold } : {},
-    ...config.enforceDoomLoop !== void 0 ? { enforceDoomLoop: config.enforceDoomLoop } : {},
-    ...config.onDoomLoop ? { onDoomLoop: config.onDoomLoop } : {},
-    ...config.contextWindow !== void 0 ? { contextWindow: config.contextWindow } : {},
-    ...config.streamProvider ? { streamProvider: config.streamProvider } : {},
-    ...telemetrySettings ? { telemetry: telemetrySettings } : {}
-  };
-}
-
 // src/agent/instance.ts
 function createAgent(config) {
   return new Agent(config);
@@ -1280,7 +1189,6 @@ var Agent = class _Agent {
   config;
   tools;
   sessions;
-  loadedSessions = /* @__PURE__ */ new Set();
   state;
   /** Context manager for overflow detection and compaction */
   contextManager;
@@ -1294,6 +1202,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) */
@@ -1302,12 +1212,22 @@ var Agent = class _Agent {
   interventionCtrl;
   /** Execution environment for tool operations */
   host;
+  /** Whether the agent owns the host and can safely recreate it on cwd changes */
+  ownsHost;
   /** Middleware runner for lifecycle hooks */
   middlewareRunner;
   /** AI SDK telemetry settings (auto-created from `tracing` config) */
   telemetrySettings;
   /** Tracing shutdown function (from `tracing` config auto-setup) */
   tracingShutdown;
+  /** Multi-consumer event dispatch */
+  _signal;
+  /** Number of active turns across all sessions */
+  activeTurnCount = 0;
+  /** Active turn intervention controllers, keyed by turn id */
+  activeTurns = /* @__PURE__ */ new Map();
+  /** Per-session turn queue to prevent concurrent writes to the same history */
+  sessionLocks = /* @__PURE__ */ new Map();
   constructor(config) {
     const setup = createAgentSetup(config);
     this.config = setup.config;
@@ -1320,9 +1240,21 @@ var Agent = class _Agent {
     this.promptBuilder = setup.promptBuilder;
     this.interventionCtrl = setup.interventionCtrl;
     this.host = setup.host;
+    this.ownsHost = setup.ownsHost;
     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() {
@@ -1342,7 +1274,7 @@ var Agent = class _Agent {
   }
   /** Is currently streaming */
   get isStreaming() {
-    return this.state.isStreaming;
+    return this.activeTurnCount > 0;
   }
   /** Current reasoning level */
   get reasoningLevel() {
@@ -1369,6 +1301,90 @@ 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);
+        }
+      }
+    }
+  }
+  resetPromptScopedTools() {
+    this.tools.delete("skill");
+    this.tools.delete("skill_resource");
+    this.skillToolsResolved = false;
+  }
+  createSessionManager() {
+    return new SessionManager(this.sessions.getStorage());
+  }
+  async acquireSessionLock(sessionId) {
+    const previous = this.sessionLocks.get(sessionId) ?? Promise.resolve();
+    let releaseLock;
+    const current = new Promise((resolve) => {
+      releaseLock = resolve;
+    });
+    const chain = previous.catch(() => void 0).then(() => current);
+    this.sessionLocks.set(sessionId, chain);
+    await previous.catch(() => void 0);
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      releaseLock();
+      if (this.sessionLocks.get(sessionId) === chain) {
+        this.sessionLocks.delete(sessionId);
+      }
+    };
+  }
+  getActiveInterventionController() {
+    const active = Array.from(this.activeTurns.values());
+    if (active.length === 0) {
+      return void 0;
+    }
+    if (active.length > 1) {
+      throw new Error(
+        "Interventions are ambiguous while multiple agent turns are active. Use separate Agent instances or wait for one turn to finish."
+      );
+    }
+    return active[0].interventionCtrl;
+  }
+  getInterventionControllerForTurn() {
+    const activeController = this.getActiveInterventionController();
+    return activeController ?? this.interventionCtrl;
+  }
+  createTurnInterventionController() {
+    return this.activeTurns.size === 0 ? this.interventionCtrl : new InterventionController();
+  }
+  releaseTurnInterventions(controller) {
+    if (controller === this.interventionCtrl) {
+      controller.resetCallbacks();
+      return;
+    }
+    this.interventionCtrl.adoptImmediate(controller.drainImmediate());
+    this.interventionCtrl.adoptDeferred(controller.drainDeferred());
+    controller.resetCallbacks();
+  }
+  syncStreamingState(active) {
+    this.activeTurnCount = Math.max(
+      0,
+      this.activeTurnCount + (active ? 1 : -1)
+    );
+    this.state.isStreaming = this.activeTurnCount > 0;
+  }
+  async syncSessionView(sessionId) {
+    if (!await this.sessions.sessionExists(sessionId)) {
+      return;
+    }
+    await this.sessions.load(sessionId);
+  }
   /**
    * Ensure MCP is connected and return tools
    * Lazy initialization - only connects on first use
@@ -1392,8 +1408,8 @@ var Agent = class _Agent {
    * `MissingToolResultsError`. This method detects orphaned tool-call IDs
    * and adds placeholder `tool` messages so the history is valid again.
    */
-  async repairOrphanedToolCalls() {
-    await repairOrphanedToolCalls(this.sessions);
+  async repairOrphanedToolCalls(sessions) {
+    await repairOrphanedToolCalls(sessions);
   }
   /**
    * Convert internal {@link Message} array to Vercel AI SDK {@link ModelMessage} format.
@@ -1419,46 +1435,74 @@ var Agent = class _Agent {
    * @yields {AgentEvent} Events as they occur during processing
    */
   async *chat(sessionId, message, options) {
-    await this.ensureSession(sessionId);
-    const abort = options?.abort ?? new AbortController().signal;
+    const releaseSessionLock = await this.acquireSessionLock(sessionId);
+    const sessions = this.createSessionManager();
     const turnId = `${sessionId}-turn-${++this.turnCounter}`;
-    this.turnTracker.startTurn(turnId);
-    await this.repairOrphanedToolCalls();
-    const mcpTools = await this.ensureMCPConnected();
-    yield* runChatLoop({
-      sessionId,
-      message,
-      abort,
-      systemOverride: options?.system,
-      sessions: this.sessions,
-      tools: createAgentToolRecord(this.tools),
-      config: this.config,
-      turnTracker: this.turnTracker,
-      interventionCtrl: this.interventionCtrl,
-      middlewareRunner: this.middlewareRunner,
-      contextManager: this.contextManager,
-      rememberedDoomLoopTools: this.rememberedDoomLoopTools,
-      reasoningLevel: this.state.reasoningLevel,
-      promptBuilder: this.promptBuilder,
-      host: this.host,
-      mcpTools,
-      telemetrySettings: this.telemetrySettings,
-      toModelMessages: this.toModelMessages.bind(this),
-      setIsStreaming: (v) => {
-        this.state.isStreaming = v;
+    let turnTracker;
+    let interventionCtrl = this.interventionCtrl;
+    let streamingStateActive = false;
+    let turnRegistered = false;
+    try {
+      await this.ensureSkillTools();
+      const abort = options?.abort ?? new AbortController().signal;
+      turnTracker = createTurnTracker({ cwd: this.config.cwd });
+      interventionCtrl = this.createTurnInterventionController();
+      this.activeTurns.set(turnId, { sessionId, interventionCtrl });
+      turnRegistered = true;
+      await ensureSessionLoaded({
+        sessionId,
+        sessions,
+        cwd: this.config.cwd
+      });
+      turnTracker.startTurn(turnId);
+      await this.repairOrphanedToolCalls(sessions);
+      const mcpTools = await this.ensureMCPConnected();
+      const loop = runChatLoop({
+        sessionId,
+        message,
+        abort,
+        systemOverride: options?.system,
+        sessions,
+        tools: createAgentToolRecord(this.tools),
+        config: this.config,
+        turnTracker,
+        interventionCtrl,
+        middlewareRunner: this.middlewareRunner,
+        contextManager: this.contextManager,
+        rememberedDoomLoopTools: this.rememberedDoomLoopTools,
+        reasoningLevel: this.state.reasoningLevel,
+        promptBuilder: this.promptBuilder,
+        host: this.host,
+        mcpTools,
+        telemetrySettings: this.telemetrySettings,
+        toModelMessages: this.toModelMessages.bind(this),
+        setIsStreaming: (value) => {
+          if (value === streamingStateActive) return;
+          streamingStateActive = value;
+          this.syncStreamingState(value);
+        }
+      });
+      for await (const event of loop) {
+        this._signal.emit(event);
+        yield event;
       }
-    });
-  }
-  /**
-   * Ensure a session is loaded or created
-   */
-  async ensureSession(sessionId) {
-    await ensureSessionLoaded({
-      sessionId,
-      sessions: this.sessions,
-      loadedSessions: this.loadedSessions,
-      cwd: this.config.cwd
-    });
+    } finally {
+      try {
+        if (streamingStateActive) {
+          this.syncStreamingState(false);
+        }
+        if (turnRegistered) {
+          this.activeTurns.delete(turnId);
+        }
+        this.releaseTurnInterventions(interventionCtrl);
+        if (turnRegistered && turnTracker) {
+          this.turnTracker = turnTracker;
+        }
+        await this.syncSessionView(sessionId);
+      } finally {
+        releaseSessionLock();
+      }
+    }
   }
   /**
    * Send a message and wait for the complete response (non-streaming).
@@ -1534,7 +1578,6 @@ var Agent = class _Agent {
   }
   /** Delete a session */
   async deleteSession(sessionId) {
-    this.loadedSessions.delete(sessionId);
     return this.sessions.deleteSession(sessionId);
   }
   /** List all sessions */
@@ -1584,10 +1627,10 @@ var Agent = class _Agent {
    * @returns Pruning result with details about what was removed/summarized
    */
   async compactContext() {
-    return await compactAgentContext(
-      this.contextManager,
-      this.sessions.getMessages()
-    );
+    return await compactAgentContext({
+      contextManager: this.contextManager,
+      sessions: this.sessions
+    });
   }
   /**
    * Clear remembered doom loop tools.
@@ -1617,6 +1660,8 @@ var Agent = class _Agent {
    *
    * If called when no turn is active, the message will be picked up
    * by the first step of the next `chat()` call.
+   * If multiple turns are active concurrently, this throws because the
+   * target turn would be ambiguous.
    *
    * @param message - The user message to inject mid-turn
    * @returns Intervention ID for tracking
@@ -1638,7 +1683,7 @@ var Agent = class _Agent {
    * ```
    */
   intervene(message) {
-    return this.interventionCtrl.intervene(message);
+    return this.getInterventionControllerForTurn().intervene(message);
   }
   /**
    * Queue a message for after the current turn completes.
@@ -1648,6 +1693,9 @@ var Agent = class _Agent {
    * `chat()` finishes. The consumer decides whether to send it as a
    * new turn.
    *
+   * If multiple turns are active concurrently, this throws because the
+   * target turn would be ambiguous.
+   *
    * @param message - The message to queue
    * @returns Intervention ID for tracking
    *
@@ -1670,15 +1718,15 @@ var Agent = class _Agent {
    * ```
    */
   queueNext(message) {
-    return this.interventionCtrl.queueNext(message);
+    return this.getInterventionControllerForTurn().queueNext(message);
   }
   /** Whether there are deferred messages queued for after the turn */
   hasQueuedNext() {
-    return this.interventionCtrl.hasDeferred;
+    return this.getInterventionControllerForTurn().hasDeferred;
   }
   /** Drain and return all deferred messages (clears the queue) */
   drainQueuedNext() {
-    return this.interventionCtrl.drainDeferred();
+    return this.getInterventionControllerForTurn().drainDeferred();
   }
   /**
    * Get the raw intervention controller for advanced use cases.
@@ -1690,7 +1738,7 @@ var Agent = class _Agent {
    * @internal
    */
   getInterventionController() {
-    return this.interventionCtrl;
+    return this.getInterventionControllerForTurn();
   }
   // ============================================================================
   // Turn Tracking
@@ -1767,17 +1815,39 @@ var Agent = class _Agent {
     this.config.systemPrompt = prompt;
     this.state.systemPrompt = prompt;
     this.promptBuilder = void 0;
+    this.resetPromptScopedTools();
   }
   /** Update working directory */
   setCwd(cwd) {
     this.config.cwd = cwd;
     this.state.cwd = cwd;
+    this.turnTracker = createTurnTracker({ cwd });
+    if (this.ownsHost) {
+      this.host = localHost(cwd);
+    }
+    this.resetPromptScopedTools();
     this.promptBuilder?.clearCache();
   }
   /** Update model */
   setModel(model) {
     this.config.model = model;
     this.state.model = model;
+    if (this.config.compaction?.summaryModel === void 0) {
+      this.contextManager.setModel(model);
+    }
+    if (this.config.contextWindow === void 0) {
+      const modelId = extractModelId(model);
+      const inferred = inferContextWindow(modelId);
+      if (inferred) {
+        this.contextManager.setLimits({
+          contextWindow: inferred,
+          ...resolveAgentContextLimits(
+            inferred,
+            this.config.compaction
+          )
+        });
+      }
+    }
   }
   /**
    * Get the prompt builder (when using pipeline mode).
@@ -1815,6 +1885,7 @@ var Agent = class _Agent {
    * runtimes can start durable turns without duplicating prompt assembly.
    */
   async buildSystemPrompts(sessionId, override) {
+    await this.ensureSkillTools();
     return await buildAgentSystemPrompts({
       config: this.config,
       toolIds: Array.from(this.tools.keys()),
@@ -1890,6 +1961,7 @@ var Agent = class _Agent {
         parentTools: Array.from(this.tools.values()),
         reasoningLevel: this.state.reasoningLevel,
         host: this.host,
+        ownsHost: this.ownsHost,
         sessions: this.sessions,
         mcpManager: this.mcpManager,
         middlewareRunner: this.middlewareRunner,
@@ -1941,9 +2013,9 @@ var Agent = class _Agent {
    * ```
    */
   async run(options) {
+    const sessions = this.createSessionManager();
     const sessionId = await createSubAgentRunSession({
-      sessions: this.sessions,
-      loadedSessions: this.loadedSessions,
+      sessions,
       cwd: this.config.cwd,
       parentSessionId: options.parentSessionId,
       title: options.title
@@ -1995,6 +2067,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();
     }
@@ -2011,6 +2084,7 @@ async function runConcurrent(tasks, options) {
   let currentIndex = 0;
   async function runNext() {
     while (currentIndex < tasks.length) {
+      if (options?.abort?.aborted) break;
       const index = currentIndex++;
       const task = tasks[index];
       results[index] = await task.agent.run({
@@ -2061,11 +2135,14 @@ export {
   InterventionController,
   LLM,
   LLMError,
+  LayeredSettings,
+  LocalSignal,
   MAX_BYTES,
   MAX_LINES,
   MemoryStorage,
   MiddlewareRunner,
   ModelCapabilityResolver,
+  NullSettings,
   OUTPUT_TOKEN_MAX,
   PRIORITY_BASE,
   PRIORITY_CUSTOM,
@@ -2075,6 +2152,8 @@ export {
   PRIORITY_SKILLS,
   PRUNE_PROTECTED_TOOLS,
   PatternCapabilitySource,
+  PluginEventBus,
+  PluginRegistry,
   Presets,
   PromptBuilder,
   RemoteCapabilityFetcher,
@@ -2085,12 +2164,14 @@ export {
   SessionManager,
   SkillRegistry,
   SourcePriority,
+  StaticSettings,
   SubAgentTracker,
   TRUNCATE_DIR,
   TRUNCATE_GLOB,
   Tool,
   ToolRegistry,
   TurnChangeTracker,
+  ValidatedSettings,
   advanceAgentTurnState,
   applyAgentWorkflowCommitResult,
   applyAgentWorkflowModelStepResult,
@@ -2138,6 +2219,7 @@ export {
   createResolver,
   createRetryHandler,
   createRetryState,
+  createScope,
   createSkillRegistry,
   createSkillResourceTool,
   createSkillTool,
@@ -2145,13 +2227,17 @@ export {
   createSubAgentTools,
   createTelemetryConfig,
   createTurnTracker,
+  currentScope,
   defaultAgentTaskCheckpointStrategy,
   defaultRegistry,
+  definePlugin,
   defineServer,
   defineTool,
   deserializeMessage,
   detectModelFamily,
+  discoverAgentProfiles,
   discoverInstructions,
+  discoverPlugins,
   discoverSkills,
   dockerHost,
   emptySkillRegistry,
@@ -2184,6 +2270,8 @@ export {
   getLeafId,
   getModelId,
   getNetworkStatus,
+  getPluginLoader,
+  getProjectAgentsDir,
   getProjectId,
   getProjectSessionsDir,
   getProviderCompatibility,
@@ -2195,15 +2283,20 @@ export {
   getSessionsDir,
   getTemplate,
   getToolRisk,
+  getUserAgentsDir,
   hasStreamProviderFactory,
   httpServer,
+  inferContextWindow,
   inferProvider,
   inferResourceType,
   isContextOverflowing,
+  isDefinedPlugin,
+  isMarkdownProfile,
   isRetryable,
   isRetryableCategory,
   likelySupportsReasoning,
   loadGlobalInstructions,
+  loadPluginModule,
   loadResourceContent,
   loadSkillContent,
   loadSkillMetadata,
@@ -2212,9 +2305,12 @@ export {
   needsCustomStreamProvider,
   normalizeToolReplayPolicy,
   otelMiddleware,
+  parseAgentFrontmatter,
   parseFrontmatter,
   parseJSONL,
+  parseMarkdownAgent,
   parseRetryDelay,
+  parseToolSpec,
   plan,
   planNextAgentWorkflowOperation,
   prepareModelStep,
@@ -2225,8 +2321,12 @@ export {
   pruneToolResults,
   quick,
   recordAgentWorkflowReplayDecision,
+  resetFrameworkAliases,
+  resetPluginLoader,
+  resolveFrameworkAliases,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,
+  restoreScope,
   review,
   runChatLoop,
   runConcurrent,
@@ -2240,6 +2340,7 @@ export {
   sleep,
   snapshotAgentWorkflowMessage,
   snapshotAgentWorkflowMessages,
+  snapshotScope,
   sseServer,
   stdioServer,
   stream,
@@ -2248,10 +2349,12 @@ export {
   summarizeEnvironment,
   supportsReasoning,
   supportsReasoningSync,
+  toAgentProfile,
   toJSONL,
   toJSONLBatch,
   truncateOutput,
   watch,
   withFileTracking,
-  withRetry
+  withRetry,
+  withinScope
 };