@cuylabs/agent-core 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,17 +1,12 @@
 import {
   AgentTurnEngine,
   ContextOverflowError,
-  DEFAULT_RETRY_CONFIG,
   DoomLoopError,
-  LLM,
-  LLMError,
-  OUTPUT_TOKEN_MAX,
   advanceAgentTurnState,
   applyAgentWorkflowCommitResult,
   applyAgentWorkflowModelStepResult,
   applyAgentWorkflowToolBatchResult,
   applyAgentWorkflowToolCallResult,
-  calculateDelay,
   cloneAgentWorkflowTurnState,
   commitOutput,
   commitStep,
@@ -21,29 +16,21 @@ import {
   createAgentTurnState,
   createAgentTurnStepCommitBatch,
   createAgentWorkflowTurnState,
-  createRetryHandler,
-  createRetryState,
   defaultAgentTaskCheckpointStrategy,
   failAgentTurnState,
   failAgentWorkflowTurnState,
-  getErrorCategory,
-  getRetryDelay,
-  isRetryable,
-  isRetryableCategory,
   planNextAgentWorkflowOperation,
   prepareModelStep,
+  processStepStream,
   processStream,
   recordAgentWorkflowReplayDecision,
   restoreAgentWorkflowMessage,
   restoreAgentWorkflowMessages,
   runModelStep,
   runToolBatch,
-  shouldRetry,
-  sleep,
   snapshotAgentWorkflowMessage,
-  snapshotAgentWorkflowMessages,
-  withRetry
-} from "./chunk-IMGQOTU2.js";
+  snapshotAgentWorkflowMessages
+} from "./chunk-3HNO5SVI.js";
 import {
   createSkillResourceTool,
   createSkillTool,
@@ -54,18 +41,25 @@ import {
   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,9 +72,6 @@ import {
   ToolRegistry,
   defaultRegistry
 } from "./chunk-SDSBEQXG.js";
-import {
-  executeAgentToolCall
-} from "./chunk-FG4MD5MU.js";
 import {
   MAX_BYTES,
   MAX_LINES,
@@ -98,14 +89,10 @@ import {
   createCheckpointManager,
   createTurnTracker
 } from "./chunk-VBWWUHWI.js";
-import {
-  extractFilePathsFromArgs,
-  shouldCaptureBaseline,
-  withFileTracking
-} from "./chunk-VEKUXUVF.js";
 import {
   ContextManager,
   DEFAULT_CONTEXT_LIMITS,
+  PRUNE_PROTECTED_TOOLS,
   estimateConversationTokens,
   estimateMessageTokens,
   estimateTokens,
@@ -115,14 +102,65 @@ import {
   pruneContext,
   pruneToolResults,
   shouldPruneContext
-} from "./chunk-QAQADS4X.js";
+} from "./chunk-BNSHUWCV.js";
 import {
-  createMCPManager,
-  defineServer,
-  httpServer,
-  sseServer,
-  stdioServer
-} from "./chunk-ZXAKHMWH.js";
+  dockerHost,
+  localHost
+} from "./chunk-VNQBHPCT.js";
+import {
+  DEFAULT_MAX_OUTPUT_TOKENS,
+  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";
+import {
+  EXTENDED_LEVELS,
+  FIXED_LEVELS,
+  STANDARD_LEVELS,
+  buildAnthropicOptions,
+  buildBedrockOptions,
+  buildGoogleOptions,
+  buildGroqOptions,
+  buildOpenAIOptions,
+  buildOpenRouterOptions,
+  buildReasoningOptions,
+  buildReasoningOptionsSync,
+  buildXAIOptions,
+  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,
@@ -131,11 +169,39 @@ import {
   createApprovalHandler,
   createTelemetryConfig,
   getToolRisk,
-  otelMiddleware
-} from "./chunk-OTUGSCED.js";
+  otelMiddleware,
+  promptCacheMiddleware
+} from "./chunk-CDTV2UYU.js";
 import {
-  createResolver
-} from "./chunk-6TDTQJ4P.js";
+  CacheCapabilitySource,
+  CapabilityCache,
+  DEFAULT_RESOLVER_OPTIONS,
+  ModelCapabilityResolver,
+  PatternCapabilitySource,
+  RemoteCapabilityFetcher,
+  RemoteCapabilitySource,
+  SourcePriority,
+  applyCapabilityOverride,
+  configureResolver,
+  createResolver,
+  extractModelId,
+  extractProvider,
+  findCapabilityOverride,
+  getDefaultResolver,
+  getModelId,
+  getNetworkStatus,
+  getProviderCompatibility,
+  getProviderId,
+  inferProvider,
+  likelySupportsReasoning
+} from "./chunk-QGOGIP7T.js";
+import {
+  createMCPManager,
+  defineServer,
+  httpServer,
+  sseServer,
+  stdioServer
+} from "./chunk-ZXAKHMWH.js";
 import {
   DEFAULT_INSTRUCTION_PATTERNS,
   DEFAULT_MAX_DEPTH,
@@ -173,24 +239,6 @@ import {
   loadSkillMetadata,
   parseFrontmatter
 } from "./chunk-LRHOS4ZN.js";
-import {
-  buildReasoningOptions,
-  buildReasoningOptionsSync,
-  getReasoningConfig,
-  getReasoningConfigSync,
-  supportsReasoning,
-  supportsReasoningSync
-} from "./chunk-X635CM2F.js";
-import {
-  ModelCapabilityResolver,
-  configureResolver,
-  getDefaultResolver,
-  getNetworkStatus
-} from "./chunk-QWFMX226.js";
-import {
-  getModelId,
-  getProviderId
-} from "./chunk-DWYX7ASF.js";
 
 // src/agent/chat-loop/commit.ts
 function createChatLoopCommitBatchApplier(params) {
@@ -279,164 +327,177 @@ 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 };
-  } 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
@@ -874,7 +935,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 = [];
@@ -978,400 +1039,6 @@ 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
 var DEFAULT_CUSTOM_STREAM_MODELS = [
   "computer-use-preview",
@@ -1819,6 +1486,7 @@ var Agent = class _Agent {
           break;
         case "complete":
           if (event.usage) usage = event.usage;
+          if (event.output !== void 0) response = event.output;
           break;
         case "error":
           throw event.error;
@@ -2365,6 +2033,8 @@ export {
   AgentTurnEngine,
   ApprovalDeniedError,
   ApprovalTimeoutError,
+  CacheCapabilitySource,
+  CapabilityCache,
   ContextManager,
   ContextOverflowError,
   DEFAULT_CONTEXT_LIMITS,
@@ -2373,13 +2043,21 @@ 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,
@@ -2395,12 +2073,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,
@@ -2412,14 +2096,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,
@@ -2434,6 +2131,8 @@ export {
   createApprovalHandler,
   createCheckpointManager,
   createMCPManager,
+  createMessageEntry,
+  createMetadataEntry,
   createPreset,
   createPromptBuilder,
   createResolver,
@@ -2460,10 +2159,15 @@ export {
   estimateMessageTokens,
   estimateTokens,
   executeAgentToolCall,
+  explore,
   extractFilePathsFromArgs,
+  extractModelId,
+  extractProvider,
+  extractSessionInfo,
   failAgentTurnState,
   failAgentWorkflowTurnState,
   filterTools,
+  findCapabilityOverride,
   findCutPoint,
   formatEnvironment,
   formatInstructions,
@@ -2476,45 +2180,61 @@ export {
   getDefaultResolver,
   getDefaultSessionManager,
   getErrorCategory,
+  getGitRootHash,
   getLeafId,
   getModelId,
   getNetworkStatus,
+  getProjectId,
   getProjectSessionsDir,
+  getProviderCompatibility,
   getProviderId,
+  getProviderOptionsKey,
   getReasoningConfig,
   getReasoningConfigSync,
   getRetryDelay,
   getSessionsDir,
   getTemplate,
   getToolRisk,
+  hasStreamProviderFactory,
   httpServer,
+  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,
+  review,
+  runChatLoop,
   runConcurrent,
   runModelStep,
   runToolBatch,
   serializeMessage,
   shouldCaptureBaseline,
+  shouldIncludeReasoningSummary,
   shouldPruneContext,
   shouldRetry,
   sleep,
@@ -2522,11 +2242,16 @@ export {
   snapshotAgentWorkflowMessages,
   sseServer,
   stdioServer,
+  stream,
+  streamOnce,
+  streamStep,
   summarizeEnvironment,
   supportsReasoning,
   supportsReasoningSync,
   toJSONL,
+  toJSONLBatch,
   truncateOutput,
+  watch,
   withFileTracking,
   withRetry
 };