agentbox-sdk 0.1.521 → 0.1.523

package/dist/agents/index.d.ts

@@ -1,5 +1,5 @@
-import { o as AgentProviderName, h as AgentOptions, t as AgentRunConfig, s as AgentRun, r as AgentResult, ak as RawAgentEvent, b as AgentAttachRequest, B as AttachedRun, ar as SetupLayout, ax as UserContent } from '../types-Bhntrw9V.js';
-export { a as AgentApprovalMode, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, u as AgentRunSink, v as AgentSetupRequest, w as AgentSkillConfig, x as AgentSubAgentConfig, y as AgentUserAnswer, z as AgentUserQuestion, E as ClaudeCodeAgentOptions, F as ClaudeCodeHookConfig, G as ClaudeCodeHookEvent, H as ClaudeCodeHookHandler, I as ClaudeCodeHookMatcherGroup, J as ClaudeCodeHooksConfig, K as ClaudeCodeProviderOptions, L as CodexAgentOptions, M as CodexCommandHook, N as CodexHookEvent, O as CodexHookMatcherGroup, P as CodexHooksConfig, Q as CodexModelProviderConfig, R as CodexProviderOptions, S as CodexSkillEntry, T as DataContent, U as EmbeddedSkillConfig, V as FilePart, W as HarnessCommandDescriptor, X as HarnessCommandInvocation, Y as HarnessCommandSource, _ as ImagePart, $ as MAX_HARNESS_COMMANDS, a0 as MAX_HARNESS_COMMAND_ARGUMENT_HINT, a1 as MAX_HARNESS_COMMAND_DESCRIPTION, a2 as MAX_HARNESS_COMMAND_NAME, aa as OpenCodeAgentOptions, ab as OpenCodeCommandEntry, ac as OpenCodePluginConfig, ad as OpenCodePluginEvent, ae as OpenCodePluginHookConfig, af as OpenCodeProviderOptions, ag as OpenCodeSkillEntry, ah as OpenRouterPlugin, am as RepoSkillConfig, at as TextPart, ay as UserContentPart, az as builtinHarnessCommands, aA as claudeHarnessCommands, aB as codexHarnessCommands, aC as codexSkillMention, aF as openCodeHarnessCommands, aG as parseHarnessCommandInvocation, aH as skillDirective } from '../types-Bhntrw9V.js';
+import { o as AgentProviderName, h as AgentOptions, t as AgentRunConfig, s as AgentRun, r as AgentResult, al as RawAgentEvent, b as AgentAttachRequest, B as AttachedRun, as as SetupLayout, ay as UserContent } from '../types-DM6zUiv1.js';
+export { a as AgentApprovalMode, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, u as AgentRunSink, v as AgentSetupRequest, w as AgentSkillConfig, x as AgentSubAgentConfig, y as AgentUserAnswer, z as AgentUserQuestion, E as ClaudeCodeAgentOptions, F as ClaudeCodeHookConfig, G as ClaudeCodeHookEvent, H as ClaudeCodeHookHandler, I as ClaudeCodeHookMatcherGroup, J as ClaudeCodeHooksConfig, K as ClaudeCodeProviderOptions, L as CodexAgentOptions, M as CodexCommandHook, N as CodexHookEvent, O as CodexHookMatcherGroup, P as CodexHooksConfig, Q as CodexModelProviderConfig, R as CodexProviderOptions, S as CodexSkillEntry, T as DataContent, U as EmbeddedSkillConfig, V as FilePart, W as HarnessCommandDescriptor, X as HarnessCommandInvocation, Y as HarnessCommandSource, _ as ImagePart, $ as MAX_HARNESS_COMMANDS, a0 as MAX_HARNESS_COMMAND_ARGUMENT_HINT, a1 as MAX_HARNESS_COMMAND_DESCRIPTION, a2 as MAX_HARNESS_COMMAND_NAME, a6 as NativeParkBackgroundWork, ab as OpenCodeAgentOptions, ac as OpenCodeCommandEntry, ad as OpenCodePluginConfig, ae as OpenCodePluginEvent, af as OpenCodePluginHookConfig, ag as OpenCodeProviderOptions, ah as OpenCodeSkillEntry, ai as OpenRouterPlugin, an as RepoSkillConfig, au as TextPart, az as UserContentPart, aA as builtinHarnessCommands, aB as claudeHarnessCommands, aC as codexHarnessCommands, aD as codexSkillMention, aG as openCodeHarnessCommands, aH as parseHarnessCommandInvocation, aI as skillDirective } from '../types-DM6zUiv1.js';
 import { S as Sandbox } from '../Sandbox-DcKAU-E3.js';
 export { AgentProvider } from '../enums.js';
 import 'e2b';

package/dist/agents/index.js

@@ -15,12 +15,12 @@ import {
   parseHarnessCommandInvocation,
   resolveHarnessCommand,
   skillDirective
-} from "../chunk-UUWGCVXA.js";
+} from "../chunk-PFGHRDL4.js";
 import "../chunk-AE2FQ6YU.js";
 import {
   AGENT_RESERVED_PORTS,
   collectAllAgentReservedPorts
-} from "../chunk-D4LSWCFA.js";
+} from "../chunk-55PSWQJZ.js";
 import "../chunk-NSJM57Z4.js";
 import {
   AgentProvider

package/dist/{chunk-ZQUE5KT6.js → chunk-OGV5XZWI.js}

@@ -10,7 +10,7 @@ import {
   sleep,
   suppressUnhandledRejection,
   time
-} from "./chunk-D4LSWCFA.js";
+} from "./chunk-55PSWQJZ.js";
 import {
   shellQuote,
   toShellCommand

package/dist/{chunk-UUWGCVXA.js → chunk-PFGHRDL4.js}

@@ -20,7 +20,7 @@ import {
   sleep,
   time,
   waitFor
-} from "./chunk-D4LSWCFA.js";
+} from "./chunk-55PSWQJZ.js";
 import {
   shellQuote
 } from "./chunk-NSJM57Z4.js";
@@ -2369,6 +2369,235 @@ var BackgroundWaitFinish = class {
   }
 };
 
