agentbox-sdk 0.1.511 → 0.1.513

package/README.md

@@ -130,33 +130,31 @@ default 30 minutes, `0` settles at the first turn end as before, `Infinity`
 waits forever. On expiry the tasks are stopped best-effort and the run
 completes with the last turn's text.
 
-Codex has no background mode of its own: its unified exec tool hands control
-back to the model early (`yield_time_ms`) and leaves the process running inside
-the app-server, where nothing wakes the model when it finishes. When a Codex
-turn ends with such a command still running, AgentBox keeps the app-server up
-and reports the command through `background.tasks` (`type: "command"`,
-`description` is the command line). Once every leftover command has finished
-while the model was idle, AgentBox starts a follow-up turn on the same thread
-carrying each command's exit code, duration and the last 4000 characters of
-output, asking the model to verify the outcome and finish without restarting
-the command; that turn is surfaced as a `message.injected` event and the run
-settles on its result (which may in turn leave more commands running). A
-message sent while waiting runs as a normal turn and is checked the same way; a
-command that finishes during a turn is left to the model's own polling and is
-only visible through `tool.call.completed`. A failed follow-up turn fails the
-run like any other turn. When `backgroundTaskTimeoutMs` expires, AgentBox asks
-the app-server to terminate the leftover processes
-(`thread/backgroundTerminals/list` + `terminate`, best effort) and completes
-with the last turn's text; `0` keeps the legacy settle-at-first-turn behaviour.
-Any unified-exec process still running at turn end counts — a dev server or
-watcher the model leaves running on purpose holds the run open until the
-ceiling — so hosts that expect such processes should pass a shorter
-`backgroundTaskTimeoutMs` for Codex. Spawned Codex sub-agents are not tracked:
-the parent must `wait_agent` for them within its turn. A waiting run can still
-be cancelled statelessly: `Agent.attach(...).abort()` interrupts the active turn
-when there is one and otherwise starts a turn only to interrupt it, which the
-originating run observes as an interrupted turn and reports as `run.cancelled`;
-the leftover processes are then terminated.
+Codex owns command polling (`write_stdin`), yielded code-mode waits (`wait`),
+and subagent waits (`wait_agent`). AgentBox finishes an ordinary Codex run on
+its root `turn/completed`, regardless of shell processes still running. It does
+not classify commands, wait for their exit, or inject synthetic follow-up turns.
+Raw tool events remain available. A command ending after the final turn does
+not restart the model. Remote cleanup disconnects from the shared app-server;
+local cleanup shuts down the app-server it owns.
+
+Native Codex goals are a separate lifecycle: an active root-thread goal keeps
+the run open between turns so Codex can continue on its own. AgentBox reports
+these gaps with `background.tasks { tasks: [], waiting: true }` and clears the
+wait when the next native turn starts. A root goal becoming `complete` or
+`blocked` ends the run after its final turn; a goal cleared or made inactive
+while idle settles immediately. Child-thread and stale-turn goal updates do
+not end the root run. `blocked` preserves the final answer without implying
+that the objective was achieved.
+
+Only these native goal waits use `backgroundTaskTimeoutMs` for Codex. The
+15-second idle grace and total wait ceiling bound the gap between native turns;
+`0` settles at the first turn. Expiry settles with the last answer without
+terminating remote shell processes. A user message can resume an idle goal
+wait. Stateless cancellation (`Agent.attach(...).abort()`) interrupts an active
+turn, or starts a turn only to interrupt it if the thread is idle, then stops
+the idle thread's leftover terminals. Claude Code and OpenCode retain their own
+background-work handling described above and below.
 
 OpenCode has no background shells, monitors, or wake-ups; its only work that
 outlives a turn is `task {background: true}`, which the server accepts only when
@@ -204,13 +202,15 @@ Pass an optional `reasoning` level alongside `model` on any run. It maps to each
 ```ts
 await agent.run({
   model: "sonnet",
-  reasoning: "high", // "low" | "medium" | "high" | "xhigh"
+  reasoning: "high", // "low" | "medium" | "high" | "xhigh" | "max" | "ultra"
   input: "Refactor this module and explain your reasoning.",
 });
 ```
 
 `xhigh` requires a model that supports it (e.g. Claude Opus 4.7+, Codex `gpt-5.4`).
 
