@standardagents/builder 0.35.4 → 0.36.2

package/dist/runtime.d.ts

@@ -1,5 +1,5 @@
-import { e as ThreadEnv, A as Agent, r as ThreadMetadata, t as ToolResult, M as Message, k as ClientToolRequest, l as ClientToolResponse, m as ClientStreamRequest, n as ClientStreamResponse, w as FileRecord, F as FlowState, y as FileStats, G as GrepResult, x as AttachmentRef, J as MessageContent, E as Env, q as ThreadInstance } from './index-DP9GxPHu.js';
-export { f as BuilderThreadEndpointHandler, C as CLIENT_STREAM_CHUNK_BYTES, o as ClientDuplex, p as ClientForwarding, B as Controller, a as ControllerContext, u as FlowResult, D as ImageContentPart, I as ImageMetadata, L as LLMResponse, H as MultimodalContent, R as RequestContext, S as StorageBackend, v as TelemetryEvent, z as TextContentPart, b as ThreadEndpointContext, T as ToolCall, g as callClient, h as callClientStream, c as createThreadEndpointHandler, j as decodeStreamChunk, d as defineController, i as encodeStreamChunk, s as supportsClientForwarding } from './index-DP9GxPHu.js';
+import { e as ThreadEnv, A as Agent, r as ThreadMetadata, t as ToolResult, M as Message, k as ClientToolRequest, l as ClientToolResponse, m as ClientStreamRequest, n as ClientStreamResponse, w as FileRecord, F as FlowState, y as FileStats, G as GrepResult, x as AttachmentRef, J as MessageContent, E as Env, q as ThreadInstance } from './index-DUIfQjBW.js';
+export { f as BuilderThreadEndpointHandler, C as CLIENT_STREAM_CHUNK_BYTES, o as ClientDuplex, p as ClientForwarding, B as Controller, a as ControllerContext, u as FlowResult, D as ImageContentPart, I as ImageMetadata, L as LLMResponse, H as MultimodalContent, R as RequestContext, S as StorageBackend, v as TelemetryEvent, z as TextContentPart, b as ThreadEndpointContext, T as ToolCall, g as callClient, h as callClientStream, c as createThreadEndpointHandler, j as decodeStreamChunk, d as defineController, i as encodeStreamChunk, s as supportsClientForwarding } from './index-DUIfQjBW.js';
 import { CodeExecutionOptions, CodeExecutionResult, SubagentRegistryEntry, InjectMessageInput, QueueMessageInput, CredentialGrant, SkillMetadata, SkillFileInput, ModelDefinition as ModelDefinition$1, ToolArgs, PromptTextPart, PromptEnvPart, VariableDefinition, SubpromptConfig as SubpromptConfig$1, PromptToolConfig as PromptToolConfig$1, SubagentToolConfig as SubagentToolConfig$1, ReasoningConfig, SideConfig as SideConfig$1, LLMProviderInterface, ContentPart, TextPart, ImagePart, FilePart, ThreadState, NamespaceContext, DefinitionLoader } from '@standardagents/spec';
 export { AgentType, DefinitionLoader, GlobalNamespaceContext, HookSignatures, ImageContent, ModelCapabilities, ModelProvider, NamespaceContext, PackageSignature, PackedExports, PackedMeta, PackedMetadata, PackedNamespaceContext, PromptInput, PromptTextPart, ProviderAssistantMessage, ProviderError, ProviderErrorCode, ProviderFactory, ProviderFactoryConfig, ProviderFinishReason, ProviderGeneratedImage, ProviderMessage, ProviderMessageContent, ModelCapabilities as ProviderModelCapabilities, ProviderReasoningDetail, ProviderRequest, ProviderResponse, ProviderStreamChunk, ProviderSystemMessage, ProviderTool, ProviderToolCallPart, ProviderToolMessage, ProviderToolResultContent, ProviderUsage, ProviderUserMessage, ReasoningConfig, StructuredPrompt, TextContent, Tool, ToolArgs, ToolArgsNode, ToolArgsRawShape, ToolContent, belongsToPackage, defineAgent, defineHook, defineModel, definePrompt, defineTool, isPacked, isVisibleInNamespace, mapReasoningLevel } from '@standardagents/spec';
 import { DurableObject, WorkerEntrypoint } from 'cloudflare:workers';
