@standardagents/builder 0.35.4 → 0.35.5

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-BIVhZqwM.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-BIVhZqwM.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

@@ -1824,6 +1824,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 +1853,9 @@ var init_LLMRequest = __esm({
               lastFailedLogId
             );
           } catch (fallbackError) {
+            if (fallbackError?._userStop) {
+              throw fallbackError;
+            }
             console.error(
               `Fallback model ${fallback.fallback_model_id} failed:`,
               fallbackError
@@ -1939,6 +1945,20 @@ 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) {
@@ -15586,6 +15606,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 +17427,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 +18105,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 +19508,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 +19533,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,