+Codex also supports `max` (maximum reasoning) and `ultra` (maximum reasoning with automatic task delegation). Astra, GPT-5.6 Sol, and GPT-5.6 Terra support both; GPT-5.6 Luna supports `max`. Check the runtime's `model/list` → `supportedReasoningEfforts` for model availability. Both values are forwarded unchanged to `turn/start.effort`, including resumed and plan-mode turns; other AgentBox providers reject them.
+
 ### Open-source & custom models (OpenRouter, OSS)
 
 Codex isn't limited to OpenAI models — it can route through any
@@ -648,3 +648,15 @@ CLIs and SDK mocks; live tests remain opt-in.
 ## License
 
 MIT
+
+For native speed selection, use `provider: { serviceTier: "fast" }` with Codex (or `"default"` for standard speed), and `provider: { fastMode: true }` with Claude Code. Omit these options to inherit harness settings. Availability and usage charges are enforced by the harness.
+
+### Preparing local Codex before a prompt
+
+For an interactive host, `provider: { prewarm: true }` makes `await agent.setup()`
+start and initialize the next Codex app-server. It does not create a thread, send
+a prompt, or run tools. The next `stream()`/`run()` consumes that prepared process
+and stops it normally when the run ends; abort still stops the owned process.
+A prepared process that exited while idle is replaced before execution. Call
+`await agent.killServer()` to dispose an unused prepared process. Prewarming is
+host-only and opt-in. Use a new Agent for a changed cwd, environment, or policy.

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, a9 as RawAgentEvent, b as AgentAttachRequest, B as AttachedRun, ag as SetupLayout, am as UserContent } from '../types-B4yy80AJ.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 DataContent, T as EmbeddedSkillConfig, U as FilePart, V as ImagePart, a1 as OpenCodeAgentOptions, a2 as OpenCodePluginConfig, a3 as OpenCodePluginEvent, a4 as OpenCodePluginHookConfig, a5 as OpenCodeProviderOptions, a6 as OpenRouterPlugin, ab as RepoSkillConfig, ai as TextPart, an as UserContentPart } from '../types-B4yy80AJ.js';
+import { o as AgentProviderName, h as AgentOptions, t as AgentRunConfig, s as AgentRun, r as AgentResult, a9 as RawAgentEvent, b as AgentAttachRequest, B as AttachedRun, ag as SetupLayout, am as UserContent } from '../types-NhKw_6mW.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 DataContent, T as EmbeddedSkillConfig, U as FilePart, V as ImagePart, a1 as OpenCodeAgentOptions, a2 as OpenCodePluginConfig, a3 as OpenCodePluginEvent, a4 as OpenCodePluginHookConfig, a5 as OpenCodeProviderOptions, a6 as OpenRouterPlugin, ab as RepoSkillConfig, ai as TextPart, an as UserContentPart } from '../types-NhKw_6mW.js';
 import { S as Sandbox } from '../Sandbox-DcKAU-E3.js';
 export { AgentProvider } from '../enums.js';
 import 'e2b';

package/dist/agents/index.js