+// src/agents/providers/claude-native-session.ts
+var PARK_BUFFER_LIMIT = 16 * 1024 * 1024;
+var WAKE_RETRY_MS = [0, 1e3, 2e3, 4e3, 8e3, 16e3, 3e4, 6e4];
+var WAKE_RETRY_CEILING_MS = 6e4;
+var NO_USER = "No user is attached to approve this request.";
+var parkedSessions = /* @__PURE__ */ new Map();
+function findParkedNativeSession(sessionId) {
+  return parkedSessions.get(sessionId);
+}
+function turnEdges(message) {
+  const m = message;
+  const state = m.type === "system" && m.subtype === "session_state_changed" ? m.state : void 0;
+  return {
+    started: m.type === "system" && (m.subtype === "init" || state === "running"),
+    // A turn that dies without a result would otherwise stay active forever
+    // and inflate the turn count an adopting run skips; idle clears it too.
+    ended: m.type === "result" || state === "idle"
+  };
+}
+var NativeClaudeSession = class {
+  constructor(sessionId, kill) {
+    this.sessionId = sessionId;
+    this.kill = kill;
+  }
+  sessionId;
+  kill;
+  prompt = new AsyncQueue();
+  query;
+  iterator;
+  handlers;
+  parked;
+  // Absolute end of the background budget, carried across parks so a CLI
+  // that is adopted and parked again cannot extend its own ceiling.
+  parkDeadline = Infinity;
+  buffer = [];
+  bufferedBytes = 0;
+  bufferedResults = 0;
+  bufferOverflowed = false;
+  turnActive = false;
+  pumping;
+  ending;
+  bind(query) {
+    this.query = query;
+    this.iterator = query[Symbol.asyncIterator]();
+  }
+  get isParked() {
+    return this.parked !== void 0;
+  }
+  canUseTool = async (toolName, input, options) => {
+    const handlers = this.handlers;
+    if (!handlers) return { behavior: "deny", message: NO_USER };
+    const result = await handlers.canUseTool(toolName, input, options);
+    if (this.handlers !== handlers && result?.behavior === "deny")
+      return { behavior: "deny", message: NO_USER };
+    return result;
+  };
+  preToolUse = async (input, toolUseID, options) => this.handlers ? this.handlers.preToolUse(input, toolUseID, options) : {};
+  /** Attach a run: `preamble` is read first, then the CLI's own output. */
+  open(handlers, preamble = [], handoff) {
+    this.handlers = handlers;
+    const queue = [...preamble];
+    let pending = handoff;
+    return {
+      [Symbol.asyncIterator]: () => ({
+        next: () => {
+          if (queue.length > 0)
+            return Promise.resolve({ done: false, value: queue.shift() });
+          if (pending) {
+            const next = pending;
+            pending = void 0;
+            return next;
+          }
+          return this.pull();
+        }
+      })
+    };
+  }
+  /**
+   * Keep the CLI after the attached run settles. `inflight` is a read that
+   * run started but never consumed; its message is buffered, not lost.
+   */
+  park(tasks, ttlMs, parking, inflight) {
+    if (this.ending || !this.iterator) return false;
+    this.handlers = void 0;
+    this.parkDeadline = Math.min(
+      this.parkDeadline,
+      Number.isFinite(ttlMs) ? Date.now() + Math.max(0, ttlMs) : Infinity
+    );
+    const parked = { tasks, parking, waking: false, wokeAt: 0 };
+    if (Number.isFinite(this.parkDeadline)) {
+      parked.timer = setTimeout(
+        () => {
+          if (this.parked !== parked) return;
+          debugClaude("\u2605 parked CLI ran out of background budget; ending it");
+          void this.end();
+        },
+        Math.min(Math.max(0, this.parkDeadline - Date.now()), 2147483647)
+      );
+      parked.timer.unref?.();
+    }
+    this.parked = parked;
+    parkedSessions.set(this.sessionId, this);
+    void this.pump(inflight);
+    return true;
+  }
+  /**
+   * A later run takes the parked CLI over: it learns what was live and how
+   * many results precede its own turn, then reads what was buffered. An
+   * attach-only run with nothing to stream leaves the park alone (undefined).
+   */
+  adopt(handlers, attachOnly) {
+    const parked = this.parked;
+    if (!parked) return void 0;
+    const turns = this.bufferedResults + (this.turnActive ? 1 : 0);
+    if (attachOnly && turns === 0) return void 0;
+    clearTimeout(parked.timer);
+    this.parked = void 0;
+    parkedSessions.delete(this.sessionId);
+    const budgetLeftMs = Number.isFinite(this.parkDeadline) ? Math.max(0, this.parkDeadline - Date.now()) : null;
+    const preamble = [
+      { _parked: { tasks: parked.tasks, turns, budgetLeftMs } },
+      ...this.buffer
+    ];
+    this.buffer = [];
+    this.bufferedBytes = 0;
+    this.bufferedResults = 0;
+    this.bufferOverflowed = false;
+    const handoff = this.pumping;
+    this.pumping = void 0;
+    return this.open(handlers, preamble, handoff);
+  }
+  /** Close the CLI and the background work it owns. Idempotent. */
+  end() {
+    return this.ending ??= (async () => {
+      const parked = this.parked;
+      this.parked = void 0;
+      this.handlers = void 0;
+      clearTimeout(parked?.timer);
+      if (parkedSessions.get(this.sessionId) === this)
+        parkedSessions.delete(this.sessionId);
+      try {
+        await this.kill();
+      } finally {
+        if (parked) parked.parking.onEnded?.();
+      }
+    })();
+  }
+  pull() {
+    return this.iterator.next().then((result) => {
+      if (!result.done) {
+        const { started, ended } = turnEdges(result.value);
+        if (started) this.turnActive = true;
+        if (ended) this.turnActive = false;
+      }
+      return result;
+    });
+  }
+  async pump(first) {
+    let next = first;
+    while (this.parked) {
+      next ??= this.pull();
+      this.pumping = next;
+      let result;
+      try {
+        result = await next;
+      } catch (error) {
+        if (this.pumping !== next) return;
+        debugClaude("parked CLI stream failed: %o", error);
+        void this.end();
+        return;
+      }
+      if (this.pumping !== next) return;
+      this.pumping = void 0;
+      next = void 0;
+      if (result.done) {
+        debugClaude("\u2605 parked CLI exited");
+        void this.end();
+        return;
+      }
+      this.hold(result.value);
+    }
+  }
+  hold(message) {
+    if (message && typeof message === "object" && "_parked" in message) return;
+    const { started } = turnEdges(message);
+    const isResult = message.type === "result";
+    if (isResult) this.bufferedResults++;
+    if (started || isResult) this.wake();
+    if (message.type === "stream_event") return;
+    const size = Buffer.byteLength(JSON.stringify(message) ?? "");
+    if (this.bufferedBytes + size > PARK_BUFFER_LIMIT) {
+      if (!this.bufferOverflowed) {
+        this.bufferOverflowed = true;
+        this.buffer.push({ _notice: "park_buffer_overflow" });
+        this.wake();
+      }
+      return;
+    }
+    this.bufferedBytes += size;
+    this.buffer.push(message);
+  }
+  wake() {
+    const parked = this.parked;
+    if (!parked || parked.waking) return;
+    if (parked.wokeAt && Date.now() - parked.wokeAt < WAKE_RETRY_CEILING_MS)
+      return;
+    parked.waking = true;
+    void (async () => {
+      try {
+        for (let attempt = 0; ; attempt++) {
+          const delay = WAKE_RETRY_MS[attempt] ?? WAKE_RETRY_CEILING_MS;
+          if (delay) await new Promise((resolve) => setTimeout(resolve, delay));
+          if (this.parked !== parked) return;
+          try {
+            if (await parked.parking.onWake() !== false) {
+              parked.wokeAt = Date.now();
+              return;
+            }
+          } catch (error) {
+            debugClaude("wake callback failed: %o", error);
+          }
+        }
+      } finally {
+        parked.waking = false;
+      }
+    })();
+  }
+};
+
 // src/agents/providers/claude-code.ts
 var DAEMON_PROTOCOL_VERSION = "11";
 var DAEMON_PORT = 43180;
