agent-accelerator 0.5.8 → 0.6.0

package/src/agent/agent.ts

@@ -1,10 +1,26 @@
-import type { AgentConfig, EditableAgentConfig, AgentRunOptions, MidSessionConfig, ToolChoiceOption, RetryPolicyConfig, Budget, BudgetState, InterruptedRun } from "../types/agent.ts";
+import type {
+  AgentConfig,
+  EditableAgentConfig,
+  AgentRunOptions,
+  MidSessionConfig,
+  ToolChoiceOption,
+  RetryPolicyConfig,
+  Budget,
+  BudgetState,
+  InterruptedRun,
+} from "../types/agent.ts";
 import type { TokenUsage } from "../types/core.ts";
 import type { ProviderRequestOptions } from "../types/model.ts";
 import { normalizeThinkingV2, resolveWhenBusy } from "../tools/tool.ts";
 import type { ToolDefinition, ToolResultRecord } from "../types/tool.ts";
 import { isSubagentResult } from "../tools/subagent-result.ts";
-import { CACHE_OPTIONS, type ThinkingLevel, type ThinkingConfig, type CacheOption, type ServiceTier } from "../types/core.ts";
+import {
+  CACHE_OPTIONS,
+  type ThinkingLevel,
+  type ThinkingConfig,
+  type CacheOption,
+  type ServiceTier,
+} from "../types/core.ts";
 import type { ContentPart } from "../types/message.ts";
 import { AgentResponse, type StreamEvent } from "../types/response.ts";
 import { AssistantMessageEventStream } from "../streaming/event-stream.ts";
@@ -13,21 +29,23 @@ import { resolveModel } from "../providers/registry.ts";
 import { buildAgentTools } from "./delegation.ts";
 import { createSubagentsTool } from "./subagents-tool.ts";
 import { WorkerRegistry } from "./workers.ts";
-import {
-  DEFAULT_MAX_DEPTH,
-  normalizeToolMap,
-  resolveDynamicModelInput,
-  resolveMainModel,
-} from "./worker.ts";
+import { DEFAULT_MAX_DEPTH, normalizeToolMap, resolveDynamicModelInput, resolveMainModel } from "./worker.ts";
 import * as path from "node:path";
 import { registerAgent } from "../scheduler/scheduler.ts";
-import { resolveHome } from "../scheduler/store.ts";
+import { resolveHome } from "../utils/home.ts";
 import { persistTelemetry, registerSessionFolder, unregisterSessionFolder } from "../telemetry-file.ts";
 import { lockFolder } from "../utils/durable.ts";
 import { createScheduledActionsTool, getDatetimeTool } from "../scheduler/tool.ts";
 import { applyEditable, assertModelAllowed, modelKey, toEditableConfig } from "./config-blocks.ts";
 import { assertNoToolCollisions } from "../tools/executor.ts";