@@ -428,6 +428,26 @@ declare class DurableThread<Env extends ThreadEnv = ThreadEnv> extends DurableOb
      * Get the persisted resumable-subagent registry for this thread.
      */
     getChildrenRegistry(_threadId: string): Promise<SubagentRegistryEntry[]>;
+    /** In-memory throttle/reentrancy guards for the stale-child reconciler. */
+    private lastChildAuditAt;
+    private childAuditInFlight;
+    /**
+     * Lazily heal registry entries stranded at a "working" status. The normal
+     * settlement chain lives only in the parent's `waitUntil`; a parent
+     * eviction/deploy/kill during a child's run leaves the entry at `running`
+     * forever and clients render an eternal spinner. On registry reads, audit
+     * old unsettled entries against the child thread's ACTUAL state and settle
+     * them — conservatively (see subagent-reconcile.ts): resumable children
+     * are never deterministically terminated.
+     */
+    private reconcileStaleChildren;
+    /**
+     * Child-side registry settlement: called from the CHILD's own DO whenever
+     * a run ends, so the spinner clears even when the parent-held completion
+     * chain died with the parent. Only downgrades a live "working" status to
+     * idle — never clobbers terminated.
+     */
+    settleChildRegistryIdle(_threadId: string, reference: string): Promise<void>;
     private setChildrenRegistry;
     upsertChildRegistry(_threadId: string, entry: SubagentRegistryEntry): Promise<void>;
     updateChildRegistryStatus(_threadId: string, reference: string, status: string): Promise<void>;
@@ -565,6 +585,9 @@ declare class DurableThread<Env extends ThreadEnv = ThreadEnv> extends DurableOb
         attachments?: unknown[];
         terminal?: boolean;
     }>;