@@ -3289,30 +3518,35 @@ async function fetchWithDaemonRetry(input, init) {
 async function* parseNdjsonStream(body) {
   const reader = body.getReader();
   const decoder = new TextDecoder();
-  let buffer = "";
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    let idx;
-    while ((idx = buffer.indexOf("\n")) !== -1) {
-      const line = buffer.slice(0, idx).trim();
-      buffer = buffer.slice(idx + 1);
-      if (line) {
-        try {
-          yield JSON.parse(line);
-        } catch {
-        }
-      }
-    }
-  }
-  buffer += decoder.decode();
-  if (buffer.trim()) {
+  let pending = [];
+  const parse = (line) => {
     try {
-      yield JSON.parse(buffer);
+      return { value: JSON.parse(line) };
     } catch {
+      return void 0;
     }
-  }
+  };
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    const text2 = decoder.decode(value, { stream: true });
+    let start = 0;
+    let idx = text2.indexOf("\n");
+    while (idx !== -1) {
+      pending.push(text2.slice(start, idx));
+      const line = pending.join("").trim();
+      pending = [];
+      start = idx + 1;
+      const parsed2 = line ? parse(line) : void 0;
+      if (parsed2) yield parsed2.value;
+      idx = text2.indexOf("\n", start);
+    }
+    if (start < text2.length) pending.push(text2.slice(start));
+  }
+  pending.push(decoder.decode());
+  const tail = pending.join("").trim();
+  const parsed = tail ? parse(tail) : void 0;
+  if (parsed) yield parsed.value;
 }
 async function daemonBaseUrl(sandbox) {
   const url = await sandbox.getPreviewLink(DAEMON_PORT);
@@ -3646,7 +3880,8 @@ ${serialized}` : serialized;
         await Promise.allSettled([...pendingReplies]);
       }
     };
-    const parking = request.options.provider?.parkBackgroundWork;
+    const parkOption = request.options.provider?.parkBackgroundWork;
+    const parking = parkOption && "wakeUrl" in parkOption ? parkOption : void 0;
     await consumeClaudeMessages(
       request,
       sink,
@@ -3784,12 +4019,12 @@ async function consumeClaudeMessages(request, sink, messages, executeStartedAt,
     );
   };
   const budgetLeftMs = () => Math.max(0, timeoutMs - waitedMs - (pendingWait?.elapsedMs() ?? 0));
-  const tryPark = async () => {
+  const tryPark = async (inflight) => {
     const live = tracker.liveTasks();
     const ttlMs = budgetLeftMs();
     if (!wait.park || live.length === 0 || isAborted() || ttlMs <= 0)
       return false;
-    parked = await wait.park(live, ttlMs).catch(() => false);
+    parked = await wait.park(live, ttlMs, inflight).catch(() => false);
     if (parked)
       debugClaude(
         "\u2605 parked the harness with %d background task(s); settling",
@@ -3827,7 +4062,7 @@ async function consumeClaudeMessages(request, sink, messages, executeStartedAt,
         break;
       }
       if ("reason" in step) {
-        if (!(step.reason === "finished" && await tryPark()))
+        if (!(step.reason === "finished" && await tryPark(next)))
           expiry = step.reason;
         break;
       }
@@ -4147,31 +4382,29 @@ async function consumeClaudeMessages(request, sink, messages, executeStartedAt,
 async function executeNativeClaude(request, sink, wait = {}) {
   const { query } = await import("@anthropic-ai/claude-agent-sdk");
   const claudeDir = claudeConfigDir(request.options);
-  const input = await validateProviderUserInput(
-    request.provider,
-    request.run.input
-  );
-  const prompt = new AsyncQueue();
+  const attachOnly = request.run.resumeParked === true;
+  const input = attachOnly ? [] : await validateProviderUserInput(request.provider, request.run.input);
+  const parkOption = request.options.provider?.parkBackgroundWork;
+  const parking = parkOption && "onWake" in parkOption ? parkOption : void 0;
   const sessionId = request.run.resumeSessionId ?? randomUUID();
+  if (request.run.forkSessionId)
+    await findParkedNativeSession(request.run.forkSessionId)?.end();
+  const adopting = request.run.resumeSessionId ? findParkedNativeSession(request.run.resumeSessionId) : void 0;
   const controller = new AbortController();
   const tracker = new BackgroundTaskTracker();
   let handle;
   let processHandle;
-  let stopped;
   let cancelled = false;
-  const stop = () => stopped ??= (async () => {
-    prompt.finish();
-    handle?.close();
-    controller.abort();
-    if (processHandle) await processHandle.kill();
-  })();
+  let parked = false;
+  let session;
+  const stop = () => session?.end() ?? Promise.resolve();
   sink.setAbort(async () => {
     cancelled = true;
     await stop();
   });
   sink.setSessionId(sessionId);
   const messageId = randomUUID();
-  prompt.push({
+  const userMessage = {
     type: "user",
     uuid: messageId,
     message: {
@@ -4181,7 +4414,7 @@ async function executeNativeClaude(request, sink, wait = {}) {
       )
     },
     parent_tool_use_id: null
-  });
+  };
   const hostEnv = Object.fromEntries(
     Object.entries({ ...process.env, ...request.options.env }).filter(
       (entry) => entry[1] !== void 0
@@ -4209,9 +4442,87 @@ async function executeNativeClaude(request, sink, wait = {}) {
   const autoApprove = shouldAutoApproveClaudeTools(request.options);
   const interactiveQuestions = hasInteractiveQuestions(request.options);
   let planning = options.permissionMode === "plan";
-  try {
+  const handlers = {
+    async preToolUse(input2) {
+      if (input2.hook_event_name !== "PreToolUse") return {};
+      planning = input2.permission_mode === "plan";
+      return interactiveQuestions && ["AskUserQuestion", "ExitPlanMode"].includes(input2.tool_name) ? {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "ask"
+        }
+      } : {};
+    },
+    async canUseTool(toolName, input2, context) {
+      if (cancelled || context.signal.aborted)
+        return {
+          behavior: "deny",
+          message: "Run cancelled",
+          interrupt: true
+        };
+      const isQuestion = toolName === "AskUserQuestion";
+      const isPlan = toolName === "ExitPlanMode";
+      if ((isQuestion || isPlan) && !interactiveQuestions)
+        return {
+          behavior: "deny",
+          message: "No interactive user is available."
+        };
+      if (!isQuestion && !isPlan && planning && toolName !== "EnterPlanMode")
+        return {
+          behavior: "deny",
+          message: "Finish planning before requesting write access."
+        };
+      if (!isQuestion && !isPlan && autoApprove)
+        return { behavior: "allow", updatedInput: input2 };
+      try {
+        const response = await sink.requestPermission({
+          type: "permission.requested",
+          provider: request.provider,
+          runId: request.runId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          requestId: context.toolUseID,
+          kind: isQuestion ? "question" : isPlan ? "plan" : "tool",
+          toolName,
+          ...isQuestion ? { questions: normalizeUserQuestions("claude-code", input2) } : {},
+          title: isQuestion ? "Your input is needed" : isPlan ? "Review the plan" : context.title ?? `Allow ${toolName}?`,
+          message: context.description ?? context.decisionReason,
+          input: input2,
+          canRemember: false
+        });
+        if (isPlan && response.decision === "allow") planning = false;
+        if (!cancelled && !context.signal.aborted && response.decision === "allow")
+          return {
+            behavior: "allow",
+            updatedInput: isQuestion ? {
+              ...input2,
+              answers: questionReply(
+                "claude-code",
+                input2,
+                response.answers ?? []
+              )
+            } : input2
+          };
+        return { behavior: "deny", message: "The user denied this action" };
+      } catch {
+        return {
+          behavior: "deny",
+          message: "Run cancelled",
+          interrupt: true
+        };
+      }
+    }
+  };
+  const startCli = () => {
+    const fresh = new NativeClaudeSession(sessionId, async () => {
+      fresh.prompt.finish();
+      handle?.close();
+      controller.abort();
+      if (processHandle) await processHandle.kill();
+    });
+    session = fresh;
+    fresh.prompt.push(userMessage);
     handle = query({
-      prompt,
+      prompt: fresh.prompt,
       options: {
         ...options,
         // Use the SDK-matched CLI by default; an installed CLI is an explicit override.
@@ -4232,89 +4543,42 @@ async function executeNativeClaude(request, sink, wait = {}) {
           });
           return processHandle.child;
         },
+        // Routed through the session so that whichever run is attached
+        // decides, and a parked CLI with nobody attached is never left
+        // waiting on a decision.
         hooks: {
           ...options.hooks,
           PreToolUse: [
             ...options.hooks?.PreToolUse ?? [],
-            {
-              hooks: [
-                async (input2) => {
-                  if (input2.hook_event_name !== "PreToolUse") return {};
-                  planning = input2.permission_mode === "plan";
-                  return interactiveQuestions && ["AskUserQuestion", "ExitPlanMode"].includes(
-                    input2.tool_name
-                  ) ? {
-                    hookSpecificOutput: {
-                      hookEventName: "PreToolUse",
-                      permissionDecision: "ask"
-                    }
-                  } : {};
-                }
-              ]
-            }
+            { hooks: [fresh.preToolUse] }
           ]
         },
-        async canUseTool(toolName, input2, context) {
-          if (cancelled || context.signal.aborted)
-            return {
-              behavior: "deny",
-              message: "Run cancelled",
-              interrupt: true
-            };
-          const isQuestion = toolName === "AskUserQuestion";
-          const isPlan = toolName === "ExitPlanMode";
-          if ((isQuestion || isPlan) && !interactiveQuestions)
-            return {
-              behavior: "deny",
-              message: "No interactive user is available."
-            };
-          if (!isQuestion && !isPlan && planning && toolName !== "EnterPlanMode")
-            return {
-              behavior: "deny",
-              message: "Finish planning before requesting write access."
-            };
-          if (!isQuestion && !isPlan && autoApprove)
-            return { behavior: "allow", updatedInput: input2 };
-          try {
-            const response = await sink.requestPermission({
-              type: "permission.requested",
-              provider: request.provider,
-              runId: request.runId,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              requestId: context.toolUseID,
-              kind: isQuestion ? "question" : isPlan ? "plan" : "tool",
-              toolName,
-              ...isQuestion ? { questions: normalizeUserQuestions("claude-code", input2) } : {},
-              title: isQuestion ? "Your input is needed" : isPlan ? "Review the plan" : context.title ?? `Allow ${toolName}?`,
-              message: context.description ?? context.decisionReason,
-              input: input2,
-              canRemember: false
-            });
-            if (isPlan && response.decision === "allow") planning = false;
-            if (!cancelled && !context.signal.aborted && response.decision === "allow")
-              return {
-                behavior: "allow",
-                updatedInput: isQuestion ? {
-                  ...input2,
-                  answers: questionReply(
-                    "claude-code",
-                    input2,
-                    response.answers ?? []
-                  )
-                } : input2
-              };
-            return { behavior: "deny", message: "The user denied this action" };
-          } catch {
-            return {
-              behavior: "deny",
-              message: "Run cancelled",
-              interrupt: true
-            };
-          }
-        }
+        canUseTool: fresh.canUseTool
       }
     });
-    const live = handle;
+    fresh.bind(handle);
+    return fresh.open(handlers);
+  };
+  const notice = (item) => (async function* () {
+    yield item;
+  })();
+  try {
+    let messages;
+    const adopted = adopting?.adopt(handlers, attachOnly);
+    if (adopted) {
+      debugClaude("\u2605 adopting the CLI parked for session %s", sessionId);
+      session = adopting;
+      if (!attachOnly) adopting.prompt.push(userMessage);
+      messages = adopted;
+    } else if (attachOnly) {
+      messages = notice({
+        _notice: adopting ? "no_parked_turn" : "no_parked_run",
+        sessionId
+      });
+    } else {
+      messages = startCli();
+    }
+    const live = session?.query;
     sink.setRaw({ query: live, claudeDir, runId: request.runId });
     sink.emitEvent(
       createNormalizedEvent("run.started", {
@@ -4329,30 +4593,38 @@ async function executeNativeClaude(request, sink, wait = {}) {
         { messageId }
       )
     );
+    const owned = session;
     await consumeClaudeMessages(
       request,
       sink,
-      live,
+      messages,
       Date.now(),
       stop,
       () => cancelled,
       {
         ...wait,
+        attachOnly,
         // Native owns the CLI: ask it to stop leftover tasks before closing it.
         stopTasks: async (ids) => {
+          if (!live) return;
           await Promise.all(
             ids.map((id) => live.stopTask(id).catch(() => void 0))
           );
-        }
+        },
+        ...parking && owned ? {
+          park: async (tasks, ttlMs, inflight) => parked = owned.park(tasks, ttlMs, parking, inflight),
+          // The CLI lives on in the session; nothing to let go of.
+          detach: async () => void 0
+        } : {}
       },
       tracker
     );
   } catch (error) {
-    await stop();
+    if (!parked) await stop();
     if (cancelled) sink.cancel();
     else throw error;
   } finally {
-    await stop();
+    if (!parked) await stop();
   }
 }
 
@@ -8028,8 +8300,8 @@ var Agent = class {
       throw new Error("AgentRunConfig.forkAtMessageId requires forkSessionId.");
     }
     if (runConfig.resumeParked) {
-      if (this.provider !== AgentProvider.ClaudeCode || !this.options.sandbox) {
-        throw new Error("AgentRunConfig.resumeParked is only supported for claude-code sandbox runs.");
+      if (this.provider !== AgentProvider.ClaudeCode || !this.options.sandbox && this.options.configuration !== "native") {
+        throw new Error("AgentRunConfig.resumeParked is only supported for claude-code sandbox or native runs.");
       }
       if (!runConfig.resumeSessionId) {
         throw new Error("AgentRunConfig.resumeParked requires resumeSessionId.");

package/dist/events/index.d.ts

@@ -1,4 +1,4 @@
-export { A as AISDKEvent, C as BackgroundTask, D as BackgroundTasksEvent, Z as HarnessCommandsEvent, a3 as MessageCompletedEvent, a4 as MessageInjectedEvent, a5 as MessageStartedEvent, a6 as NativePlanEvent, a7 as NormalizedAgentEvent, a8 as NormalizedAgentEventBase, a9 as NormalizedAgentEventType, ai as PermissionRequestedEvent, aj as PermissionResolvedEvent, ak as RawAgentEvent, al as ReasoningDeltaEvent, an as RunCancelledEvent, ao as RunCompletedEvent, ap as RunErrorEvent, aq as RunStartedEvent, as as TextDeltaEvent, au as ToolCallCompletedEvent, av as ToolCallDeltaEvent, aw as ToolCallStartedEvent, aD as createNormalizedEvent, aE as normalizeRawAgentEvent, aI as toAISDKEvent, aJ as toAISDKStream } from '../types-Bhntrw9V.js';
+export { A as AISDKEvent, C as BackgroundTask, D as BackgroundTasksEvent, Z as HarnessCommandsEvent, a3 as MessageCompletedEvent, a4 as MessageInjectedEvent, a5 as MessageStartedEvent, a7 as NativePlanEvent, a8 as NormalizedAgentEvent, a9 as NormalizedAgentEventBase, aa as NormalizedAgentEventType, aj as PermissionRequestedEvent, ak as PermissionResolvedEvent, al as RawAgentEvent, am as ReasoningDeltaEvent, ao as RunCancelledEvent, ap as RunCompletedEvent, aq as RunErrorEvent, ar as RunStartedEvent, at as TextDeltaEvent, av as ToolCallCompletedEvent, aw as ToolCallDeltaEvent, ax as ToolCallStartedEvent, aE as createNormalizedEvent, aF as normalizeRawAgentEvent, aJ as toAISDKEvent, aK as toAISDKStream } from '../types-DM6zUiv1.js';
 import { AgentProvider } from '../enums.js';
 import '../Sandbox-DcKAU-E3.js';
 import 'e2b';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { A as AISDKEvent, a as AgentApprovalMode, b as AgentAttachRequest, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, h as AgentOptions, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, o as AgentProviderName, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, r as AgentResult, s as AgentRun, t as AgentRunConfig, u as AgentRunSink, v as AgentSetupRequest, w as AgentSkillConfig, x as AgentSubAgentConfig, y as AgentUserAnswer, z as AgentUserQuestion, B as AttachedRun, C as BackgroundTask, D as BackgroundTasksEvent, E as ClaudeCodeAgentOptions, F as ClaudeCodeHookConfig, G as ClaudeCodeHookEvent, H as ClaudeCodeHookHandler, I as ClaudeCodeHookMatcherGroup, J as ClaudeCodeHooksConfig, K as ClaudeCodeProviderOptions, L as CodexAgentOptions, M as CodexCommandHook, N as CodexHookEvent, O as CodexHookMatcherGroup, P as CodexHooksConfig, Q as CodexModelProviderConfig, R as CodexProviderOptions, S as CodexSkillEntry, T as DataContent, U as EmbeddedSkillConfig, V as FilePart, W as HarnessCommandDescriptor, X as HarnessCommandInvocation, Y as HarnessCommandSource, Z as HarnessCommandsEvent, _ as ImagePart, $ as MAX_HARNESS_COMMANDS, a0 as MAX_HARNESS_COMMAND_ARGUMENT_HINT, a1 as MAX_HARNESS_COMMAND_DESCRIPTION, a2 as MAX_HARNESS_COMMAND_NAME, a3 as MessageCompletedEvent, a4 as MessageInjectedEvent, a5 as MessageStartedEvent, a6 as NativePlanEvent, a7 as NormalizedAgentEvent, a8 as NormalizedAgentEventBase, a9 as NormalizedAgentEventType, aa as OpenCodeAgentOptions, ab as OpenCodeCommandEntry, ac as OpenCodePluginConfig, ad as OpenCodePluginEvent, ae as OpenCodePluginHookConfig, af as OpenCodeProviderOptions, ag as OpenCodeSkillEntry, ah as OpenRouterPlugin, ai as PermissionRequestedEvent, aj as PermissionResolvedEvent, ak as RawAgentEvent, al as ReasoningDeltaEvent, am as RepoSkillConfig, an as RunCancelledEvent, ao as RunCompletedEvent, ap as RunErrorEvent, aq as RunStartedEvent, ar as SetupLayout, as as TextDeltaEvent, at as TextPart, au as ToolCallCompletedEvent, av as ToolCallDeltaEvent, aw as ToolCallStartedEvent, ax as UserContent, ay as UserContentPart, az as builtinHarnessCommands, aA as claudeHarnessCommands, aB as codexHarnessCommands, aC as codexSkillMention, aD as createNormalizedEvent, aE as normalizeRawAgentEvent, aF as openCodeHarnessCommands, aG as parseHarnessCommandInvocation, aH as skillDirective, aI as toAISDKEvent, aJ as toAISDKStream } from './types-Bhntrw9V.js';
+export { A as AISDKEvent, a as AgentApprovalMode, b as AgentAttachRequest, c as AgentCommandConfig, d as AgentCostData, e as AgentExecutionRequest, f as AgentLocalMcpConfig, g as AgentMcpConfig, h as AgentOptions, i as AgentOptionsBase, j as AgentOptionsMap, k as AgentPermissionDecision, l as AgentPermissionKind, m as AgentPermissionResponse, n as AgentProviderAdapter, o as AgentProviderName, p as AgentReasoningEffort, q as AgentRemoteMcpConfig, r as AgentResult, s as AgentRun, t as AgentRunConfig, u as AgentRunSink, v as AgentSetupRequest, w as AgentSkillConfig, x as AgentSubAgentConfig, y as AgentUserAnswer, z as AgentUserQuestion, B as AttachedRun, C as BackgroundTask, D as BackgroundTasksEvent, E as ClaudeCodeAgentOptions, F as ClaudeCodeHookConfig, G as ClaudeCodeHookEvent, H as ClaudeCodeHookHandler, I as ClaudeCodeHookMatcherGroup, J as ClaudeCodeHooksConfig, K as ClaudeCodeProviderOptions, L as CodexAgentOptions, M as CodexCommandHook, N as CodexHookEvent, O as CodexHookMatcherGroup, P as CodexHooksConfig, Q as CodexModelProviderConfig, R as CodexProviderOptions, S as CodexSkillEntry, T as DataContent, U as EmbeddedSkillConfig, V as FilePart, W as HarnessCommandDescriptor, X as HarnessCommandInvocation, Y as HarnessCommandSource, Z as HarnessCommandsEvent, _ as ImagePart, $ as MAX_HARNESS_COMMANDS, a0 as MAX_HARNESS_COMMAND_ARGUMENT_HINT, a1 as MAX_HARNESS_COMMAND_DESCRIPTION, a2 as MAX_HARNESS_COMMAND_NAME, a3 as MessageCompletedEvent, a4 as MessageInjectedEvent, a5 as MessageStartedEvent, a6 as NativeParkBackgroundWork, a7 as NativePlanEvent, a8 as NormalizedAgentEvent, a9 as NormalizedAgentEventBase, aa as NormalizedAgentEventType, ab as OpenCodeAgentOptions, ac as OpenCodeCommandEntry, ad as OpenCodePluginConfig, ae as OpenCodePluginEvent, af as OpenCodePluginHookConfig, ag as OpenCodeProviderOptions, ah as OpenCodeSkillEntry, ai as OpenRouterPlugin, aj as PermissionRequestedEvent, ak as PermissionResolvedEvent, al as RawAgentEvent, am as ReasoningDeltaEvent, an as RepoSkillConfig, ao as RunCancelledEvent, ap as RunCompletedEvent, aq as RunErrorEvent, ar as RunStartedEvent, as as SetupLayout, at as TextDeltaEvent, au as TextPart, av as ToolCallCompletedEvent, aw as ToolCallDeltaEvent, ax as ToolCallStartedEvent, ay as UserContent, az as UserContentPart, aA as builtinHarnessCommands, aB as claudeHarnessCommands, aC as codexHarnessCommands, aD as codexSkillMention, aE as createNormalizedEvent, aF as normalizeRawAgentEvent, aG as openCodeHarnessCommands, aH as parseHarnessCommandInvocation, aI as skillDirective, aJ as toAISDKEvent, aK as toAISDKStream } from './types-DM6zUiv1.js';
 export { AGENT_RESERVED_PORTS, Agent, HarnessCapabilities, HarnessCommand, agentboxRoot, collectAllAgentReservedPorts, getAgentLayout, harnessCapabilities, resolveHarnessCommand } from './agents/index.js';
 export { A as AsyncCommandHandle, C as CommandEvent, a as CommandOptions, b as CommandResult, D as DaytonaProviderOptions, c as DaytonaSandboxOptions, E as E2bProviderOptions, d as E2bSandboxOptions, G as GitCloneOptions, L as LocalDockerProviderOptions, e as LocalDockerSandboxOptions, M as ModalProviderOptions, f as ModalSandboxOptions, S as Sandbox, g as SandboxDescriptor, h as SandboxListOptions, i as SandboxOptions, j as SandboxOptionsBase, k as SandboxOptionsMap, l as SandboxProviderName, m as SandboxRaw, n as SandboxRawMap, o as SandboxResourceSpec, T as TarballEntry, V as VercelGitSource, p as VercelProviderOptions, q as VercelSandboxOptions } from './Sandbox-DcKAU-E3.js';
 export { SandboxAdapter, buildGitCloneCommand } from './sandboxes/index.js';

package/dist/index.js

@@ -15,7 +15,7 @@ import {
   parseHarnessCommandInvocation,
   resolveHarnessCommand,
   skillDirective
-} from "./chunk-UUWGCVXA.js";
+} from "./chunk-PFGHRDL4.js";
 import {
   ProviderLogAssembler,
   createNormalizedEvent,
@@ -27,11 +27,11 @@ import {
   Sandbox,
   SandboxAdapter,
   buildGitCloneCommand
-} from "./chunk-ZQUE5KT6.js";
+} from "./chunk-OGV5XZWI.js";
 import {
   AGENT_RESERVED_PORTS,
   collectAllAgentReservedPorts
-} from "./chunk-D4LSWCFA.js";
+} from "./chunk-55PSWQJZ.js";
 import "./chunk-NSJM57Z4.js";
 import {
   AgentProvider,

package/dist/sandboxes/index.js

@@ -2,8 +2,8 @@ import {
   Sandbox,
   SandboxAdapter,
   buildGitCloneCommand
-} from "../chunk-ZQUE5KT6.js";
-import "../chunk-D4LSWCFA.js";
+} from "../chunk-OGV5XZWI.js";
+import "../chunk-55PSWQJZ.js";
 import "../chunk-NSJM57Z4.js";
 import {
   SandboxProvider

package/dist/{types-Bhntrw9V.d.ts → types-DM6zUiv1.d.ts}

@@ -495,7 +495,7 @@ interface AgentRunConfig {
     systemPrompt?: string;
     resumeSessionId?: string;
     /**
-     * claude-code sandbox runs: attach to the harness parked for
+     * claude-code sandbox and native runs: attach to the harness parked for
      * {@link resumeSessionId} without sending {@link input}, and stream the
      * turn it started on its own. Completes with empty text when nothing is
      * parked or no such turn exists. See `provider.parkBackgroundWork`.
@@ -714,21 +714,40 @@ interface OpenCodeProviderOptions {
     args?: string[];
     plugins?: OpenCodePluginConfig[];
 }
+/**
+ * Parking for native (`configuration: "native"`) runs, where this process
+ * owns the CLI: the parked CLI lives on in this process, so the next run
+ * resuming the session must run in this same process to adopt it.
+ */
+interface NativeParkBackgroundWork {
+    /**
+     * The parked CLI started a turn on its own with nobody attached. Start a
+     * run with `resumeParked` in this process to stream it. Resolve `false`
+     * (or throw) to be asked again with backoff; anything else counts as
+     * accepted until a run attaches.
+     */
+    onWake(): Promise<boolean | void> | boolean | void;
+    /** The parked CLI is gone: its work finished and it exited, or its budget ran out. */
+    onEnded?(): void;
+}
 interface ClaudeCodeProviderOptions {
     /**
-     * Sandbox runs only. End a run at its answer even when background work is
-     * still live, and keep the CLI alive in the sandbox for it (a "parked"
-     * run) instead of holding the run open. A run whose turn ends with nothing
-     * live is unaffected. The next run resuming that session takes the CLI
-     * over. When the CLI starts a turn on its own with nobody attached (a task
-     * finished, a schedule fired) the daemon POSTs `{ runId, sessionId }` to
-     * `wakeUrl` with `Authorization: Bearer <wakeToken>`; stream that turn with
-     * `resumeParked`. The park lasts what is left of `backgroundTaskTimeoutMs`.
+     * End a run at its answer even when background work is still live, and
+     * keep the CLI alive for it (a "parked" run) instead of holding the run
+     * open. A run whose turn ends with nothing live is unaffected. The next run
+     * resuming that session takes the CLI over. The park lasts what is left of
+     * `backgroundTaskTimeoutMs`.
+     *
+     * Sandbox runs: when the CLI starts a turn on its own with nobody attached
+     * (a task finished, a schedule fired) the daemon POSTs
+     * `{ runId, sessionId }` to `wakeUrl` with
+     * `Authorization: Bearer <wakeToken>`; stream that turn with
+     * `resumeParked`. Native runs: see {@link NativeParkBackgroundWork}.
      */
     parkBackgroundWork?: {
         wakeUrl: string;
         wakeToken: string;
-    };
+    } | NativeParkBackgroundWork;
     /** Request fast mode explicitly; false overrides inherited fast settings. */
     fastMode?: boolean;
     binary?: string;
@@ -1009,4 +1028,4 @@ interface AgentProviderAdapter<P extends AgentProviderName = AgentProviderName>
     attachSendMessage(request: AgentAttachRequest<P>, content: UserContent): Promise<void>;
 }
 
-export { MAX_HARNESS_COMMANDS as $, type AISDKEvent as A, type AttachedRun as B, type BackgroundTask as C, type BackgroundTasksEvent as D, type ClaudeCodeAgentOptions as E, type ClaudeCodeHookConfig as F, type ClaudeCodeHookEvent as G, type ClaudeCodeHookHandler as H, type ClaudeCodeHookMatcherGroup as I, type ClaudeCodeHooksConfig as J, type ClaudeCodeProviderOptions as K, type CodexAgentOptions as L, type CodexCommandHook as M, type CodexHookEvent as N, type CodexHookMatcherGroup as O, type CodexHooksConfig as P, type CodexModelProviderConfig as Q, type CodexProviderOptions as R, type CodexSkillEntry as S, type DataContent as T, type EmbeddedSkillConfig as U, type FilePart as V, type HarnessCommandDescriptor as W, type HarnessCommandInvocation as X, type HarnessCommandSource as Y, type HarnessCommandsEvent as Z, type ImagePart as _, type AgentApprovalMode as a, MAX_HARNESS_COMMAND_ARGUMENT_HINT as a0, MAX_HARNESS_COMMAND_DESCRIPTION as a1, MAX_HARNESS_COMMAND_NAME as a2, type MessageCompletedEvent as a3, type MessageInjectedEvent as a4, type MessageStartedEvent as a5, type NativePlanEvent as a6, type NormalizedAgentEvent as a7, type NormalizedAgentEventBase as a8, type NormalizedAgentEventType as a9, claudeHarnessCommands as aA, codexHarnessCommands as aB, codexSkillMention as aC, createNormalizedEvent as aD, normalizeRawAgentEvent as aE, openCodeHarnessCommands as aF, parseHarnessCommandInvocation as aG, skillDirective as aH, toAISDKEvent as aI, toAISDKStream as aJ, type OpenCodeAgentOptions as aa, type OpenCodeCommandEntry as ab, type OpenCodePluginConfig as ac, type OpenCodePluginEvent as ad, type OpenCodePluginHookConfig as ae, type OpenCodeProviderOptions as af, type OpenCodeSkillEntry as ag, type OpenRouterPlugin as ah, type PermissionRequestedEvent as ai, type PermissionResolvedEvent as aj, type RawAgentEvent as ak, type ReasoningDeltaEvent as al, type RepoSkillConfig as am, type RunCancelledEvent as an, type RunCompletedEvent as ao, type RunErrorEvent as ap, type RunStartedEvent as aq, type SetupLayout as ar, type TextDeltaEvent as as, type TextPart as at, type ToolCallCompletedEvent as au, type ToolCallDeltaEvent as av, type ToolCallStartedEvent as aw, type UserContent as ax, type UserContentPart as ay, builtinHarnessCommands as az, type AgentAttachRequest as b, type AgentCommandConfig as c, type AgentCostData as d, type AgentExecutionRequest as e, type AgentLocalMcpConfig as f, type AgentMcpConfig as g, type AgentOptions as h, type AgentOptionsBase as i, type AgentOptionsMap as j, type AgentPermissionDecision as k, type AgentPermissionKind as l, type AgentPermissionResponse as m, type AgentProviderAdapter as n, type AgentProviderName as o, type AgentReasoningEffort as p, type AgentRemoteMcpConfig as q, type AgentResult as r, type AgentRun as s, type AgentRunConfig as t, type AgentRunSink as u, type AgentSetupRequest as v, type AgentSkillConfig as w, type AgentSubAgentConfig as x, type AgentUserAnswer as y, type AgentUserQuestion as z };
+export { MAX_HARNESS_COMMANDS as $, type AISDKEvent as A, type AttachedRun as B, type BackgroundTask as C, type BackgroundTasksEvent as D, type ClaudeCodeAgentOptions as E, type ClaudeCodeHookConfig as F, type ClaudeCodeHookEvent as G, type ClaudeCodeHookHandler as H, type ClaudeCodeHookMatcherGroup as I, type ClaudeCodeHooksConfig as J, type ClaudeCodeProviderOptions as K, type CodexAgentOptions as L, type CodexCommandHook as M, type CodexHookEvent as N, type CodexHookMatcherGroup as O, type CodexHooksConfig as P, type CodexModelProviderConfig as Q, type CodexProviderOptions as R, type CodexSkillEntry as S, type DataContent as T, type EmbeddedSkillConfig as U, type FilePart as V, type HarnessCommandDescriptor as W, type HarnessCommandInvocation as X, type HarnessCommandSource as Y, type HarnessCommandsEvent as Z, type ImagePart as _, type AgentApprovalMode as a, MAX_HARNESS_COMMAND_ARGUMENT_HINT as a0, MAX_HARNESS_COMMAND_DESCRIPTION as a1, MAX_HARNESS_COMMAND_NAME as a2, type MessageCompletedEvent as a3, type MessageInjectedEvent as a4, type MessageStartedEvent as a5, type NativeParkBackgroundWork as a6, type NativePlanEvent as a7, type NormalizedAgentEvent as a8, type NormalizedAgentEventBase as a9, builtinHarnessCommands as aA, claudeHarnessCommands as aB, codexHarnessCommands as aC, codexSkillMention as aD, createNormalizedEvent as aE, normalizeRawAgentEvent as aF, openCodeHarnessCommands as aG, parseHarnessCommandInvocation as aH, skillDirective as aI, toAISDKEvent as aJ, toAISDKStream as aK, type NormalizedAgentEventType as aa, type OpenCodeAgentOptions as ab, type OpenCodeCommandEntry as ac, type OpenCodePluginConfig as ad, type OpenCodePluginEvent as ae, type OpenCodePluginHookConfig as af, type OpenCodeProviderOptions as ag, type OpenCodeSkillEntry as ah, type OpenRouterPlugin as ai, type PermissionRequestedEvent as aj, type PermissionResolvedEvent as ak, type RawAgentEvent as al, type ReasoningDeltaEvent as am, type RepoSkillConfig as an, type RunCancelledEvent as ao, type RunCompletedEvent as ap, type RunErrorEvent as aq, type RunStartedEvent as ar, type SetupLayout as as, type TextDeltaEvent as at, type TextPart as au, type ToolCallCompletedEvent as av, type ToolCallDeltaEvent as aw, type ToolCallStartedEvent as ax, type UserContent as ay, type UserContentPart as az, type AgentAttachRequest as b, type AgentCommandConfig as c, type AgentCostData as d, type AgentExecutionRequest as e, type AgentLocalMcpConfig as f, type AgentMcpConfig as g, type AgentOptions as h, type AgentOptionsBase as i, type AgentOptionsMap as j, type AgentPermissionDecision as k, type AgentPermissionKind as l, type AgentPermissionResponse as m, type AgentProviderAdapter as n, type AgentProviderName as o, type AgentReasoningEffort as p, type AgentRemoteMcpConfig as q, type AgentResult as r, type AgentRun as s, type AgentRunConfig as t, type AgentRunSink as u, type AgentSetupRequest as v, type AgentSkillConfig as w, type AgentSubAgentConfig as x, type AgentUserAnswer as y, type AgentUserQuestion as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbox-sdk",
-  "version": "0.1.521",
+  "version": "0.1.523",
   "description": "Swappable coding agents and sandbox providers for Bun and TypeScript.",
   "license": "MIT",
   "repository": {