@standardagents/builder 0.25.6 → 0.26.0

package/dist/built-in-routes.js

@@ -1082,6 +1082,37 @@ function resolveStreamTimeoutMs(env2, key, fallback) {
   const parsed = typeof raw === "number" ? raw : typeof raw === "string" ? Number.parseInt(raw, 10) : NaN;
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
+function resolveWatchdogStaleCeilingMs(env2) {
+  const firstChunk = resolveStreamTimeoutMs(
+    env2,
+    "STANDARD_AGENTS_STREAM_FIRST_CHUNK_TIMEOUT_MS",
+    STREAM_FIRST_CHUNK_TIMEOUT_MS
+  );
+  const stall = resolveStreamTimeoutMs(
+    env2,
+    "STANDARD_AGENTS_STREAM_STALL_TIMEOUT_MS",
+    STREAM_STALL_TIMEOUT_MS
+  );
+  return Math.max(firstChunk, stall) + 6e4;
+}
+async function awaitBounded(work, budgetMs, label) {
+  let timer;
+  work.catch(() => {
+  });
+  const timeout = new Promise((resolve2) => {
+    timer = setTimeout(() => {
+      console.error(
+        `[LLMRequest] ${label} did not settle within ${budgetMs}ms \u2014 continuing without it`
+      );
+      resolve2(void 0);
+    }, budgetMs);
+  });
+  try {
+    return await Promise.race([work, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 function modelSupportsImageInput(modelDef) {
   const supportsImages = modelDef.capabilities?.supportsImages;
   if (typeof supportsImages === "boolean") {
@@ -1295,13 +1326,42 @@ function transformMessages(messages) {
           arguments: typeof tc.function.arguments === "string" ? JSON.parse(tc.function.arguments) : tc.function.arguments,
           extraContent: tc.extra_content && typeof tc.extra_content === "object" ? tc.extra_content : void 0
         }));
+        const storedDetails = msg.reasoning_details;
+        const reasoningDetails = Array.isArray(
+          storedDetails
+        ) ? storedDetails.flatMap((entry) => {
+          if (!entry || typeof entry !== "object") return [];
+          const raw = entry;
+          const type = raw.type === "summary" || raw.type === "encrypted" ? raw.type : "text";
+          return [
+            {
+              type,
+              id: typeof raw.id === "string" ? raw.id : void 0,
+              text: typeof raw.text === "string" ? raw.text : void 0,
+              data: typeof raw.data === "string" ? raw.data : void 0,
+              format: typeof raw.format === "string" ? raw.format : void 0
+            }
+          ];
+        }) : void 0;
+        const storedReasoning = msg.reasoning_content;
+        let reasoning = typeof storedReasoning === "string" && storedReasoning.length > 0 ? storedReasoning : void 0;
+        if (!reasoning && Array.isArray(reasoningDetails)) {
+          const seen = /* @__PURE__ */ new Set();
+          const texts = [];
+          for (const d of reasoningDetails) {
+            if (typeof d?.text === "string" && d.text.length > 0 && !seen.has(d.text)) {
+              seen.add(d.text);
+              texts.push(d.text);
+            }
+          }
+          if (texts.length) reasoning = texts.join("\n");
+        }
         return {
           role: "assistant",
           content: typeof msg.content === "string" ? msg.content : null,
           toolCalls: toolCalls?.length ? toolCalls : void 0,
-          // Pass reasoning for multi-turn context
-          reasoning: msg.reasoning_content || void 0,
-          reasoningDetails: msg.reasoning_details || void 0
+          reasoning,
+          reasoningDetails: reasoningDetails?.length ? reasoningDetails : void 0
         };
       }
       case "tool":
@@ -1476,7 +1536,7 @@ function normalizeProviderMetadataValue(value) {
   if (!trimmed || trimmed.toLowerCase() === "unknown") return void 0;
   return trimmed;
 }
-var NON_VISION_PLACEHOLDER_TEXT, STREAM_FIRST_CHUNK_TIMEOUT_MS, STREAM_STALL_TIMEOUT_MS, LLMRequest;
+var NON_VISION_PLACEHOLDER_TEXT, STREAM_FIRST_CHUNK_TIMEOUT_MS, STREAM_STALL_TIMEOUT_MS, HOOK_AWAIT_BUDGET_MS, STREAM_CLEANUP_BUDGET_MS, LLMRequest;
 var init_LLMRequest = __esm({
   "src/agents/LLMRequest.ts"() {
     init_pricing();
@@ -1487,6 +1547,8 @@ var init_LLMRequest = __esm({
     NON_VISION_PLACEHOLDER_TEXT = "[Image omitted: model does not support vision]";
     STREAM_FIRST_CHUNK_TIMEOUT_MS = 12e4;
     STREAM_STALL_TIMEOUT_MS = 45e3;
+    HOOK_AWAIT_BUDGET_MS = 3e4;
+    STREAM_CLEANUP_BUDGET_MS = 5e3;
     LLMRequest = class {
       /**
        * Execute an LLM request with full retry/fallback logic
@@ -1970,7 +2032,14 @@ var init_LLMRequest = __esm({
                 parentSignal.removeEventListener("abort", onParentAbort);
               }
               try {
-                await iterator.return?.();
+                const cleanup = iterator.return?.();
+                if (cleanup) {
+                  await awaitBounded(
+                    Promise.resolve(cleanup),
+                    STREAM_CLEANUP_BUDGET_MS,
+                    "stream iterator cleanup"
+                  );
+                }
               } catch {
               }
             }
@@ -2103,7 +2172,11 @@ var init_LLMRequest = __esm({
        */
       static async resolveProgressArgument(state, toolName) {
         try {
-          const mod = await state.thread.instance.loadTool(toolName);
+          const mod = await awaitBounded(
+            state.thread.instance.loadTool(toolName),
+            HOOK_AWAIT_BUDGET_MS,
+            `loadTool(${toolName}) for progress argument`
+          );
           const pa = mod?.progressArgument ?? mod?.default?.progressArgument;
           return typeof pa === "string" && pa ? pa : void 0;
         } catch {
@@ -2124,7 +2197,11 @@ var init_LLMRequest = __esm({
           function: { name: entry.name, arguments: entry.argumentsDelta || "" }
         };
         try {
-          await FlowEngine.runToolCallStartedHook(state, toolCall, progress);
+          await awaitBounded(
+            FlowEngine.runToolCallStartedHook(state, toolCall, progress),
+            HOOK_AWAIT_BUDGET_MS,
+            `tool_call_started hook for ${entry.name}`
+          );
         } catch (error) {
           console.error("[LLMRequest] Error firing tool_call_started:", error);
         }
@@ -7726,6 +7803,25 @@ This usually points to something I can't fix from here \u2014 for example the wo
           return null;
         }
       }
+      /**
+       * Registry entries the model may see (and therefore manage). Hidden
+       * subagent relationships (`SubagentToolConfig.hidden` — infrastructure
+       * children like background compaction) are excluded from the injected
+       * "Active subagent instances" message: a listed instance reads as the
+       * model's to clean up, and terminate_subagent on an infrastructure child
+       * kills work the runtime depends on. Static and pure for direct testing.
+       */
+      static filterModelVisibleSubagents(registry, promptTools) {
+        if (registry.length === 0) return registry;
+        const hidden = /* @__PURE__ */ new Set();
+        for (const config of promptTools ?? []) {
+          if (typeof config === "object" && config !== null && "name" in config && config.hidden === true) {
+            hidden.add(config.name);
+          }
+        }
+        if (hidden.size === 0) return registry;
+        return registry.filter((entry) => !hidden.has(entry.name));
+      }
       static async getSubagentRegistry(state) {
         if (typeof state.thread.instance.getChildrenRegistry === "function") {
           try {
@@ -7984,7 +8080,10 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
             });
           }
         }
-        const subagentRegistry = await this.getSubagentRegistry(state);
+        const subagentRegistry = _FlowEngine.filterModelVisibleSubagents(
+          await this.getSubagentRegistry(state),
+          state.prompt?._tools
+        );
         if (subagentRegistry.length > 0) {
           const fallbackNameMap = await this.resolveRegistryThreadNameMap(state, subagentRegistry);
           const lines = subagentRegistry.map((entry) => {
@@ -12301,8 +12400,12 @@ var init_ThreadStateImpl = __esm({
           options?.includeSilent,
           options?.maxDepth
         );
+        const messages = result.messages.map(this._mapMessage);
+        if (options?.order === "desc") {
+          messages.reverse();
+        }
         return {
-          messages: result.messages.map(this._mapMessage),
+          messages,
           total: result.total,
           hasMore: result.hasMore
         };
@@ -42141,14 +42244,19 @@ function transformAssistantMessage2(msg) {
       }
     }
     if (msg.reasoning && typeof msg.reasoning === "string") {
-      if (reasoningItemsById.size > 0) {
-        const firstItem = reasoningItemsById.values().next().value;
-        if (firstItem) {
-          firstItem.summary.unshift({ type: "summary_text", text: msg.reasoning });
+      const alreadyPresent = Array.from(reasoningItemsById.values()).some(
+        (item) => item.summary.some((s) => s.text === msg.reasoning)
+      );
+      if (!alreadyPresent) {
+        if (reasoningItemsById.size > 0) {
+          const firstItem = reasoningItemsById.values().next().value;
+          if (firstItem) {
+            firstItem.summary.unshift({ type: "summary_text", text: msg.reasoning });
+          }
+        } else {
+          const newItem = getOrCreateItem(defaultId);
+          newItem.summary = [{ type: "summary_text", text: msg.reasoning }];
         }
-      } else {
-        const newItem = getOrCreateItem(defaultId);
-        newItem.summary = [{ type: "summary_text", text: msg.reasoning }];
       }
     }
     for (const item of reasoningItemsById.values()) {
@@ -66015,7 +66123,11 @@ var config_get_default = defineController2(async ({ config, env: env2, req }) =>
   });
 });
 
+// src/version.ts
+var BUILDER_VERSION = "0.26.0".length > 0 ? "0.26.0" : "dev";
+
 // src/api/diagnostics.get.ts
+init_LLMRequest();
 function isFetcher(value) {
   return !!value && typeof value.fetch === "function";
 }
@@ -66104,8 +66216,30 @@ var diagnostics_get_default = defineController2(async ({ req, env: env2, tools,
       });
     }
   }
-  return Response.json({ warnings });
+  const runtime = {
+    builderVersion: BUILDER_VERSION,
+    streamFirstChunkTimeoutMs: resolveStreamTimeoutValue(
+      env2,
+      "STANDARD_AGENTS_STREAM_FIRST_CHUNK_TIMEOUT_MS",
+      12e4
+    ),
+    streamStallTimeoutMs: resolveStreamTimeoutValue(
+      env2,
+      "STANDARD_AGENTS_STREAM_STALL_TIMEOUT_MS",
+      45e3
+    ),
+    watchdogCeilingMs: resolveWatchdogStaleCeilingMs(env2),
+    watchdogCompanionAvailable: Boolean(
+      env2.AGENT_BUILDER_WATCHDOG
+    )
+  };
+  return Response.json({ warnings, runtime });
 });
+function resolveStreamTimeoutValue(env2, key, fallback) {
+  const raw = env2?.[key];
+  const parsed = typeof raw === "number" ? raw : typeof raw === "string" ? Number.parseInt(raw, 10) : NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
 
 // src/api/events.get.ts
 var events_get_default = defineController2(async ({ req, env: env2 }) => {
@@ -70707,6 +70841,61 @@ var cost_get_default = defineController2(async ({ req, params, env: env2 }) => {
   }
 });
 
+// src/api/threads/[id]/diagnostics.get.ts
+var diagnostics_get_default2 = defineController2(async ({ req, params, env: env2 }) => {
+  if (isPlatformHosted(env2)) {
+    const authResult = await requirePermission(req, env2, "logs");
+    if (authResult instanceof Response) {
+      return authResult;
+    }
+  } else {
+    const authContext = await authenticate(req, env2);
+    if (authContext && !hasPermission(authContext.user, "logs")) {
+      return Response.json(
+        { error: "Forbidden: 'logs' access required" },
+        { status: 403 }
+      );
+    }
+  }
+  const threadId = params.id;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  try {
+    const agentBuilderId = env2.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env2.AGENT_BUILDER.get(agentBuilderId);
+    const threadMeta = await agentBuilder.getThread(threadId);
+    if (!threadMeta) {
+      return Response.json({ error: "Thread not found" }, { status: 404 });
+    }
+    const threadStub = env2.AGENT_BUILDER_THREAD.get(
+      env2.AGENT_BUILDER_THREAD.idFromName(threadId)
+    );
+    const thread = await threadStub.getDiagnostics?.();
+    let watchdog = null;
+    const watchdogNamespace = env2.AGENT_BUILDER_WATCHDOG;
+    if (watchdogNamespace) {
+      try {
+        const companion = watchdogNamespace.get(watchdogNamespace.idFromName(threadId));
+        watchdog = await companion.getState();
+      } catch (error) {
+        console.error("[diagnostics] Failed to read watchdog companion state:", error);
+      }
+    }
+    return Response.json({
+      thread: thread ?? null,
+      watchdog,
+      terminated: threadMeta.terminated ?? null
+    });
+  } catch (error) {
+    console.error("Error fetching thread diagnostics:", error);
+    return Response.json(
+      { error: error instanceof Error ? error.message : "Failed to fetch diagnostics" },
+      { status: 500 }
+    );
+  }
+});
+
 // src/api/threads/[id]/effects.get.ts
 async function getAuthorizedThreadStub(req, env2, threadId) {
   const authResult = await requireAuth(req, env2);
@@ -71225,8 +71414,69 @@ var pending_tool_calls_get_default = defineController2(async ({ params, env: env
   }
 });
 
+// src/api/threads/[id]/revive.post.ts
+var revive_post_default = defineController2(async ({ req, params, env: env2 }) => {
+  if (isPlatformHosted(env2)) {
+    const authResult = await requirePermission(req, env2, "logs");
+    if (authResult instanceof Response) {
+      return authResult;
+    }
+  } else {
+    const authContext = await authenticate(req, env2);
+    if (authContext && !hasPermission(authContext.user, "logs")) {
+      return Response.json(
+        { error: "Forbidden: 'logs' access required" },
+        { status: 403 }
+      );
+    }
+  }
+  const threadId = params.id;
+  if (!threadId) {
+    return Response.json({ error: "Thread ID required" }, { status: 400 });
+  }
+  try {
+    const agentBuilderId = env2.AGENT_BUILDER.idFromName("singleton");
+    const agentBuilder = env2.AGENT_BUILDER.get(agentBuilderId);
+    const threadMeta = await agentBuilder.getThread(threadId);
+    if (!threadMeta) {
+      return Response.json({ error: "Thread not found" }, { status: 404 });
+    }
+    const threadStub = env2.AGENT_BUILDER_THREAD.get(
+      env2.AGENT_BUILDER_THREAD.idFromName(threadId)
+    );
+    if (typeof threadStub.watchdogProbe !== "function") {
+      return Response.json(
+        { error: "This deployment does not support watchdog probes" },
+        { status: 501 }
+      );
+    }
+    const result = await threadStub.watchdogProbe(threadId);
+    return Response.json(result);
+  } catch (error) {
+    console.error("Error running watchdog probe:", error);
+    return Response.json(
+      { error: error instanceof Error ? error.message : "Failed to run watchdog probe" },
+      { status: 500 }
+    );
+  }
+});
+
 // src/api/threads/[id]/rpc.post.ts
 var rpc_post_default = defineController2(async ({ req, params, env: env2 }) => {
+  if (isPlatformHosted(env2)) {
+    const authResult = await requirePermission(req, env2, "logs");
+    if (authResult instanceof Response) {
+      return authResult;
+    }
+  } else {
+    const authContext = await authenticate(req, env2);
+    if (authContext && !hasPermission(authContext.user, "logs")) {
+      return Response.json(
+        { error: "Forbidden: 'logs' access required" },
+        { status: 403 }
+      );
+    }
+  }
   const threadId = params.id;
   if (!threadId) {
     return Response.json({ error: "Thread ID required" }, { status: 400 });
@@ -72979,6 +73229,7 @@ var routeHandlers = {
   "GET:/threads/:id/bridge": bridge_default,
   "POST:/threads/:id/continue": continue_post_default,
   "GET:/threads/:id/cost": cost_get_default,
+  "GET:/threads/:id/diagnostics": diagnostics_get_default2,
   "GET:/threads/:id/effects": effects_get_default,
   "GET:/threads/:id/fs": fs_default,
   "DELETE:/threads/:id/kv": kv_default,
@@ -72988,6 +73239,7 @@ var routeHandlers = {
   "GET:/threads/:id/messages": messages_get_default,
   "POST:/threads/:id/messages": messages_post_default,
   "GET:/threads/:id/pending-tool-calls": pending_tool_calls_get_default,
+  "POST:/threads/:id/revive": revive_post_default,
   "POST:/threads/:id/rpc": rpc_post_default,
   "POST:/threads/:id/stop": stop_post_default,
   "GET:/threads/:id/stream": stream_default,