@@ -4,7 +4,7 @@ import {
   getAgentLayout,
   harnessCapabilities,
   resolveHarnessCommand
-} from "../chunk-G3VEVR6Y.js";
+} from "../chunk-XJWZR2NR.js";
 import "../chunk-775FIGGL.js";
 import {
   AGENT_RESERVED_PORTS,

package/dist/{chunk-G3VEVR6Y.js → chunk-XJWZR2NR.js}

@@ -2051,12 +2051,16 @@ function buildClaudeQueryOptions(params) {
     extraArgs["append-system-prompt"] = run.systemPrompt;
   }
   const includeHookEvents = provider?.includeHookEvents ?? false;
+  if (run.reasoning === "max" || run.reasoning === "ultra") {
+    throw new Error(`Reasoning effort "${run.reasoning}" is only supported by Codex.`);
+  }
   const effort = provider?.ultracode ? "xhigh" : run.reasoning;
   return {
     cwd: params.cwd ?? params.request.options.cwd,
     env: params.env,
     pathToClaudeCodeExecutable: provider?.binary ?? "claude",
     ...params.settingsPath ? { settings: params.settingsPath } : {},
+    ...params.request.options.configuration === "native" && provider?.fastMode !== void 0 ? { settings: { fastMode: provider.fastMode } } : {},
     ...params.request.options.configuration === "native" ? {
       settingSources: ["user", "project", "local"],
       systemPrompt: { type: "preset", preset: "claude_code" }
@@ -2704,7 +2708,11 @@ var ClaudeCodeAgentAdapter = class {
       const workflowSettings = buildClaudeWorkflowSettings(
         options.provider?.ultracode
       );
-      const claudeSettings = { ...hookSettings, ...workflowSettings };
+      const claudeSettings = {
+        ...hookSettings,
+        ...workflowSettings,
+        ...options.provider?.fastMode !== void 0 ? { fastMode: options.provider.fastMode } : {}
+      };
       const mcpConfigJson = buildClaudeMcpConfig(options.mcps) ?? JSON.stringify({ mcpServers: {} }, null, 2);
       const artifacts = [
         ...!sandbox ? [{ path: path8.join(target.layout.claudeDir, ".claude-plugin", "plugin.json"), content: JSON.stringify({ name: "agentbox", version: "1.0.0" }) }] : [],
@@ -3642,6 +3650,7 @@ function buildThreadParams(cwd, options, request) {
   return {
     cwd,
     model: request.run.model ?? null,
+    ...request.options.provider?.serviceTier !== void 0 ? { serviceTier: request.options.provider.serviceTier } : {},
     ...options.provider?.approvalPolicy ? { approvalPolicy: options.provider.approvalPolicy } : options.configuration === "native" && !options.fullAccess ? {} : { approvalPolicy: !options.fullAccess && isInteractiveApproval(options) ? "untrusted" : "never" },
     sandbox: buildCodexSandboxMode(options),
     serviceName: "agentbox",
@@ -3657,6 +3666,7 @@ function buildResumeParams(cwd, options, request) {
     threadId: request.run.resumeSessionId,
     cwd,
     model: request.run.model ?? null,
+    ...request.options.provider?.serviceTier !== void 0 ? { serviceTier: request.options.provider.serviceTier } : {},
     ...options.provider?.approvalPolicy ? { approvalPolicy: options.provider.approvalPolicy } : options.configuration === "native" && !options.fullAccess ? {} : { approvalPolicy: !options.fullAccess && isInteractiveApproval(options) ? "untrusted" : "never" },
     sandbox: buildCodexSandboxMode(options),
     ...request.run.systemPrompt ? { developerInstructions: request.run.systemPrompt } : options.configuration === "native" ? {} : { developerInstructions: null },
@@ -3673,6 +3683,7 @@ function buildForkParams(cwd, options, request) {
     lastTurnId: request.run.forkAtMessageId ?? null,
     cwd,
     model: request.run.model ?? null,
+    ...request.options.provider?.serviceTier !== void 0 ? { serviceTier: request.options.provider.serviceTier } : {},
     ...options.provider?.approvalPolicy ? { approvalPolicy: options.provider.approvalPolicy } : options.configuration === "native" && !options.fullAccess ? {} : { approvalPolicy: !options.fullAccess && isInteractiveApproval(options) ? "untrusted" : "never" },
     sandbox: buildCodexSandboxMode(options),
     ...request.run.systemPrompt ? { developerInstructions: request.run.systemPrompt } : options.configuration === "native" ? {} : { developerInstructions: null },
@@ -3712,6 +3723,7 @@ function buildCodexTurnStartParams(params) {
     },
     ...sandboxPolicy ? { sandboxPolicy } : {},
     model: request.run.model ?? null,
+    ...request.options.provider?.serviceTier !== void 0 ? { serviceTier: request.options.provider.serviceTier } : {},
     effort: request.run.reasoning ?? null,
     ...request.run.mode ? { collaborationMode: {
       mode: request.run.mode,
@@ -3720,23 +3732,6 @@ function buildCodexTurnStartParams(params) {
     outputSchema: null
   };
 }
-var BACKGROUND_OUTPUT_TAIL_CHARS = 4e3;
-function buildCodexBackgroundFollowUp(items) {
-  const reports = items.map((item) => {
-    const tail = (item.aggregatedOutput ?? "").slice(-BACKGROUND_OUTPUT_TAIL_CHARS).trimEnd();
-    const duration = item.durationMs === void 0 ? "an unknown time" : `${Math.round(item.durationMs / 1e3)}s`;
-    return `\`${item.command}\` exited with code ${item.exitCode ?? "unknown"} after ${duration}.
-Output (last ${BACKGROUND_OUTPUT_TAIL_CHARS} chars):
-\`\`\`
-${tail || "(no output)"}
-\`\`\`
-`;
-  });
-  return `Background command finished while you were idle.
-
-${reports.join("")}
-Continue from here: verify the outcome and finish the task. Do not restart the command.`;
-}
 var CODEX_CANCEL_TURN_TEXT = "Run cancelled by the host.";
 async function terminateBackgroundTerminals(client, threadId) {
   await withTimeout((async () => {
@@ -4430,6 +4425,7 @@ async function createRuntime(request, inputParts) {
     cleanup: async () => {
       await processHandle.kill();
     },
+    isAlive: () => processHandle.child.exitCode === null && processHandle.child.signalCode === null && !processHandle.child.killed,
     raw: { processHandle, codexDir },
     inputItems
   };
@@ -4477,11 +4473,47 @@ async function killCodexAppServer(request) {
     { cwd: options.cwd, timeoutMs: 1e4 }
   ).catch(() => void 0);
 }
+async function initializeCodexClient(client) {
+  await client.request("initialize", {
+    clientInfo: { title: "AgentBox", name: "AgentBox", version: "0.1.0" },
+    capabilities: { experimentalApi: true }
+  });
+  await client.notify("initialized", {});
+}
 var CodexAgentAdapter = class {
+  prepared;
+  preparationGeneration = 0;
   async setup(request) {
+    const generation = this.preparationGeneration;
+    if (request.options.provider?.prewarm && request.options.sandbox) {
+      throw new Error("Codex prewarm is only supported for host execution.");
+    }
     await setupCodex(request);
+    if (!request.options.provider?.prewarm || this.prepared?.isAlive?.()) return;
+    await this.prepared?.cleanup();
+    if (generation !== this.preparationGeneration) throw new Error("Codex preparation was cancelled.");
+    const runtime = await createRuntime(request, []);
+    if (generation !== this.preparationGeneration) {
+      await runtime.cleanup();
+      throw new Error("Codex preparation was cancelled.");
+    }
+    const client = new JsonRpcLineClient(runtime.source, runtime.writeLine);
+    const prepared = { ...runtime, client };
+    this.prepared = prepared;
+    try {
+      await withTimeout(initializeCodexClient(client), 1e4);
+      if (this.prepared !== prepared) throw new Error("Codex preparation was cancelled.");
+    } catch (error) {
+      if (this.prepared === prepared) this.prepared = void 0;
+      await runtime.cleanup();
+      throw error;
+    }
   }
   async killServer(request) {
+    this.preparationGeneration++;
+    const prepared = this.prepared;
+    this.prepared = void 0;
+    await prepared?.cleanup();
     await killCodexAppServer(request);
   }
   async execute(request, sink) {
@@ -4492,11 +4524,20 @@ var CodexAgentAdapter = class {
       "validateProviderUserInput",
       () => validateProviderUserInput(request.provider, request.run.input)
     );
-    const runtime = await time(
-      debugCodex,
-      "createRuntime",
-      () => createRuntime(request, inputParts)
-    );
+    const prepared = this.prepared;
+    this.prepared = void 0;
+    let runtime;
+    if (prepared?.isAlive?.()) {
+      try {
+        runtime = { ...prepared, inputItems: await buildCodexInputItems(request.options, inputParts) };
+      } catch (error) {
+        await prepared.cleanup();
+        throw error;
+      }
+    } else {
+      await prepared?.cleanup();
+      runtime = await time(debugCodex, "createRuntime", () => createRuntime(request, inputParts));
+    }
     sink.setRaw(runtime.raw);
     sink.emitEvent(
       createNormalizedEvent("run.started", {
@@ -4511,7 +4552,6 @@ var CodexAgentAdapter = class {
     const interactiveApproval = isInteractiveApproval(request.options);
     let rootThreadId;
     let turnId;
-    let pendingTurns = 1;
     let abortInvoked = false;
     sink.setAbort(async () => {
       abortInvoked = true;
@@ -4565,61 +4605,33 @@ var CodexAgentAdapter = class {
     let streamedText = "";
     const timeoutMs = resolveBackgroundTaskTimeoutMs(request.options.backgroundTaskTimeoutMs);
     const isRootThread = (params) => !params?.threadId || params.threadId === rootThreadId;
-    const inFlight = /* @__PURE__ */ new Map();
-    const finished = [];
+    let goalStatus = request.run.goal ? "active" : void 0;
     let pendingWait;
     let waitedMs = 0;
-    let followUpSent = false;
     let turnMessageText = "";
     let lastTurn;
-    let lastTasksKey = JSON.stringify({ tasks: [], waiting: false });
-    const liveTasks = () => [...inFlight.values()].filter((item) => item.outlived).map((item) => ({ id: item.id, type: "command", description: item.command }));
-    const emitTasks = (tasks, waiting) => {
-      const key = JSON.stringify({ tasks, waiting });
-      if (key === lastTasksKey) return;
-      lastTasksKey = key;
-      sink.emitEvent(createNormalizedEvent("background.tasks", { provider: request.provider, runId: request.runId }, { tasks, waiting }));
+    let goalWaiting = false;
+    const emitGoalWaiting = (waiting) => {
+      if (waiting === goalWaiting) return;
+      goalWaiting = waiting;
+      sink.emitEvent(createNormalizedEvent("background.tasks", { provider: request.provider, runId: request.runId }, { tasks: [], waiting }));
     };
     const endWait = () => {
       if (!pendingWait) return;
       waitedMs += pendingWait.elapsedMs();
       pendingWait.clear();
       pendingWait = void 0;
-      followUpSent = false;
-    };
-    const sendBackgroundFollowUp = async () => {
-      if (!rootThreadId || !pendingWait || followUpSent || finished.length === 0 || abortInvoked) return;
-      if (timeoutMs - waitedMs - pendingWait.elapsedMs() <= 0) return;
-      followUpSent = true;
-      const text2 = buildCodexBackgroundFollowUp(finished.splice(0));
-      try {
-        const response = await client.request(
-          "turn/start",
-          buildCodexTurnStartParams({
-            threadId: rootThreadId,
-            inputItems: [{ type: "text", text: text2, text_elements: [] }],
-            request
-          })
-        );
-        endWait();
-        sink.emitEvent(createNormalizedEvent("message.injected", { provider: request.provider, runId: request.runId }, {
-          content: text2,
-          ...typeof response?.turn?.id === "string" ? { messageId: response.turn.id } : {}
-        }));
-      } catch (error) {
-        debugCodex("background follow-up turn/start failed: %o", error);
-      }
+      emitGoalWaiting(false);
     };
     const completion = new Promise((resolve, reject) => {
       const settle = () => {
         endWait();
-        emitTasks([], false);
         sink.emitEvent(createNormalizedEvent("run.completed", { provider: request.provider, runId: request.runId }, { text: lastTurn?.messageText || void 0 }));
         resolve({ text: lastTurn?.text ?? streamedText, turnId, threadId: rootThreadId, interrupted: false });
       };
       const settleOnFailure = (error) => {
         if (!pendingWait || !lastTurn || abortInvoked) return false;
-        debugCodex("\u2605 transport failed during background wait; settling on the last turn: %o", error);
+        debugCodex("\u2605 transport failed during goal wait; settling on the last turn: %o", error);
         settle();
         return true;
       };
@@ -4639,8 +4651,7 @@ var CodexAgentAdapter = class {
           }
           if ("reason" in step) {
             if (!abortInvoked) {
-              debugCodex("\u2605 background wait over (%s) with %d command(s) in flight", step.reason, inFlight.size);
-              if (step.reason === "ceiling" && rootThreadId) await terminateBackgroundTerminals(client, rootThreadId);
+              debugCodex("\u2605 native goal wait over (%s)", step.reason);
               settle();
               return;
             }
@@ -4724,11 +4735,29 @@ var CodexAgentAdapter = class {
               sink.emitEvent(createNormalizedEvent("plan.completed", { provider: request.provider, runId: request.runId }, { text: item2.text }));
             }
           }
+          if (rootThreadId && message.params && message.params.threadId === rootThreadId) {
+            if (message.method === "thread/goal/updated") {
+              const goal = message.params.goal;
+              if (!message.params.turnId || message.params.turnId === turnId) {
+                goalStatus = typeof goal?.status === "string" ? goal.status : void 0;
+                if (goalStatus !== "active" && pendingWait && !abortInvoked) {
+                  settle();
+                  return;
+                }
+              }
+            } else if (message.method === "thread/goal/cleared") {
+              goalStatus = void 0;
+              if (pendingWait && !abortInvoked) {
+                settle();
+                return;
+              }
+            }
+          }
           const turn = message.params?.turn;
           const rootTurnCompleted = message.method === "turn/completed" && isRootThread(message.params);
-          const waitAfterTurn = rootTurnCompleted && pendingTurns <= 1 && timeoutMs !== 0 && !abortInvoked && turn?.status === "completed" && (inFlight.size > 0 || finished.length > 0);
+          const waitAfterTurn = rootTurnCompleted && timeoutMs !== 0 && !abortInvoked && turn?.status === "completed" && goalStatus === "active";
           for (const event of toNormalizedCodexEvents(request.runId, message)) {
-            if (event.type === "run.completed" && (waitAfterTurn || turn?.status === "interrupted")) continue;
+            if (event.type === "run.completed" && (!rootTurnCompleted || waitAfterTurn || turn?.status === "interrupted")) continue;
             sink.emitEvent(event);
             if (event.type === "text.delta") {
               streamedText += event.delta;
@@ -4740,61 +4769,31 @@ var CodexAgentAdapter = class {
             rootThreadId = message.params?.thread?.id ?? rootThreadId;
           }
           if (message.method === "turn/started") {
-            turnId = turn?.id ?? turnId;
             if (isRootThread(message.params)) {
+              turnId = turn?.id ?? turnId;
               streamedText = "";
               turnMessageText = "";
-              if (pendingWait) debugCodex("\u2605 follow-up turn started; background wait over");
+              if (pendingWait) debugCodex("\u2605 follow-up turn started; native goal wait over");
               endWait();
-              emitTasks(liveTasks(), false);
-            }
-          }
-          if (item?.type === "commandExecution" && typeof item.id === "string" && isRootThread(message.params)) {
-            if (message.method === "item/started") {
-              inFlight.set(item.id, {
-                id: item.id,
-                command: String(item.command ?? ""),
-                processId: typeof item.processId === "string" ? item.processId : void 0,
-                outlived: false
-              });
-            } else if (message.method === "item/completed") {
-              const tracked = inFlight.get(item.id);
-              inFlight.delete(item.id);
-              if (tracked?.outlived && pendingWait) {
-                finished.push({
-                  ...tracked,
-                  aggregatedOutput: typeof item.aggregatedOutput === "string" ? item.aggregatedOutput : void 0,
-                  exitCode: typeof item.exitCode === "number" ? item.exitCode : void 0,
-                  durationMs: typeof item.durationMs === "number" ? item.durationMs : void 0
-                });
-              }
-              emitTasks(liveTasks(), pendingWait !== void 0);
-              pendingWait?.setIdle(inFlight.size === 0);
-              if (pendingWait && inFlight.size === 0) await sendBackgroundFollowUp();
             }
           }
           if (rootTurnCompleted) {
-            pendingTurns--;
-            if (pendingTurns <= 0) {
-              const previousText = lastTurn?.text;
-              lastTurn = { text: streamedText, messageText: turnMessageText };
-              if (!waitAfterTurn) {
-                resolve({
-                  text: streamedText || previousText,
-                  turnId,
-                  threadId: rootThreadId,
-                  interrupted: turn?.status === "interrupted"
-                });
-                return;
-              }
-              for (const tracked of inFlight.values()) tracked.outlived = true;
-              debugCodex("\u2605 turn ended with %d command(s) in flight; waiting", inFlight.size);
-              endWait();
-              pendingWait = new BackgroundWait(BACKGROUND_TASK_GRACE_MS, Math.max(0, timeoutMs - waitedMs));
-              pendingWait.setIdle(inFlight.size === 0);
-              emitTasks(liveTasks(), true);
-              if (inFlight.size === 0) await sendBackgroundFollowUp();
+            const previousText = lastTurn?.text;
+            lastTurn = { text: streamedText, messageText: turnMessageText };
+            if (!waitAfterTurn) {
+              resolve({
+                text: streamedText || previousText,
+                turnId,
+                threadId: rootThreadId,
+                interrupted: turn?.status === "interrupted"
+              });
+              return;
             }
+            debugCodex("\u2605 turn ended with an active goal; waiting for native continuation");
+            endWait();
+            pendingWait = new BackgroundWait(BACKGROUND_TASK_GRACE_MS, Math.max(0, timeoutMs - waitedMs));
+            pendingWait.setIdle(true);
+            emitGoalWaiting(true);
           }
           if (message.method === "error" && !shouldIgnoreCodexError(message)) {
             reject(message);
@@ -4807,17 +4806,7 @@ var CodexAgentAdapter = class {
     });
     try {
       if (!runtime.client) {
-        await client.request("initialize", {
-          clientInfo: {
-            title: "AgentBox",
-            name: "AgentBox",
-            version: "0.1.0"
-          },
-          capabilities: {
-            experimentalApi: true
-          }
-        });
-        await client.notify("initialized", {});
+        await initializeCodexClient(client);
       }
       const cwd = request.options.cwd ?? process.cwd();
       let threadResponse;
@@ -4873,7 +4862,6 @@ var CodexAgentAdapter = class {
         completionError = err;
       }
       endWait();
-      emitTasks([], false);
       if (completionError !== void 0) {
         if (abortInvoked) {
           debugCodex(
@@ -4919,8 +4907,8 @@ var CodexAgentAdapter = class {
    * driven by the normalized `message.started` event whose
    * `messageId` IS the codex turnId).
    *
-   * When that interrupt is rejected — the thread is idle in a background
-   * wait, or the turn id is stale or missing — a turn is started only to be
+   * When that interrupt is rejected — the thread is between native goal
+   * turns, or the turn id is stale or missing — a turn is started only to be
    * interrupted, so the originating run still observes an interrupted turn
    * and cancels; the model's leftover processes are then terminated.
    * Without `sessionId` the call is a no-op.
@@ -6830,6 +6818,9 @@ var Agent = class {
     this.setupPromise = void 0;
   }
   stream(runConfig) {
+    if (this.provider !== AgentProvider.Codex && (runConfig.reasoning === "max" || runConfig.reasoning === "ultra")) {
+      throw new Error(`Reasoning effort "${runConfig.reasoning}" is only supported by Codex.`);
+    }
     if (runConfig.resumeSessionId && runConfig.forkSessionId) {
       throw new Error(
         "AgentRunConfig.resumeSessionId and forkSessionId are mutually exclusive."

package/dist/events/index.d.ts

@@ -1,4 +1,4 @@
-export { A as AISDKEvent, C as BackgroundTask, D as BackgroundTasksEvent, W as MessageCompletedEvent, X as MessageInjectedEvent, Y as MessageStartedEvent, Z as NativePlanEvent, _ as NormalizedAgentEvent, $ as NormalizedAgentEventBase, a0 as NormalizedAgentEventType, a7 as PermissionRequestedEvent, a8 as PermissionResolvedEvent, a9 as RawAgentEvent, aa as ReasoningDeltaEvent, ac as RunCancelledEvent, ad as RunCompletedEvent, ae as RunErrorEvent, af as RunStartedEvent, ah as TextDeltaEvent, aj as ToolCallCompletedEvent, ak as ToolCallDeltaEvent, al as ToolCallStartedEvent, ao as createNormalizedEvent, ap as normalizeRawAgentEvent, aq as toAISDKEvent, ar as toAISDKStream } from '../types-B4yy80AJ.js';
+export { A as AISDKEvent, C as BackgroundTask, D as BackgroundTasksEvent, W as MessageCompletedEvent, X as MessageInjectedEvent, Y as MessageStartedEvent, Z as NativePlanEvent, _ as NormalizedAgentEvent, $ as NormalizedAgentEventBase, a0 as NormalizedAgentEventType, a7 as PermissionRequestedEvent, a8 as PermissionResolvedEvent, a9 as RawAgentEvent, aa as ReasoningDeltaEvent, ac as RunCancelledEvent, ad as RunCompletedEvent, ae as RunErrorEvent, af as RunStartedEvent, ah as TextDeltaEvent, aj as ToolCallCompletedEvent, ak as ToolCallDeltaEvent, al as ToolCallStartedEvent, ao as createNormalizedEvent, ap as normalizeRawAgentEvent, aq as toAISDKEvent, ar as toAISDKStream } from '../types-NhKw_6mW.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 DataContent, T as EmbeddedSkillConfig, U as FilePart, V as ImagePart, W as MessageCompletedEvent, X as MessageInjectedEvent, Y as MessageStartedEvent, Z as NativePlanEvent, _ as NormalizedAgentEvent, $ as NormalizedAgentEventBase, a0 as NormalizedAgentEventType, a1 as OpenCodeAgentOptions, a2 as OpenCodePluginConfig, a3 as OpenCodePluginEvent, a4 as OpenCodePluginHookConfig, a5 as OpenCodeProviderOptions, a6 as OpenRouterPlugin, a7 as PermissionRequestedEvent, a8 as PermissionResolvedEvent, a9 as RawAgentEvent, aa as ReasoningDeltaEvent, ab as RepoSkillConfig, ac as RunCancelledEvent, ad as RunCompletedEvent, ae as RunErrorEvent, af as RunStartedEvent, ag as SetupLayout, ah as TextDeltaEvent, ai as TextPart, aj as ToolCallCompletedEvent, ak as ToolCallDeltaEvent, al as ToolCallStartedEvent, am as UserContent, an as UserContentPart, ao as createNormalizedEvent, ap as normalizeRawAgentEvent, aq as toAISDKEvent, ar as toAISDKStream } from './types-B4yy80AJ.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 DataContent, T as EmbeddedSkillConfig, U as FilePart, V as ImagePart, W as MessageCompletedEvent, X as MessageInjectedEvent, Y as MessageStartedEvent, Z as NativePlanEvent, _ as NormalizedAgentEvent, $ as NormalizedAgentEventBase, a0 as NormalizedAgentEventType, a1 as OpenCodeAgentOptions, a2 as OpenCodePluginConfig, a3 as OpenCodePluginEvent, a4 as OpenCodePluginHookConfig, a5 as OpenCodeProviderOptions, a6 as OpenRouterPlugin, a7 as PermissionRequestedEvent, a8 as PermissionResolvedEvent, a9 as RawAgentEvent, aa as ReasoningDeltaEvent, ab as RepoSkillConfig, ac as RunCancelledEvent, ad as RunCompletedEvent, ae as RunErrorEvent, af as RunStartedEvent, ag as SetupLayout, ah as TextDeltaEvent, ai as TextPart, aj as ToolCallCompletedEvent, ak as ToolCallDeltaEvent, al as ToolCallStartedEvent, am as UserContent, an as UserContentPart, ao as createNormalizedEvent, ap as normalizeRawAgentEvent, aq as toAISDKEvent, ar as toAISDKStream } from './types-NhKw_6mW.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

@@ -4,7 +4,7 @@ import {
   getAgentLayout,
   harnessCapabilities,
   resolveHarnessCommand
-} from "./chunk-G3VEVR6Y.js";
+} from "./chunk-XJWZR2NR.js";
 import {
   ProviderLogAssembler,
   createNormalizedEvent,

package/dist/{types-B4yy80AJ.d.ts → types-NhKw_6mW.d.ts}

@@ -377,7 +377,8 @@ interface FilePart {
 }
 type UserContentPart = TextPart | ImagePart | FilePart;
 type UserContent = string | UserContentPart[];
-type AgentReasoningEffort = "low" | "medium" | "high" | "xhigh";
+/** `max` and `ultra` are Codex-only and require a supporting model/runtime. */
+type AgentReasoningEffort = "low" | "medium" | "high" | "xhigh" | "max" | "ultra";
 interface AgentRunConfig {
     input: UserContent;
     runId?: string;
@@ -492,6 +493,12 @@ interface AgentOptionsBase {
      * work); `Infinity` waits forever. On expiry the tasks are stopped
      * best-effort and the run completes with the last turn's text. Progress
      * is reported through `background.tasks` events.
+     * For Codex, only gaps between active native goal turns use this budget
+     * (also bounded by the idle grace). Ordinary turns finish on turn/completed,
+     * regardless of live shell processes. No synthetic command-result turn is
+     * injected, and goal-wait expiry does not terminate remote shell processes.
+     * Inactive goals settle after their final turn; clearing a goal while idle
+     * settles immediately.
      */
     backgroundTaskTimeoutMs?: number;
     approvalMode?: AgentApprovalMode;
@@ -505,6 +512,12 @@ interface AgentOptionsBase {
     commands?: AgentCommandConfig[];
 }
 interface CodexProviderOptions {
+    /** Prepare the next host app-server during setup(), before a prompt arrives.
+     * No thread or turn is started. Each execution still owns and stops its
+     * process; killServer() also disposes an unused prepared process. */
+    prewarm?: boolean;
+    /** Native service tier; "default" explicitly selects standard speed. */
+    serviceTier?: string;
     /** Explicit policy for new, resumed, and forked native sessions. */
     approvalPolicy?: "untrusted" | "on-request" | "never";
     /** Managed host execution defaults to read-only; native configuration uses the CLI's settings. */
@@ -564,6 +577,8 @@ interface OpenCodeProviderOptions {
     plugins?: OpenCodePluginConfig[];
 }
 interface ClaudeCodeProviderOptions {
+    /** Request fast mode explicitly; false overrides inherited fast settings. */
+    fastMode?: boolean;
     binary?: string;
     args?: string[];
     hooks?: ClaudeCodeHooksConfig;

package/package.json

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