+    /** Best-effort: mark this child's entry idle in its parent's registry. */
+    private settleOwnRegistryEntry;
+    private executeBlockingImpl;
     /**
      * Send a new message to the thread (RPC method)
      * Enqueues the message processing to be handled by the alarm handler
@@ -785,6 +808,7 @@ declare class DurableThread<Env extends ThreadEnv = ThreadEnv> extends DurableOb
             parent_log_id: string | null;
             retry_of_log_id: string | null;
             error: string | null;
+            error_type: string | null;
             cost_total: number | null;
             input_tokens: number | null;
             cached_tokens: number | null;

package/dist/runtime.js

@@ -931,12 +931,23 @@ function resolvePlatformRouting(providerName, env) {
     baseUrl: `${origin}/v1/proxy/${encodeURIComponent(provider)}${basePath}`
   };
 }
+function platformProviderFactoryConfig(providerName, routing) {
+  const config = {
+    apiKey: routing.apiKey,
+    baseUrl: routing.baseUrl
+  };
+  if (providerName.toLowerCase() === "deepinfra") {
+    config.modelsUrl = `${routing.origin}/v1/proxy/deepinfra/models`;
+  }
+  return config;
+}
 var DEFAULT_PLATFORM_PROXY_ORIGIN, PROVIDER_BASE_PATHS;
 var init_platform_routing = __esm({
   "src/agents/providers/platform-routing.ts"() {
     DEFAULT_PLATFORM_PROXY_ORIGIN = "https://api.standardagents.ai";
     PROVIDER_BASE_PATHS = {
-      cloudflare: "/ai/v1"
+      cloudflare: "/ai/v1",
+      deepinfra: "/openai"
     };
   }
 });
@@ -1229,10 +1240,7 @@ var init_ProviderRegistry = __esm({
         }
         const routing = resolvePlatformRouting(providerName, env);
         if (routing) {
-          const config = {
-            apiKey: routing.apiKey,
-            baseUrl: routing.baseUrl
-          };
+          const config = platformProviderFactoryConfig(providerName, routing);
           registerPlatformProxyOrigin(routing.origin);
           const fingerprint = this.getProviderFingerprint(`platform:${providerName}`, modelDef, config);
           const cached = this.providerCache.get(modelName);
@@ -1268,6 +1276,7 @@ var init_ProviderRegistry = __esm({
           google: "GOOGLE_API_KEY",
           groq: "GROQ_API_KEY",
           novita: "NOVITA_API_KEY",
+          deepinfra: "DEEPINFRA_API_KEY",
           openai: "OPENAI_API_KEY",
           openrouter: "OPENROUTER_API_KEY",
           anthropic: "ANTHROPIC_API_KEY",
@@ -1705,7 +1714,9 @@ function buildRequestBody(context, modelDef) {
       messages: requestMessages,
       tools,
       toolChoice,
-      parallelToolCalls: supportsToolCalls ? context.parallel_tool_calls : void 0,
+      // null (prompt didn't set it) normalizes to undefined so providers omit
+      // the wire param entirely and their default applies (2026-08-04).
+      parallelToolCalls: supportsToolCalls ? context.parallel_tool_calls ?? void 0 : void 0,
       reasoning: context.reasoning ? {
         level: reasoningEffortToLevel(context.reasoning.effort),
         maxTokens: context.reasoning.max_tokens,
@@ -1824,6 +1835,9 @@ var init_LLMRequest = __esm({
         try {
           return await this.tryModel(context, state, context.model, startTime, void 0);
         } catch (primaryError) {
+          if (primaryError?._userStop) {
+            throw primaryError;
+          }
           console.error(`Primary model ${context.model} failed:`, primaryError);
           lastFailedLogId = primaryError?._lastLogId;
           state.emitTelemetry?.({
@@ -1850,6 +1864,9 @@ var init_LLMRequest = __esm({
               lastFailedLogId
             );
           } catch (fallbackError) {
+            if (fallbackError?._userStop) {
+              throw fallbackError;
+            }
             console.error(
               `Fallback model ${fallback.fallback_model_id} failed:`,
               fallbackError
@@ -1939,9 +1956,24 @@ var init_LLMRequest = __esm({
             this.fireAsyncMetadataFetch(response, state, logId);
             return { response, logId };
           } catch (error2) {
+            if (state.abortController?.signal?.aborted) {
+              await this.logError(
+                state,
+                new Error("Interrupted by user"),
+                "user_interrupted",
+                actualModelId,
+                startTime,
+                logId
+              );
+              const stopError = new Error("aborted");
+              stopError._lastLogId = logId;
+              stopError._userStop = true;
+              throw stopError;
+            }
             console.error(`Error calling ${actualModelId} (attempt ${attempts}):`, error2);
             await this.logError(state, error2, "api_error", actualModelId, startTime, logId);
-            if (attempts < MAX_RETRIES_PER_MODEL) {
+            const isStallTimeout = error2?.code === "timeout";
+            if (attempts < MAX_RETRIES_PER_MODEL && !isStallTimeout) {
               const base = BACKOFF_BASE * Math.pow(2, attempts - 1);
               const retryAfterMs = typeof error2?.retryAfter === "number" ? error2.retryAfter * 1e3 : 0;
               const backoffMs = Math.max(base, retryAfterMs);
@@ -3849,7 +3881,7 @@ __export(ToolExecutor_exports, {
 function getPackageId(state) {
   return state.namespaceContext.type === "packed" ? state.namespaceContext.packageId : void 0;
 }
-var SUBAGENT_CREATE_TOOL, SUBAGENT_MESSAGE_TOOL, LEGACY_SEND_TO_AGENT_TOOL, INTERNAL_SCOPED_ENV_ARGUMENT, INTERNAL_SCOPED_ENV_CONTEXT_KEY, ToolExecutor;
+var SUBAGENT_CREATE_TOOL, SUBAGENT_MESSAGE_TOOL, SUBAGENTS_LIST_TOOL, LEGACY_SEND_TO_AGENT_TOOL, INTERNAL_SCOPED_ENV_ARGUMENT, INTERNAL_SCOPED_ENV_CONTEXT_KEY, ToolExecutor;
 var init_ToolExecutor = __esm({
   "src/agents/ToolExecutor.ts"() {
     init_types();
@@ -3857,6 +3889,7 @@ var init_ToolExecutor = __esm({
     init_sessionTools();
     SUBAGENT_CREATE_TOOL = "subagent_create";
     SUBAGENT_MESSAGE_TOOL = "subagent_message";
+    SUBAGENTS_LIST_TOOL = "subagents";
     LEGACY_SEND_TO_AGENT_TOOL = "send_to_agent";
     INTERNAL_SCOPED_ENV_ARGUMENT = "__scoped_env";
     INTERNAL_SCOPED_ENV_CONTEXT_KEY = "__immediate_scoped_env_by_call_id";
@@ -4015,6 +4048,33 @@ var init_ToolExecutor = __esm({
        * Execute a single tool call
        */
       static async executeToolCall(call, state, toolMessageId) {
+        try {
+          const n = call.function?.name;
+          if (n && n.includes("_") && n !== "mcp") {
+            const cat2 = await state.thread.instance.getValue("mcp_catalog");
+            for (const srv of cat2?.servers ?? []) {
+              const sname = srv.name ?? srv.serverInfo?.name;
+              if (!sname || !n.startsWith(`${sname}_`)) continue;
+              const mtool = n.slice(sname.length + 1);
+              if (!Array.isArray(srv.tools) || !srv.tools.some((t) => t.name === mtool)) continue;
+              call = {
+                ...call,
+                function: {
+                  ...call.function,
+                  name: "mcp",
+                  arguments: JSON.stringify({
+                    action: "call",
+                    server: sname,
+                    tool: mtool,
+                    arguments_json: call.function.arguments || "{}"
+                  })
+                }
+              };
+              break;
+            }
+          }
+        } catch {
+        }
         const toolType = await this.identifyToolType(call, state);
         switch (toolType) {
           case "native":
@@ -4064,7 +4124,7 @@ var init_ToolExecutor = __esm({
        */
       static async identifyToolType(call, state) {
         const toolName = call.function.name;
-        if (toolName === SUBAGENT_CREATE_TOOL || toolName === SUBAGENT_MESSAGE_TOOL || toolName === LEGACY_SEND_TO_AGENT_TOOL) {
+        if (toolName === SUBAGENT_CREATE_TOOL || toolName === SUBAGENT_MESSAGE_TOOL || toolName === SUBAGENTS_LIST_TOOL || toolName === LEGACY_SEND_TO_AGENT_TOOL) {
           return "agent";
         }
         if (state.allowedTools) {
@@ -4597,6 +4657,22 @@ ${errorLines.join("\n")}`);
           if (builtinSubagentAction === "message") {
             return await this.executeSubagentMessageTool(call, state);
           }
+          if (call.function.name === SUBAGENTS_LIST_TOOL) {
+            const { FlowEngine: FlowEngine2 } = await Promise.resolve().then(() => (init_FlowEngine(), FlowEngine_exports));
+            const registry = await FlowEngine2.listModelVisibleSubagents(state);
+            if (registry.length === 0) {
+              return { status: "success", result: "No active subagent instances." };
+            }
+            const lines = registry.map(
+              (entry) => `- ${entry.reference}: ${entry.name} \u2014 ${entry.status ?? "unknown"}${entry.description ? ` (${entry.description})` : ""}`
+            );
+            return {
+              status: "success",
+              result: `Active subagent instances:
+${lines.join("\n")}
+Message one with subagent_message(referenceId, message).`
+            };
+          }
           const createArgs = builtinSubagentAction === "create" ? this.parseSubagentCreateArgs(call.function.arguments) : null;
           if (createArgs?.error) {
             return { status: "error", error: createArgs.error };
@@ -6919,7 +6995,10 @@ This usually points to something I can't fix from here \u2014 for example the wo
           model: def.model,
           include_chat: def.includeChat ?? false,
           include_past_tools: def.includePastTools ?? false,
-          parallel_tool_calls: def.parallelToolCalls ?? false,
+          // Unset stays unset (2026-08-04): defaulting to `false` forbade the
+          // parallel batching agentic-tuned models are trained on; absent lets
+          // the provider default apply, while an explicit prompt value is honored.
+          parallel_tool_calls: def.parallelToolCalls ?? null,
           tool_choice: def.toolChoice ?? "auto",
           reasoning_effort: def.reasoning?.effort ?? null,
           reasoning_max_tokens: def.reasoning?.maxTokens ?? null,
@@ -8201,6 +8280,13 @@ This usually points to something I can't fix from here \u2014 for example the wo
         if (hidden.size === 0) return registry;
         return registry.filter((entry) => !hidden.has(entry.name));
       }
+      /** Public snapshot for the `subagents` built-in tool (ToolExecutor). */
+      static async listModelVisibleSubagents(state) {
+        return _FlowEngine.filterModelVisibleSubagents(
+          await this.getSubagentRegistry(state),
+          state.prompt?._tools
+        );
+      }
       static async getSubagentRegistry(state) {
         if (typeof state.thread.instance.getChildrenRegistry === "function") {
           try {
@@ -8470,7 +8556,8 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
           await this.getSubagentRegistry(state),
           state.prompt?._tools
         );
-        if (subagentRegistry.length > 0) {
+        const suppressRegistryMessage = Array.isArray(state.prompt?.hooks) ? state.prompt.hooks.includes("append_static_session_env") : false;
+        if (subagentRegistry.length > 0 && !suppressRegistryMessage) {
           const fallbackNameMap = await this.resolveRegistryThreadNameMap(state, subagentRegistry);
           const lines = subagentRegistry.map((entry) => {
             const threadName = this.getRegistryThreadName(entry) ?? fallbackNameMap.get(entry.reference) ?? null;
@@ -8829,6 +8916,16 @@ ${lines.join("\n\n")}`
           }
           if (resumablePromptSubagents.length > 0 && !tools.some((tool) => tool.function.name === "subagent_create")) {
             tools.push(this.buildSubagentCreateTool(resumablePromptSubagents));
+            if (!tools.some((tool) => tool.function.name === "subagents")) {
+              tools.push({
+                type: "function",
+                function: {
+                  name: "subagents",
+                  description: "List your active subagent instances: reference id, name, status, and working-status text. Use when you need to check on children you created; completions also arrive as messages.",
+                  parameters: { type: "object", properties: {} }
+                }
+              });
+            }
           }
           const hasActiveResumable = childrenRegistry.some(
             (entry) => entry.status !== "terminated"
@@ -8863,6 +8960,73 @@ ${lines.join("\n\n")}`
               }
             });
           }
+          try {
+            const cat2 = await state.thread.instance.getValue("mcp_catalog");
+            const servers = cat2?.servers ?? [];
+            const have = new Set(tools.map((t) => t.function?.name));
+            const sanitizeProperty = (p) => {
+              const prop = p ?? {};
+              const t = prop.type;
+              if (t === "string" || t === "number" || t === "integer" || t === "boolean") {
+                const out = { type: t };
+                if (typeof prop.description === "string") out.description = prop.description;
+                if (Array.isArray(prop.enum)) out.enum = prop.enum;
+                return out;
+              }
+              if (t === "array") {
+                return {
+                  type: "array",
+                  items: sanitizeProperty(prop.items),
+                  ...typeof prop.description === "string" ? { description: prop.description } : {}
+                };
+              }
+              if (t === "object") {
+                const props = prop.properties ?? {};
+                const out = {};
+                for (const [k, v] of Object.entries(props)) out[k] = sanitizeProperty(v);
+                return {
+                  type: "object",
+                  properties: out,
+                  ...Array.isArray(prop.required) ? { required: prop.required.filter((r) => typeof r === "string" && r in out) } : {},
+                  ...typeof prop.description === "string" ? { description: prop.description } : {}
+                };
+              }
+              return {
+                type: "string",
+                ...typeof prop.description === "string" ? { description: prop.description } : {}
+              };
+            };
+            const sanitizeSchema = (schema) => {
+              const s = schema ?? { type: "object", properties: {} };
+              if (s.type !== void 0 && s.type !== "object") return null;
+              const sanitized = sanitizeProperty({ ...s, type: "object" });
+              return sanitized;
+            };
+            for (const srv of servers) {
+              const sname = srv.name ?? srv.serverInfo?.name;
+              if (!sname || srv.error || !Array.isArray(srv.tools)) continue;
+              for (const mt of srv.tools) {
+                const pname = `${sname}_${mt.name}`;
+                if (have.has(pname)) continue;
+                const parameters = sanitizeSchema(mt.inputSchema);
+                if (!parameters) {
+                  console.log(`[FlowEngine] mcp projection: skipped ${pname} (non-object schema)`);
+                  continue;
+                }
+                tools.push({
+                  type: "function",
+                  function: {
+                    name: pname,
+                    description: mt.description || `${mt.name} via the ${sname} MCP server`,
+                    parameters
+                  }
+                });
+                have.add(pname);
+              }
+            }
+            console.log(`[FlowEngine] mcp projection: ${tools.length} tools after catalog merge`);
+          } catch {
+          }
           console.log(`[FlowEngine] getToolsForPrompt result: ${tools.length} tools loaded for prompt ${promptData.name}`);
           return tools;
         } catch (error) {
@@ -15586,6 +15750,25 @@ var migration34 = {
 var migrations = [migration, migration2, migration3, migration4, migration5, migration6, migration7, migration8, migration9, migration10, migration11, migration12, migration13, migration14, migration15, migration16, migration17, migration18, migration19, migration20, migration21, migration22, migration23, migration24, migration25, migration26, migration27, migration28, migration29, migration30, migration31, migration32, migration33, migration34];
 var LATEST_SCHEMA_VERSION = migrations.length;
 
+// src/durable-objects/subagent-reconcile.ts
+var CHILD_STALE_AFTER_MS = 5 * 6e4;
+var CHILD_AUDIT_MIN_INTERVAL_MS = 6e4;
+var CHILD_AUDIT_MAX_PER_SWEEP = 4;
+var SETTLED_STATUSES = /* @__PURE__ */ new Set(["idle", "terminated"]);
+function isAuditCandidate(entry, nowMs) {
+  if (SETTLED_STATUSES.has(entry.status)) return false;
+  const createdMs = (entry.createdAt ?? 0) / 1e3;
+  return nowMs - createdMs >= CHILD_STALE_AFTER_MS;
+}
+function resolveStaleChildStatus(entry, child, nowMs) {
+  if (SETTLED_STATUSES.has(entry.status)) return null;
+  if (!child) return "terminated";
+  if (child.terminated) return "terminated";
+  if (child.executing) return null;
+  if (nowMs - child.lastActivityMs < CHILD_STALE_AFTER_MS) return null;
+  return entry.resumable ? "idle" : "terminated";
+}
+
 // src/durable-objects/DurableThread.ts
 init_types();
 
@@ -17388,12 +17571,103 @@ var DurableThread = class _DurableThread extends DurableObject {
     );
     const rows = cursor.toArray();
     const raw = rows[0]?.value ?? "[]";
+    let entries;
     try {
       const parsed = JSON.parse(raw);
-      return Array.isArray(parsed) ? parsed : [];
+      entries = Array.isArray(parsed) ? parsed : [];
     } catch {
       return [];
     }
+    return this.reconcileStaleChildren(entries);
+  }
+  /** In-memory throttle/reentrancy guards for the stale-child reconciler. */
+  lastChildAuditAt = 0;
+  childAuditInFlight = false;
+  /**
+   * Lazily heal registry entries stranded at a "working" status. The normal
+   * settlement chain lives only in the parent's `waitUntil`; a parent
+   * eviction/deploy/kill during a child's run leaves the entry at `running`
+   * forever and clients render an eternal spinner. On registry reads, audit
+   * old unsettled entries against the child thread's ACTUAL state and settle
+   * them — conservatively (see subagent-reconcile.ts): resumable children
+   * are never deterministically terminated.
+   */
+  async reconcileStaleChildren(entries) {
+    const nowMs = Date.now();
+    if (this.childAuditInFlight) return entries;
+    if (nowMs - this.lastChildAuditAt < CHILD_AUDIT_MIN_INTERVAL_MS) return entries;
+    const candidates = entries.filter((entry) => isAuditCandidate(entry, nowMs));
+    if (candidates.length === 0) return entries;
+    this.childAuditInFlight = true;
+    this.lastChildAuditAt = nowMs;
+    try {
+      const agentBuilderId = this.env.AGENT_BUILDER.idFromName("singleton");
+      const agentBuilder = this.env.AGENT_BUILDER.get(agentBuilderId);
+      const changed = [];
+      for (const entry of candidates.slice(0, CHILD_AUDIT_MAX_PER_SWEEP)) {
+        let facts = null;
+        try {
+          const child = await agentBuilder.getThread(entry.reference);
+          facts = child ? {
+            terminated: child.terminated ?? null,
+            executing: child.executing === true,
+            lastActivityMs: Number(child.last_activity_at ?? child.created_at ?? 0) * 1e3
+          } : null;
+        } catch {
+          continue;
+        }
+        const resolution = resolveStaleChildStatus(entry, facts, nowMs);
+        if (resolution) {
+          changed.push({
+            reference: entry.reference,
+            status: resolution,
+            // Settling a live one-shot child to terminated also terminates
+            // the thread itself so registry and reality agree.
+            terminateChild: resolution === "terminated" && facts !== null && !facts.terminated
+          });
+        }
+      }
+      if (changed.length === 0) return entries;
+      const byRef = new Map(changed.map((c) => [c.reference, c]));
+      const healed = entries.map(
+        (entry) => byRef.has(entry.reference) ? { ...entry, status: byRef.get(entry.reference).status } : entry
+      );
+      await this.setChildrenRegistry(healed);
+      for (const c of changed) {
+        if (c.terminateChild) {
+          try {
+            const childId = this.env.AGENT_BUILDER_THREAD.idFromName(c.reference);
+            const childStub = this.env.AGENT_BUILDER_THREAD.get(childId);
+            await childStub.terminateThread?.(c.reference);
+          } catch (error) {
+            console.error("[DurableThread] Stale-child terminate failed (non-fatal):", error);
+          }
+        }
+        await this.broadcastChildStatusChanged(c.reference);
+      }
+      console.log(
+        `[DurableThread] Reconciled ${changed.length} stale subagent entr${changed.length === 1 ? "y" : "ies"}:`,
+        changed.map((c) => `${c.reference.slice(0, 8)}\u2192${c.status}`).join(", ")
+      );
+      return healed;
+    } finally {
+      this.childAuditInFlight = false;
+    }
+  }
+  /**
+   * Child-side registry settlement: called from the CHILD's own DO whenever
+   * a run ends, so the spinner clears even when the parent-held completion
+   * chain died with the parent. Only downgrades a live "working" status to
+   * idle — never clobbers terminated.
+   */
+  async settleChildRegistryIdle(_threadId, reference) {
+    const entries = await this.getChildrenRegistry("");
+    const entry = entries.find((e) => e.reference === reference);
+    if (!entry || entry.status === "terminated" || entry.status === "idle") return;
+    await this.setChildrenRegistry(
+      entries.map((e) => e.reference === reference ? { ...e, status: "idle" } : e)
+    );
+    await this.broadcastChildStatusChanged(reference);
   }
   async setChildrenRegistry(entries) {
     await this.ctx.storage.sql.exec(
@@ -17975,6 +18249,33 @@ var DurableThread = class _DurableThread extends DurableObject {
    * Used by blocking subagent tool calls.
    */
   async executeBlocking(threadId, agentId, initial_messages, data) {
+    try {
+      return await this.executeBlockingImpl(threadId, agentId, initial_messages, data);
+    } finally {
+      this.ctx.waitUntil?.(this.settleOwnRegistryEntry(threadId));
+    }
+  }
+  /** Best-effort: mark this child's entry idle in its parent's registry. */
+  async settleOwnRegistryEntry(threadId) {
+    try {
+      const terminatedCursor = await this.ctx.storage.sql.exec(
+        `SELECT value FROM execution_state WHERE key = 'terminated' LIMIT 1`
+      );
+      const terminated = terminatedCursor.toArray()[0]?.value;
+      if (terminated && terminated !== "" && terminated !== "null") return;
+      const agentBuilderId = this.env.AGENT_BUILDER.idFromName("singleton");
+      const agentBuilder = this.env.AGENT_BUILDER.get(agentBuilderId);
+      const meta = await agentBuilder.getThread(threadId);
+      const parent = meta?.parent;
+      if (!parent) return;
+      const parentId = this.env.AGENT_BUILDER_THREAD.idFromName(parent);
+      const parentStub = this.env.AGENT_BUILDER_THREAD.get(parentId);
+      await parentStub.settleChildRegistryIdle?.(parent, threadId);
+    } catch (error) {
+      console.error("[DurableThread] Child-side registry settlement failed (non-fatal):", error);
+    }
+  }
+  async executeBlockingImpl(threadId, agentId, initial_messages, data) {
     await this.ensureMigrated();
     await this.assertNotTerminated();
     let parentThreadId = null;
@@ -19351,7 +19652,7 @@ ${resultContent}${attachmentSummary}`;
         `
         SELECT
           id, message_id, provider, actual_provider, standard_agents_router_used, model, model_name, prompt_name,
-          tools_called, queued_tools, provider_tools, parent_log_id, retry_of_log_id, error, cost_total,
+          tools_called, queued_tools, provider_tools, parent_log_id, retry_of_log_id, error, error_type, cost_total,
           input_tokens, cached_tokens, output_tokens, total_tokens,
           is_complete, created_at
         FROM logs
@@ -19376,6 +19677,7 @@ ${resultContent}${attachmentSummary}`;
         parent_log_id: row.parent_log_id,
         retry_of_log_id: row.retry_of_log_id,
         error: row.error,
+        error_type: row.error_type,
         cost_total: row.cost_total,
         input_tokens: row.input_tokens,
         cached_tokens: row.cached_tokens,