-import { runAgentLoop, streamAgentLoop, unfinishedToolCalls, endsWithStop, accumulateUsage, type SteerEntry } from "./loop.ts";
+import {
+  runAgentLoop,
+  streamAgentLoop,
+  unfinishedToolCalls,
+  endsWithStop,
+  accumulateUsage,
+  type SteerEntry,
+} from "./loop.ts";
 import { isRetryableRun, readRetryAfterMs, sleep } from "../utils/retry.ts";
 import { createSessionId, nowMs, newRunId, previewPrompt } from "../utils/session.ts";
 import {
@@ -38,32 +56,50 @@ import {
   listSubAgentTraceIdsForSessions,
   type SubAgentTrace,
 } from "./delegation.ts";
-import { addTurn, buildUsageReport, emptyUsage, mergeUsage, modelName, readUsage, type UsageNode, type UsageReport, type UsageTotals } from "../session/usage.ts";
-import { saveSessionFile, sessionDirFor, loadSessionDir, findInvalidMessage, priceUsage, telemetryBus, type SessionRunMark, type SessionRunEnd, type SessionPending, type SessionToolRecord } from "../session/store.ts";
+import {
+  addTurn,
+  buildUsageReport,
+  emptyUsage,
+  mergeUsage,
+  modelName,
+  readUsage,
+  type UsageNode,
+  type UsageReport,
+  type UsageTotals,
+} from "../session/usage.ts";
+import {
+  saveSessionFile,
+  sessionDirFor,
+  loadSessionDir,
+  findInvalidMessage,
+  priceUsage,
+  telemetryBus,
+  type SessionRunMark,
+  type SessionRunEnd,
+  type SessionPending,
+  type SessionToolRecord,
+} from "../session/store.ts";
 import { SessionJournal } from "../session/journal.ts";
 import { ToolLogs, type ToolLogWriter } from "../session/tool-log.ts";
 import { isLocalPathInput } from "../utils/safe-io.ts";
-import { clearSessionRouting, normalizeStructuredOutput, normalizeStop } from "../providers.ts";
+import { clearSessionRouting, normalizeStructuredOutput } from "../providers.ts";
 import type { StructuredOutputSpec } from "../types/model.ts";
 import { clearInteractionChains } from "../providers/google.ts";
 import { validateModelThinking, ensureModelCatalogFresh } from "../models/catalog.ts";
-import { buildSessionData, type PersistedAgentSession, type SessionTotals,} from "../session/store.ts";
+import { buildSessionData, type PersistedAgentSession, type SessionTotals } from "../session/store.ts";
 import { SessionTelemetry } from "../session/store.ts";
 
 /**
  * Resolves a per-run thinking override without mutating agent config.
  */
-export function resolveEffectiveThinking(
-  base?: ThinkingConfig,
-  overrideLevel?: string
-): ThinkingConfig | undefined {
+export function resolveEffectiveThinking(base?: ThinkingConfig, overrideLevel?: string): ThinkingConfig | undefined {
   if (!overrideLevel) return base;
   if (overrideLevel === "none") return { enabled: false, level: "none", budgetTokens: 0 };
   if (overrideLevel === "dynamic") return { enabled: true, level: "dynamic", budgetTokens: -1 };
   return { enabled: true, level: overrideLevel as ThinkingConfig["level"] };
 }
 
-import { ConfigError, SessionLoadError, isAbortError } from "../types/errors.ts";
+import { ConfigError, SessionLoadError, ValidationError, isAbortError } from "../types/errors.ts";
 
 /**
  * Disposers for the manual user-signal forward listeners (fallback when
@@ -94,8 +130,7 @@ export interface AgentRunLimits {
 /** Resolves `(config as any).limits` with defaults (timeouts tolerate reasoning). */
 function resolveAgentLimits(config: { limits?: Record<string, unknown> }): AgentRunLimits {
   const raw = (config as { limits?: Record<string, unknown> }).limits ?? {};
-  const num = (v: unknown): number | undefined =>
-    typeof v === "number" && Number.isFinite(v) ? v : undefined;
+  const num = (v: unknown): number | undefined => (typeof v === "number" && Number.isFinite(v) ? v : undefined);
   // A network timeout: `0` or `Infinity` turns it off, any other number is milliseconds, anything else is unset (the default applies).
   const timeout = (v: unknown): number | undefined => (typeof v === "number" && !Number.isNaN(v) ? v : undefined);
   return {
@@ -104,7 +139,9 @@ function resolveAgentLimits(config: { limits?: Record<string, unknown> }): Agent
     ...(num(raw.maxToolCallsPerRun) !== undefined
       ? { maxToolCallsPerRun: Math.max(1, Math.floor(num(raw.maxToolCallsPerRun)!)) }
       : {}),
-    ...(num(raw.maxTotalTokens) !== undefined ? { maxTotalTokens: Math.max(1, Math.floor(num(raw.maxTotalTokens)!)) } : {}),
+    ...(num(raw.maxTotalTokens) !== undefined
+      ? { maxTotalTokens: Math.max(1, Math.floor(num(raw.maxTotalTokens)!)) }
+      : {}),
     requestTimeoutMs: timeout(raw.requestTimeoutMs) ?? 300_000,
     firstByteTimeoutMs: timeout(raw.firstByteTimeoutMs) ?? 120_000,
     streamIdleTimeoutMs: timeout(raw.streamIdleTimeoutMs) ?? 300_000,
@@ -216,8 +253,6 @@ export class Agent {
   private readonly callDefaults: {
     toolChoice?: ToolChoiceOption;
     maxOutputTokens?: number;
-    stop?: string | string[];
-    seed?: number;
     retry?: RetryPolicyConfig;
     env?: Record<string, string>;
     fetch?: typeof fetch;
@@ -325,34 +360,50 @@ export class Agent {
     this.subagentModel = dynModel as string | any | undefined;
     const dynEnabled = dynRaw ? (dynRaw.enabled ?? true) : false;
     if (dynRaw) {
-      const dynTools = normalizeToolMap((dynRaw as { tools?: Record<string, ToolDefinition> | ToolDefinition[] }).tools);
+      const dynTools = normalizeToolMap(
+        (dynRaw as { tools?: Record<string, ToolDefinition> | ToolDefinition[] }).tools
+      );
       const rawDepth = (dynRaw as { maxDepth?: unknown }).maxDepth;
       // Depth is unlimited unless the developer sets a cap (a whole number >= 1; Infinity also means unlimited).
-      if (rawDepth !== undefined && rawDepth !== Infinity && !(Number.isInteger(rawDepth) && (rawDepth as number) >= 1)) {
-        throw new ConfigError(`[Agent Accelerator] Invalid dynamicSubagents.maxDepth ${JSON.stringify(rawDepth)}: expected a whole number >= 1, or omit it for no limit; set dynamicSubagents.enabled: false to turn workers off.`);
+      if (
+        rawDepth !== undefined &&
+        rawDepth !== Infinity &&
+        !(Number.isInteger(rawDepth) && (rawDepth as number) >= 1)
+      ) {
+        throw new ConfigError(
+          `[Agent Accelerator] Invalid dynamicSubagents.maxDepth ${JSON.stringify(rawDepth)}: expected a whole number >= 1, or omit it for no limit; set dynamicSubagents.enabled: false to turn workers off.`
+        );
       }
       const rawBudget = (dynRaw as { workerBudget?: { maxCostUsd?: unknown; maxTotalTokens?: unknown } }).workerBudget;
       for (const key of ["maxCostUsd", "maxTotalTokens"] as const) {
         const v = rawBudget?.[key];
         if (v !== undefined && !(typeof v === "number" && Number.isFinite(v) && v > 0)) {
-          throw new ConfigError(`[Agent Accelerator] Invalid dynamicSubagents.workerBudget.${key} ${JSON.stringify(v)}: expected a number greater than 0, or omit it for no limit.`);
+          throw new ConfigError(
+            `[Agent Accelerator] Invalid dynamicSubagents.workerBudget.${key} ${JSON.stringify(v)}: expected a number greater than 0, or omit it for no limit.`
+          );
         }
       }
       // Open workers are unlimited unless the developer sets a cap (a number >= 1; Infinity also means unlimited).
       const rawMax = (dynRaw as { maxSpawn?: unknown }).maxSpawn;
       if (rawMax !== undefined && (typeof rawMax !== "number" || Number.isNaN(rawMax))) {
-        throw new ConfigError(`[Agent Accelerator] Invalid dynamicSubagents.maxSpawn ${JSON.stringify(rawMax)}: expected a whole number >= 1, or omit it for no limit.`);
+        throw new ConfigError(
+          `[Agent Accelerator] Invalid dynamicSubagents.maxSpawn ${JSON.stringify(rawMax)}: expected a whole number >= 1, or omit it for no limit.`
+        );
       }
       const maxSpawn = rawMax === undefined || rawMax === Infinity ? Infinity : Math.max(1, Math.floor(rawMax));
       // Only scheduled actions are timed: no limit unless the developer sets one (0 and Infinity mean none).
       for (const removed of ["timeout", "modelMaySetTimeout"]) {
         if ((dynRaw as Record<string, unknown>)[removed] !== undefined) {
-          throw new ConfigError(`[Agent Accelerator] dynamicSubagents.${removed} was removed: set dynamicSubagents.workerTimeoutMs (the longest a scheduled run may take, optional) and let each scheduled action carry its own timeoutMs.`);
+          throw new ConfigError(
+            `[Agent Accelerator] dynamicSubagents.${removed} was removed: set dynamicSubagents.workerTimeoutMs (the longest a scheduled run may take, optional) and let each scheduled action carry its own timeoutMs.`
+          );
         }
       }
       const rawTimeout = (dynRaw as { workerTimeoutMs?: unknown }).workerTimeoutMs;
       if (rawTimeout !== undefined && (typeof rawTimeout !== "number" || Number.isNaN(rawTimeout) || rawTimeout < 0)) {
-        throw new ConfigError(`[Agent Accelerator] Invalid dynamicSubagents.workerTimeoutMs ${JSON.stringify(rawTimeout)}: expected a number of milliseconds > 0, or omit it (0 and Infinity mean no limit).`);
+        throw new ConfigError(
+          `[Agent Accelerator] Invalid dynamicSubagents.workerTimeoutMs ${JSON.stringify(rawTimeout)}: expected a number of milliseconds > 0, or omit it (0 and Infinity mean no limit).`
+        );
       }
       const workerTimeoutMs = !rawTimeout ? Infinity : Math.max(1, Math.floor(rawTimeout));
       this.dynamicSubagents = {
@@ -419,17 +470,20 @@ export class Agent {
     }
     this.cache = config.cache;
     if (config.resume !== undefined && config.resume !== "automatic" && config.resume !== "explicit") {
-      throw new ConfigError(`[Agent Accelerator] Invalid resume ${JSON.stringify(config.resume)}: expected "automatic" (default) or "explicit".`);
+      throw new ConfigError(
+        `[Agent Accelerator] Invalid resume ${JSON.stringify(config.resume)}: expected "automatic" (default) or "explicit".`
+      );
     }
     this.resumeMode = config.resume ?? "automatic";
     if (config.runRetries !== undefined && !(Number.isInteger(config.runRetries) && config.runRetries >= 0)) {
-      throw new ConfigError(`[Agent Accelerator] Invalid runRetries ${JSON.stringify(config.runRetries)}: expected a whole number >= 0 (default 3, 0 turns it off).`);
+      throw new ConfigError(
+        `[Agent Accelerator] Invalid runRetries ${JSON.stringify(config.runRetries)}: expected a whole number >= 0 (default 3, 0 turns it off).`
+      );
     }
     this.runRetries = config.runRetries ?? 3;
 
     this.serviceTier = config.serviceTier;
-    this.onFailure =
-      config.onFailure === "rollback" || config.onFailure === "keep" ? config.onFailure : "auto";
+    this.onFailure = config.onFailure === "rollback" || config.onFailure === "keep" ? config.onFailure : "auto";
     this.forkConfig = { ...config };
     this.captureRaw = config.captureRaw;
     this.budget = config.budget ? { ...config.budget } : undefined;
@@ -448,8 +502,6 @@ export class Agent {
     this.callDefaults = {
       toolChoice: config.toolChoice,
       maxOutputTokens: config.maxOutputTokens,
-      stop: config.stop,
-      seed: config.seed,
       retry: config.retry,
       env: config.env,
       fetch: config.fetch,
@@ -466,7 +518,6 @@ export class Agent {
       Object.assign(this.tools, normalizeToolMap(config.tools));
     }
 
-
     if (Array.isArray(config.subagents)) {
       const subagentTools = buildAgentTools(config.subagents);
       for (const [toolName, toolDef] of Object.entries(subagentTools)) {
@@ -574,7 +625,11 @@ export class Agent {
 
   // Records one model call of THIS agent (priced per turn, with the service tier); in: the loop's onTurnUsage, out: this.usageTotals (saved by the next persist).
   private recordTurnUsage(usage: TokenUsage, spec: Parameters<typeof priceUsage>[1]): void {
-    addTurn(this.usageTotals, usage, priceUsage(usage, spec, this.serviceTier ? { serviceTier: this.serviceTier } : undefined));
+    addTurn(
+      this.usageTotals,
+      usage,
+      priceUsage(usage, spec, this.serviceTier ? { serviceTier: this.serviceTier } : undefined)
+    );
   }
 
   /** Adds another agent's spending to this one (a fixed worker's per-call copy into its template). @internal */
@@ -589,7 +644,10 @@ export class Agent {
    * below it. Spending of one-shot scheduled-action workers is in their run files, not here.
    */
   usageReport(): UsageReport {
-    return buildUsageReport({ id: this.sessionId, name: this.name, model: modelName(this.modelStringOrSpec), totals: this.usageTotals }, [...this.workers.usageNodes(), ...this.fixedWorkerNodes()]);
+    return buildUsageReport(
+      { id: this.sessionId, name: this.name, model: modelName(this.modelStringOrSpec), totals: this.usageTotals },
+      [...this.workers.usageNodes(), ...this.fixedWorkerNodes()]
+    );
   }
 
   // The `subagents: [...]` workers as usage nodes (their per-call copies' spending is merged into them); in: the constructor config, out: usageReport.
@@ -598,14 +656,25 @@ export class Agent {
     for (const entry of this.forkConfig.subagents ?? []) {
       const worker = "agent" in entry ? entry.agent : entry;
       const name = "agent" in entry ? entry.name : worker.name;
-      nodes.push({ id: name, name, model: modelName(worker.modelStringOrSpec), status: "fixed", totals: worker.usageTotals, workers: [] });
+      nodes.push({
+        id: name,
+        name,
+        model: modelName(worker.modelStringOrSpec),
+        status: "fixed",
+        totals: worker.usageTotals,
+        workers: [],
+      });
     }
     return nodes;
   }
 
   // Says on the telemetry bus that resuming (or a prompt that was waiting) failed; in: a rejected resume, out: telemetryBus.
   private reportResumeFailure(err: unknown): void {
-    telemetryBus.emitWarning("agent.resume_failed", `[Agent Accelerator] Resuming session ${this.sessionId} failed: ${err instanceof Error ? err.message : String(err)}`, { sessionId: this.sessionId });
+    telemetryBus.emitWarning(
+      "agent.resume_failed",
+      `[Agent Accelerator] Resuming session ${this.sessionId} failed: ${err instanceof Error ? err.message : String(err)}`,
+      { sessionId: this.sessionId }
+    );
   }
 
   /** Runs that a crash cut off (they began, never ended and are not running now), oldest first. Needs `persist: { dir }` and the same `sessionId` as before the restart. */
@@ -629,7 +698,8 @@ export class Agent {
    */
   resume(): Promise<AgentResponse | undefined> {
     if (this.resuming) return this.resuming;
-    if (this.currentRun) throw new Error("[Agent Accelerator] resume() needs an idle agent: a run is already active.");
+    if (this.currentRun)
+      throw new ValidationError("[Agent Accelerator] resume() needs an idle agent: a run is already active.");
     const mark = this.runMarks.filter((m) => !m.end && m !== this.activeMark).pop();
     const last = this.context.messages[this.context.messages.length - 1];
     const nothingOpen = unfinishedToolCalls(this.context.messages).length === 0;
@@ -642,7 +712,11 @@ export class Agent {
     telemetryBus.emit({
       code: "agent.resumed",
       message: `[Agent Accelerator] resuming run ${mark.id} of session ${this.sessionId}`,
-      data: { sessionId: this.sessionId, runId: mark.id, pendingToolCalls: unfinishedToolCalls(this.context.messages).map((c) => c.name) },
+      data: {
+        sessionId: this.sessionId,
+        runId: mark.id,
+        pendingToolCalls: unfinishedToolCalls(this.context.messages).map((c) => c.name),
+      },
     });
     const run = this.startNonStreamingRun("", undefined, mark);
     const clear = (): void => {
@@ -655,7 +729,18 @@ export class Agent {
 
   // The finished tool calls of the current run as results the loop can reuse; in: toolRecords, out: loopConfig.resume.stored.
   private storedToolResults(): Map<string, ToolResultRecord> {
-    return new Map(this.toolRecords.map((t) => [t.id, { id: t.id, name: t.name, result: t.result, ...(t.isError ? { isError: true } : {}), ...(t.stopped ? { stopped: true } : {}) } as ToolResultRecord]));
+    return new Map(
+      this.toolRecords.map((t) => [
+        t.id,
+        {
+          id: t.id,
+          name: t.name,
+          result: t.result,
+          ...(t.isError ? { isError: true } : {}),
+          ...(t.stopped ? { stopped: true } : {}),
+        } as ToolResultRecord,
+      ])
+    );
   }
 
   // Closes a run's mark with how it ended and saves that at once (not on the next tick), so the disk is up to date when `await run()` returns; in: the run's promise handlers, out: runMarks + journal.
@@ -683,9 +768,7 @@ export class Agent {
     const base = this.instructions || "";
     let out = base;
     const isThinkingEnabled =
-      this.thinkingConfig?.enabled !== false &&
-      this.thinkingConfig?.level &&
-      this.thinkingConfig?.level !== "none";
+      this.thinkingConfig?.enabled !== false && this.thinkingConfig?.level && this.thinkingConfig?.level !== "none";
     if (isThinkingEnabled && !out.includes("[Reasoning Directive]")) {
       const guidance =
         "[Reasoning Directive]\n" +
@@ -697,16 +780,22 @@ export class Agent {
     return out || undefined;
   }
 
-  /** Clears conversation messages and provider thought signatures while keeping configuration. */
+  /** Starts a fresh conversation: clears messages, signatures, run marks and the run's saved tool results, keeps config and spending totals. */
   reset(): void {
     const sid = this.sessionId;
     this.context.messages = [];
     this.context.thoughtSignatures = [];
     this.context.systemPrompt = this.getFullInstructions();
     this.runMarks.length = 0;
+    this.toolRecords.length = 0; // a cleared conversation has no run to resume, so its finished tool results go too
+    this.activeMark = undefined;
     // Reset also drops session-scoped provider chaining/routing.
-    try { clearInteractionChains(sid); } catch {}
-    try { clearSessionRouting(sid); } catch {}
+    try {
+      clearInteractionChains(sid);
+    } catch {}
+    try {
+      clearSessionRouting(sid);
+    } catch {}
   }
 
   /**
@@ -725,17 +814,27 @@ export class Agent {
   /** Drops one named session. No-op for unknown ids. */
   disposeSession(id: string): void {
     unregisterSessionFolder(id);
-    try { this.sessions.delete(id); } catch {}
-    try { clearInteractionChains(id); } catch {}
-    try { clearSessionRouting(id); } catch {}
+    try {
+      this.sessions.delete(id);
+    } catch {}
+    try {
+      clearInteractionChains(id);
+    } catch {}
+    try {
+      clearSessionRouting(id);
+    } catch {}
   }
 
   /** Drops all named sessions except the default context. */
   clearSessions(): void {
     try {
       for (const id of [...this.sessions.keys()]) {
-        try { clearInteractionChains(id); } catch {}
-        try { clearSessionRouting(id); } catch {}
+        try {
+          clearInteractionChains(id);
+        } catch {}
+        try {
+          clearSessionRouting(id);
+        } catch {}
       }
       this.sessions.clear();
     } catch {}
@@ -751,8 +850,12 @@ export class Agent {
       for (const [key, entry] of [...this.sessions.entries()]) {
         if (now - entry.lastAccess > SESSION_TTL_MS) {
           this.sessions.delete(key);
-          try { clearInteractionChains(key); } catch {}
-          try { clearSessionRouting(key); } catch {}
+          try {
+            clearInteractionChains(key);
+          } catch {}
+          try {
+            clearSessionRouting(key);
+          } catch {}
         }
       }
     } catch {}
@@ -769,12 +872,19 @@ export class Agent {
         let oldest: string | undefined;
         let oldestTs = Infinity;
         for (const [key, entry] of this.sessions) {
-          if (entry.lastAccess < oldestTs) { oldestTs = entry.lastAccess; oldest = key; }
+          if (entry.lastAccess < oldestTs) {
+            oldestTs = entry.lastAccess;
+            oldest = key;
+          }
         }
         if (!oldest) break;
         this.sessions.delete(oldest);
-        try { clearInteractionChains(oldest); } catch {}
-        try { clearSessionRouting(oldest); } catch {}
+        try {
+          clearInteractionChains(oldest);
+        } catch {}
+        try {
+          clearSessionRouting(oldest);
+        } catch {}
       }
     } catch {}
     return fresh;
@@ -787,8 +897,12 @@ export class Agent {
     const err = Object.assign(new Error("Queue cleared"), { name: "AbortError" });
     const pending = this.pendingQueue.splice(0);
     for (const entry of pending) {
-      try { entry.reject(err); } catch {}
-      try { entry.deferredStream?.fail(err instanceof Error ? err : new Error(String(err))); } catch {}
+      try {
+        entry.reject(err);
+      } catch {}
+      try {
+        entry.deferredStream?.fail(err instanceof Error ? err : new Error(String(err)));
+      } catch {}
     }
     this.persistNow();
     return n;
@@ -798,7 +912,7 @@ export class Agent {
   private assertSteerRoom(inbox: SteerEntry[]): void {
     const max = this.maxSteers ?? 20;
     if (inbox.length >= max) {
-      throw new Error(
+      throw new ValidationError(
         `[Agent Accelerator] Steer inbox is full (${inbox.length}/${max}). Wait for the active run to drain or increase midSession.maxSteers.`
       );
     }
@@ -837,7 +951,7 @@ export class Agent {
   // Throws synchronously on an empty content-part array so run() and stream() fail at the same moment; in: any prompt entry point, out: nothing.
   private assertPromptValid(prompt: string | ContentPart[]): void {
     if (Array.isArray(prompt) && prompt.length === 0) {
-      throw new Error(
+      throw new ValidationError(
         "[Agent Accelerator] Prompt cannot be empty: pass a non-empty string or at least one content part."
       );
     }
@@ -856,7 +970,9 @@ export class Agent {
   interrupt(arg?: Error | string | ContentPart[], options?: AgentRunOptions): void | Promise<AgentResponse> {
     if (typeof arg === "string" || Array.isArray(arg)) {
       if (options?.stream === true) {
-        throw new Error('[Agent Accelerator] interrupt(message) is non-streaming. Use stream(prompt, { enqueue: "interrupt" }) for a streaming interrupt.');
+        throw new ValidationError(
+          '[Agent Accelerator] interrupt(message) is non-streaming. Use stream(prompt, { enqueue: "interrupt" }) for a streaming interrupt.'
+        );
       }
       return this.run(arg, { ...options, enqueue: "interrupt" });
     }
@@ -898,12 +1014,12 @@ export class Agent {
   steer(prompt: string | ContentPart[], options?: AgentRunOptions): Promise<AgentResponse> {
     this.assertPromptValid(prompt);
     if (options?.stream === true) {
-      throw new Error(
+      throw new ValidationError(
         '[Agent Accelerator] steer() is non-streaming. Use stream(prompt, { enqueue: "steer" }) for a streaming steer.'
       );
     }
     if (this.midSessionConfig.mode === "queue") {
-      throw new Error(
+      throw new ConfigError(
         '[Agent Accelerator] steer() is disabled by midSession.mode "queue". Use queue() or set mode to "auto"/"steer".'
       );
     }
@@ -956,19 +1072,19 @@ export class Agent {
   queue(prompt: string | ContentPart[], options?: AgentRunOptions): Promise<AgentResponse> {
     this.assertPromptValid(prompt);
     if (options?.stream === true) {
-      throw new Error(
+      throw new ValidationError(
         '[Agent Accelerator] queue() is non-streaming. Use stream(prompt, { enqueue: "queue" }) for a streaming follow-up.'
       );
     }
     if (this.midSessionConfig.mode === "steer") {
-      throw new Error(
+      throw new ConfigError(
         '[Agent Accelerator] queue() is disabled by midSession.mode "steer". Use steer() or set mode to "auto"/"queue".'
       );
     }
     if (!this.currentRun) return this.run(prompt, options) as Promise<AgentResponse>;
     const max = this.midSessionConfig.maxQueued ?? 20;
     if (this.pendingQueue.length >= max) {
-      throw new Error(
+      throw new ValidationError(
         `[Agent Accelerator] Queue is full (${this.pendingQueue.length}/${max}). Wait for the active run to finish or increase midSession.maxQueued.`
       );
     }
@@ -999,8 +1115,12 @@ export class Agent {
           reason instanceof Error ? reason : new Error("Queued run aborted before start"),
           { name: "AbortError" }
         );
-        try { next.reject(abortErr); } catch {}
-        try { next.deferredStream?.fail(abortErr instanceof Error ? abortErr : new Error(String(abortErr))); } catch {}
+        try {
+          next.reject(abortErr);
+        } catch {}
+        try {
+          next.deferredStream?.fail(abortErr instanceof Error ? abortErr : new Error(String(abortErr)));
+        } catch {}
         queueMicrotask(() => this.pumpQueue());
         return;
       }
@@ -1009,30 +1129,48 @@ export class Agent {
       const deferred = next.deferredStream;
       try {
         const real = this.startStreamingRun(next.prompt, next.options);
-        try { (deferred as any).__piped = true; } catch {}
+        try {
+          (deferred as any).__piped = true;
+        } catch {}
         const forward = (e: StreamEvent) => {
-          try { deferred.push(e); } catch {}
+          try {
+            deferred.push(e);
+          } catch {}
         };
         real.on("*", forward as any);
         try {
           deferred.onCancel(() => {
-            try { real.cancel(); } catch {}
+            try {
+              real.cancel();
+            } catch {}
           });
         } catch {}
         real.result().then(
           (res) => {
-            try { next.resolve(res); } catch {}
-            try { deferred.end(res); } catch {}
+            try {
+              next.resolve(res);
+            } catch {}
+            try {
+              deferred.end(res);
+            } catch {}
           },
           (err) => {
-            try { next.reject(err); } catch {}
+            try {
+              next.reject(err);
+            } catch {}
             // Pipe failures into the deferred stream so for-await sees them.
-            try { deferred.fail(err instanceof Error ? err : new Error(String(err))); } catch {}
+            try {
+              deferred.fail(err instanceof Error ? err : new Error(String(err)));
+            } catch {}
           }
         );
       } catch (err) {
-        try { next.reject(err); } catch {}
-        try { deferred.fail(err instanceof Error ? err : new Error(String(err))); } catch {}
+        try {
+          next.reject(err);
+        } catch {}
+        try {
+          deferred.fail(err instanceof Error ? err : new Error(String(err)));
+        } catch {}
         // Keep draining even if starting failed.
         queueMicrotask(() => this.pumpQueue());
       }
@@ -1045,7 +1183,11 @@ export class Agent {
   private finishCurrentRun(): void {
     // Leftover steer entries become queued follow-ups instead of dropping.
     let leftover: SteerEntry[] = [];
-    try { leftover = this.currentRun?.steerInbox?.splice(0) ?? []; } catch { leftover = []; }
+    try {
+      leftover = this.currentRun?.steerInbox?.splice(0) ?? [];
+    } catch {
+      leftover = [];
+    }
     this.currentRun = null;
     if (leftover.length > 0) {
       try {
@@ -1055,12 +1197,18 @@ export class Agent {
         for (const entry of leftover) {
           try {
             if ((entry.options as { signal?: AbortSignal } | undefined)?.signal?.aborted) {
-              entry.settle?.reject(Object.assign(new Error("Steer aborted before it could run"), { name: "AbortError" }));
+              entry.settle?.reject(
+                Object.assign(new Error("Steer aborted before it could run"), { name: "AbortError" })
+              );
               continue;
             }
-          } catch { continue; }
+          } catch {
+            continue;
+          }
           if (this.pendingQueue.length + lateSteers.length >= max) {
-            entry.settle?.reject(new Error("[Agent Accelerator] Steer dropped: the follow-up queue is full."));
+            entry.settle?.reject(
+              new ValidationError("[Agent Accelerator] Steer dropped: the follow-up queue is full.")
+            );
             continue;
           }
           // The steer was never injected: it now runs as a follow-up, and the
@@ -1089,7 +1237,9 @@ export class Agent {
     try {
       const dispose = mergeDisposers.get(runController);
       if (dispose) {
-        try { dispose(); } catch {}
+        try {
+          dispose();
+        } catch {}
         mergeDisposers.delete(runController);
       }
     } catch {}
@@ -1103,7 +1253,9 @@ export class Agent {
       try {
         runController.abort((userSignal as any).reason);
       } catch {
-        try { runController.abort(); } catch {}
+        try {
+          runController.abort();
+        } catch {}
       }
       return runController.signal;
     }
@@ -1119,13 +1271,19 @@ export class Agent {
       try {
         runController.abort((userSignal as any).reason);
       } catch {
-        try { runController.abort(); } catch {}
+        try {
+          runController.abort();
+        } catch {}
       }
     };
-    try { userSignal.addEventListener("abort", forward, { once: true }); } catch {}
+    try {
+      userSignal.addEventListener("abort", forward, { once: true });
+    } catch {}
     try {
       mergeDisposers.set(runController, () => {
-        try { userSignal.removeEventListener("abort", forward); } catch {}
+        try {
+          userSignal.removeEventListener("abort", forward);
+        } catch {}
       });
     } catch {}
     return runController.signal;
@@ -1221,9 +1379,7 @@ export class Agent {
     const toolChoice = normalizeToolChoiceOption(runOptions?.toolChoice ?? d.toolChoice);
     const retry = { ...d.retry, ...runOptions?.retry };
     const env = { ...d.env, ...runOptions?.env };
-    const stop = normalizeStop(runOptions?.stop ?? d.stop);
     const maxOutputTokens = runOptions?.maxOutputTokens ?? d.maxOutputTokens;
-    const seed = runOptions?.seed ?? d.seed;
     const fetchImpl = runOptions?.fetch ?? d.fetch;
     return {
       apiKey: this.apiKey,
@@ -1237,8 +1393,6 @@ export class Agent {
       ...(this.googleTier ? { googleTier: this.googleTier } : {}),
       ...(toolChoice !== undefined ? { toolChoice } : {}),
       ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
-      ...(stop ? { stop } : {}),
-      ...(seed !== undefined ? { seed } : {}),
       ...(Object.keys(env).length > 0 ? { env } : {}),
       ...(fetchImpl ? { fetch: fetchImpl } : {}),
       ...(retry.maxRetries !== undefined ? { maxRetries: retry.maxRetries } : {}),
@@ -1312,13 +1466,18 @@ export class Agent {
       const failedAttempts: FailedAttempt[] = [];
       for (let attempt = 0; ; attempt++) {
         try {
-          res = await runAgentLoop(attempt === 0 ? loopConfig : { ...loopConfig, resume: { stored: this.storedToolResults() } });
+          res = await runAgentLoop(
+            attempt === 0 ? loopConfig : { ...loopConfig, resume: { stored: this.storedToolResults() } }
+          );
           break;
         } catch (err) {
           if (attempt >= this.runRetries || runOptions?.signal?.aborted || !isRetryableRun(err)) throw err;
           const partial = (err as { partial?: FailedAttempt }).partial;
           if (partial?.usage) failedAttempts.push(partial);
-          const delayMs = Math.max(RUN_RETRY_DELAYS_MS[Math.min(attempt, RUN_RETRY_DELAYS_MS.length - 1)]!, readRetryAfterMs(err) ?? 0);
+          const delayMs = Math.max(
+            RUN_RETRY_DELAYS_MS[Math.min(attempt, RUN_RETRY_DELAYS_MS.length - 1)]!,
+            readRetryAfterMs(err) ?? 0
+          );
           telemetryBus.emitWarning(
             "agent.run_retry",
             `[Agent Accelerator] Run failed (${err instanceof Error ? err.message : String(err)}); retry ${attempt + 1} of ${this.runRetries} in ${delayMs} ms.`,
@@ -1343,7 +1502,9 @@ export class Agent {
       (err) => this.endRun(mark, isAbortError(err) ? "aborted" : "failed")
     );
     const cleanup = () => {
-      try { this.cleanupMerge(runController); } catch {}
+      try {
+        this.cleanupMerge(runController);
+      } catch {}
       if (this.currentRun?.runPromise === task) this.finishCurrentRun();
     };
     task.then(cleanup, cleanup);
@@ -1351,10 +1512,7 @@ export class Agent {
   }
 
   // Starts one streaming run: validates the model and thinking level synchronously, adds the prompt, builds the loop config and returns the loop's event stream, recording the run ending when it settles; in: stream()/pumpQueue, out: an AssistantMessageEventStream.
-  private startStreamingRun(
-    prompt: string | ContentPart[],
-    options?: AgentRunOptions
-  ): AssistantMessageEventStream {
+  private startStreamingRun(prompt: string | ContentPart[], options?: AgentRunOptions): AssistantMessageEventStream {
     const resolved = resolveModel(this.modelStringOrSpec);
     const effectiveLevel = normalizeThinkingV2(options?.thinking, options?.thinkingLevel) || this.thinkingConfig?.level;
     if (effectiveLevel) {
@@ -1406,7 +1564,9 @@ export class Agent {
           this.mergeSubagentTraces(res.subagents as any);
           this.persistNow();
         } catch {}
-        try { this.cleanupMerge(runController); } catch {}
+        try {
+          this.cleanupMerge(runController);
+        } catch {}
         if (this.stateless) {
           targetContext.messages = [];
           targetContext.thoughtSignatures = [];
@@ -1415,7 +1575,9 @@ export class Agent {
       },
       (err) => {
         this.endRun(mark, isAbortError(err) ? "aborted" : "failed");
-        try { this.cleanupMerge(runController); } catch {}
+        try {
+          this.cleanupMerge(runController);
+        } catch {}
         if (this.currentRun?.outerStream === s) this.finishCurrentRun();
       }
     );
@@ -1532,12 +1694,24 @@ export class Agent {
       else if (cfg.file) saveSessionFile(cfg.file, this as any, null);
     } catch (err) {
       // Surface via hook instead of swallowing silently.
-      try { (cfg as unknown as { onPersistError?: (e: unknown) => void }).onPersistError?.(err); } catch {}
+      try {
+        (cfg as unknown as { onPersistError?: (e: unknown) => void }).onPersistError?.(err);
+      } catch {}
     }
   }
 
   /** Merges completed worker metadata (incl. steps) into this agent's trace registry. */
-  private mergeSubagentTraces(subagents: Array<{ trackingId?: string; name: string; sessionId?: string; parentSessionId?: string; task: string; steps?: SubAgentTrace["steps"]; [k: string]: unknown }>): void {
+  private mergeSubagentTraces(
+    subagents: Array<{
+      trackingId?: string;
+      name: string;
+      sessionId?: string;
+      parentSessionId?: string;
+      task: string;
+      steps?: SubAgentTrace["steps"];
+      [k: string]: unknown;
+    }>
+  ): void {
     if (!subagents || subagents.length === 0) return;
     const rawOf = (id?: string): string | undefined => {
       if (!id) return undefined;
@@ -1639,15 +1813,19 @@ export class Agent {
     try {
       const g: any = globalThis as any;
       this.context.messages = Array.isArray(data.messages)
-        ? (typeof g.structuredClone === "function"
-            ? g.structuredClone(data.messages)
-            : JSON.parse(JSON.stringify(data.messages)))
+        ? typeof g.structuredClone === "function"
+          ? g.structuredClone(data.messages)
+          : JSON.parse(JSON.stringify(data.messages))
         : [];
     } catch {
       this.context.messages = Array.isArray(data.messages) ? [...data.messages] : [];
     }
     this.context.thoughtSignatures = [];
-    this.runMarks.splice(0, this.runMarks.length, ...(data.runs ?? []).filter((r) => r.i < this.context.messages.length));
+    this.runMarks.splice(
+      0,
+      this.runMarks.length,
+      ...(data.runs ?? []).filter((r) => r.i < this.context.messages.length)
+    );
     this.restoreUsage(data.usage);
     if (data.systemPrompt) {
       this.context.systemPrompt = data.systemPrompt;
@@ -1656,10 +1834,18 @@ export class Agent {
     }
     // Importing a snapshot invalidates prior provider chaining/routing
     // for both the previous and the restored session.
-    try { clearInteractionChains(prevSid); } catch {}
-    try { clearSessionRouting(prevSid); } catch {}
-    try { clearInteractionChains(this.sessionId); } catch {}
-    try { clearSessionRouting(this.sessionId); } catch {}
+    try {
+      clearInteractionChains(prevSid);
+    } catch {}
+    try {
+      clearSessionRouting(prevSid);
+    } catch {}
+    try {
+      clearInteractionChains(this.sessionId);
+    } catch {}
+    try {
+      clearSessionRouting(this.sessionId);
+    } catch {}
   }
 
   /**
@@ -1689,11 +1875,15 @@ export class Agent {
   }
 
   // Adds the user prompt to the target context (fresh context when stateless, stable system prompt, additionalContext as a user prefix) and marks the run start for the default session; in: a run start, out: the new SessionRunMark.
-  private prepareTurn(prompt: string | ContentPart[], options?: AgentRunOptions, target?: AgentContext): SessionRunMark | undefined {
+  private prepareTurn(
+    prompt: string | ContentPart[],
+    options?: AgentRunOptions,
+    target?: AgentContext
+  ): SessionRunMark | undefined {
     // Prompt validation throws synchronously in both run() and
     // stream() (same timing; documented here).
     if (Array.isArray(prompt) && prompt.length === 0) {
-      throw new Error(
+      throw new ValidationError(
         "[Agent Accelerator] Prompt cannot be empty: pass a non-empty string or at least one content part."
       );
     }
@@ -1748,23 +1938,14 @@ export class Agent {
   run(
     prompt: string | ContentPart[],
     options: AgentRunOptions & { stream: true } & (
-      | { onDelta: NonNullable<AgentRunOptions["onDelta"]> }
-      | { onThinkingDelta: NonNullable<AgentRunOptions["onThinkingDelta"]> }
-      | { onEvent: NonNullable<AgentRunOptions["onEvent"]> }
-    )
+        | { onDelta: NonNullable<AgentRunOptions["onDelta"]> }
+        | { onThinkingDelta: NonNullable<AgentRunOptions["onThinkingDelta"]> }
+        | { onEvent: NonNullable<AgentRunOptions["onEvent"]> }
+      )
   ): Promise<AgentResponse> & AsyncIterable<StreamEvent>;
-  run(
-    prompt: string | ContentPart[],
-    options: AgentRunOptions & { stream: true }
-  ): AssistantMessageEventStream;
-  run(
-    prompt: string | ContentPart[],
-    options?: AgentRunOptions
-  ): Promise<AgentResponse>;
-  run(
-    prompt: string | ContentPart[],
-    options?: AgentRunOptions
-  ): Promise<AgentResponse> | AssistantMessageEventStream {
+  run(prompt: string | ContentPart[], options: AgentRunOptions & { stream: true }): AssistantMessageEventStream;
+  run(prompt: string | ContentPart[], options?: AgentRunOptions): Promise<AgentResponse>;
+  run(prompt: string | ContentPart[], options?: AgentRunOptions): Promise<AgentResponse> | AssistantMessageEventStream {
     // Prompt validation throws synchronously in both run() and
     // stream() (same timing; async work starts only after validation).
     this.assertPromptValid(prompt);
@@ -1793,12 +1974,14 @@ export class Agent {
     // Mid-session: busy agent serializes via steer (same turn) or queue (next turn), or stops the active run and starts this prompt (interrupt).
     if (this.currentRun) {
       if (options?.enqueue === "interrupt") {
-        return new Promise<AgentResponse>((resolve, reject) => this.queueUrgent({ prompt, options, isStream: false, resolve, reject }));
+        return new Promise<AgentResponse>((resolve, reject) =>
+          this.queueUrgent({ prompt, options, isStream: false, resolve, reject })
+        );
       }
       const enforced = this.midSessionConfig.mode;
       const requested = options?.enqueue;
       if (requested && (enforced === "steer" || enforced === "queue") && requested !== enforced) {
-        throw new Error(
+        throw new ConfigError(
           `[Agent Accelerator] enqueue "${requested}" is disabled by midSession.mode "${enforced}". Use ${enforced}() or set mode to "auto"/"${requested}".`
         );
       }
@@ -1808,14 +1991,14 @@ export class Agent {
         return this.steerInto(this.currentRun, prompt, options);
       } else {
         if (this.midSessionConfig.mode === "steer") {
-          throw new Error(
+          throw new ConfigError(
             '[Agent Accelerator] enqueue "queue" is disabled by midSession.mode "steer". Use steer() or set mode to "auto"/"queue".'
           );
         }
         this.assertPromptValid(prompt);
         const max = this.midSessionConfig.maxQueued ?? 20;
         if (this.pendingQueue.length >= max) {
-          throw new Error(
+          throw new ValidationError(
             `[Agent Accelerator] Queue is full (${this.pendingQueue.length}/${max}). Wait for the active run to finish or increase midSession.maxQueued.`
           );
         }
@@ -1844,13 +2027,9 @@ export class Agent {
     prompt: string | ContentPart[],
     optionsOrStream?: boolean | AgentRunOptions
   ): Promise<AgentResponse> & AsyncIterable<string | StreamEvent> {
-    const isStream =
-      typeof optionsOrStream === "boolean"
-        ? optionsOrStream
-        : optionsOrStream?.stream === true;
+    const isStream = typeof optionsOrStream === "boolean" ? optionsOrStream : optionsOrStream?.stream === true;
 
-    const runOpts: AgentRunOptions =
-      typeof optionsOrStream === "object" ? optionsOrStream : { stream: isStream };
+    const runOpts: AgentRunOptions = typeof optionsOrStream === "object" ? optionsOrStream : { stream: isStream };
 
     if (isStream) {
       const stream = this.stream(prompt, runOpts);
@@ -1858,7 +2037,8 @@ export class Agent {
       if (runOpts.onDelta || runOpts.onThinkingDelta || runOpts.onEvent) {
         if (runOpts.onEvent) stream.on("*", runOpts.onEvent as any);
         if (runOpts.onDelta) stream.on("text_delta", (e: any) => runOpts.onDelta!(e.delta!, e));
-        if (runOpts.onThinkingDelta) stream.on("thinking_delta", (e: any) => runOpts.onThinkingDelta!(e.thinkingDelta!, e));
+        if (runOpts.onThinkingDelta)
+          stream.on("thinking_delta", (e: any) => runOpts.onThinkingDelta!(e.thinkingDelta!, e));
       }
       const stringStream: any = {
         [Symbol.asyncIterator]: async function* () {
@@ -1899,10 +2079,7 @@ export class Agent {
    * }
    * ```
    */
-  stream(
-    prompt: string | ContentPart[],
-    options?: AgentRunOptions
-  ): AssistantMessageEventStream {
+  stream(prompt: string | ContentPart[], options?: AgentRunOptions): AssistantMessageEventStream {
     // Same sync validation timing as run().
     this.assertPromptValid(prompt);
     // Mid-session: busy agent serializes via steer (same turn) or queue (next turn).
@@ -1910,8 +2087,12 @@ export class Agent {
       const enforcedStream = this.midSessionConfig.mode;
       const urgent = options?.enqueue === "interrupt"; // stops the active run and goes first, in every mode and whatever the queue holds
       const requestedStream = options?.enqueue === "interrupt" ? undefined : options?.enqueue;
-      if (requestedStream && (enforcedStream === "steer" || enforcedStream === "queue") && requestedStream !== enforcedStream) {
-        throw new Error(
+      if (
+        requestedStream &&
+        (enforcedStream === "steer" || enforcedStream === "queue") &&
+        requestedStream !== enforcedStream
+      ) {
+        throw new ConfigError(
           `[Agent Accelerator] enqueue "${requestedStream}" is disabled by midSession.mode "${enforcedStream}". Use ${enforcedStream}() or set mode to "auto"/"${requestedStream}".`
         );
       }
@@ -1935,28 +2116,40 @@ export class Agent {
           activePromise.then(
             (res) => {
               try {
-                stub.push({ type: "done", delta: "", usage: res.usage, finishReason: res.finishReason, responseId: res.responseId } as any);
+                stub.push({
+                  type: "done",
+                  delta: "",
+                  usage: res.usage,
+                  finishReason: res.finishReason,
+                  responseId: res.responseId,
+                } as any);
+              } catch {}
+              try {
+                stub.end(res);
               } catch {}
-              try { stub.end(res); } catch {}
             },
             (err) => {
-              try { stub.fail(err instanceof Error ? err : new Error(String(err))); } catch {}
+              try {
+                stub.fail(err instanceof Error ? err : new Error(String(err)));
+              } catch {}
             }
           );
         } else {
-          try { stub.fail(new Error("[Agent Accelerator] No active run to steer.")); } catch {}
+          try {
+            stub.fail(new ValidationError("[Agent Accelerator] No active run to steer."));
+          } catch {}
         }
         return stub;
       }
       if (!urgent && this.midSessionConfig.mode === "steer") {
-        throw new Error(
+        throw new ConfigError(
           '[Agent Accelerator] enqueue "queue" is disabled by midSession.mode "steer". Use steer() or set mode to "auto"/"queue".'
         );
       }
       this.assertPromptValid(prompt);
       const max = this.midSessionConfig.maxQueued ?? 20;
       if (!urgent && this.pendingQueue.length >= max) {
-        throw new Error(
+        throw new ValidationError(
           `[Agent Accelerator] Queue is full (${this.pendingQueue.length}/${max}). Wait for the active run to finish or increase midSession.maxQueued.`
         );
       }
@@ -2003,7 +2196,9 @@ export class Agent {
           if (idx >= 0) {
             this.pendingQueue.splice(idx, 1);
             queuedEntry.reject(Object.assign(new Error("Stream aborted"), { name: "AbortError" }));
-            try { deferred.fail(Object.assign(new Error("Stream aborted"), { name: "AbortError" })); } catch {}
+            try {
+              deferred.fail(Object.assign(new Error("Stream aborted"), { name: "AbortError" }));
+            } catch {}
           }
         } catch {}
       });
@@ -2021,7 +2216,13 @@ export class Agent {
           // Otherwise (edge), end it here.
           try {
             if ((deferred as any).__piped !== true) {
-              deferred.push({ type: "done", delta: "", usage: res.usage, finishReason: res.finishReason, responseId: res.responseId } as any);
+              deferred.push({
+                type: "done",
+                delta: "",
+                usage: res.usage,
+                finishReason: res.finishReason,
+                responseId: res.responseId,
+              } as any);
               deferred.end(res);
             }
           } catch {}
@@ -2043,10 +2244,7 @@ export class Agent {
   }
 
   // Attaches onEvent/onDelta/onThinkingDelta to a stream and, with wrapThinking, adds display-only <think> tags and whitespace hygiene on the outer events; in: stream()/pumpQueue, out: listeners on the stream.
-  private wireStreamCallbacks(
-    s: AssistantMessageEventStream,
-    options?: AgentRunOptions
-  ): void {
+  private wireStreamCallbacks(s: AssistantMessageEventStream, options?: AgentRunOptions): void {
     // Wire one-liner callbacks so `stream:true` + onDelta is enough — no manual for-await needed
     if (options?.wrapThinking) {
       // Auto-wrap reasoning as <think>…</think> per-turn — clean boundaries across multi-turn agent runs.
@@ -2123,7 +2321,9 @@ export class Agent {
         const raw: string = e.delta ?? "";
         if (!justClosedThink) return raw;
         const stripped = raw.replace(/^\n+/, "");
-        try { e.delta = stripped; } catch {}
+        try {
+          e.delta = stripped;
+        } catch {}
         if (!stripped) return "";
         justClosedThink = false;
         return stripped;
@@ -2220,11 +2420,13 @@ export class Agent {
           closeSynthetic();
           if (justClosedThink) {
             const stripped: string = (e.delta ?? "").replace(/^\n+/, "");
-            try { e.delta = stripped; } catch {}
+            try {
+              e.delta = stripped;
+            } catch {}
             if (!stripped) return;
             justClosedThink = false;
           }
-          needThinkNewline = !((e.delta ?? "").endsWith("\n"));
+          needThinkNewline = !(e.delta ?? "").endsWith("\n");
         });
         s.on("tool_call_start" as any, () => {
           closeSynthetic();
@@ -2254,7 +2456,7 @@ export class Agent {
 /** What a failed run attempt got done before it failed (the `partial` the loop attaches to its error). */
 type FailedAttempt = Partial<AgentResponse> & { usage: TokenUsage };
 
-// Adds what failed attempts already did (tool calls, results, turns, token usage) to the response of the attempt that finally worked, so a retry never hides side effects or cost; in: the final response + each failed attempt's `err.partial`, out: the run's AgentResponse.
+// Adds what failed attempts already did (tool calls, results, workers, turns, token usage) to the response of the attempt that finally worked, so a retry never hides side effects or cost; in: the final response + each failed attempt's `err.partial`, out: the run's AgentResponse.
 function withFailedAttempts(res: AgentResponse, failed: FailedAttempt[]): AgentResponse {
   const usage: TokenUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
   for (const f of failed) accumulateUsage(usage, f.usage);
@@ -2266,7 +2468,7 @@ function withFailedAttempts(res: AgentResponse, failed: FailedAttempt[]): AgentR
     thoughtSignature: res.thoughtSignature,
     toolCalls: [...failed.flatMap((f) => f.toolCalls ?? []), ...res.toolCalls],
     toolResults: [...failed.flatMap((f) => f.toolResults ?? []), ...res.toolResults],
-    subagents: res.subagents,
+    subagents: [...failed.flatMap((f) => f.subagents ?? []), ...res.subagents],
     usage,
     responseId: res.responseId,
     model: res.model,
@@ -2302,7 +2504,12 @@ export function normalizeThinking(config: AgentConfig, fallbackLevel?: string):
     try {
       const rawModel: any = (config.model as any)?.model ? (config.model as any).model : config.model;
       const modelStr = typeof rawModel === "string" ? rawModel : rawModel?.id || "";
-      const provStr = typeof rawModel === "object" && rawModel?.provider ? rawModel.provider : modelStr.includes("/") ? modelStr.split("/")[0] : "";
+      const provStr =
+        typeof rawModel === "object" && rawModel?.provider
+          ? rawModel.provider
+          : modelStr.includes("/")
+            ? modelStr.split("/")[0]
+            : "";
       const actualModelId = modelStr.includes("/") ? modelStr.split("/").slice(1).join("/") : modelStr;
       if (actualModelId) {
         validateModelThinking(provStr || "openrouter", actualModelId, level);