@standardagents/builder 0.29.1 → 0.29.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-BNLDsLsL.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-BNLDsLsL.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-CcnGEkPh.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-CcnGEkPh.js';
 import { CodeExecutionOptions, CodeExecutionResult, SubagentRegistryEntry, InjectMessageInput, QueueMessageInput, 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';
@@ -1043,7 +1043,10 @@ declare class DurableThread<Env extends ThreadEnv = ThreadEnv> extends DurableOb
      * always produce a normal tool error (no client connected, timeout, or user
      * denial) for the model to reason about.
      */
-    callClientTool(request: ClientToolRequest): Promise<ClientToolResponse>;
+    callClientTool(request: ClientToolRequest, durability?: {
+        toolCallId: string;
+        side: "a" | "b";
+    }): Promise<ClientToolResponse>;
     /** Settle a pending forwarded call exactly once, clearing its timers. */
     private settleClientCall;
     /** Close and forget a bridge socket we've deemed dead, failing remaining calls. */

package/dist/runtime.js

@@ -13536,7 +13536,10 @@ var init_ThreadStateImpl = __esm({
             data: { deferred: true, toolCallId }
           };
         }
-        const local = await this._threadInstance.callClientTool(request);
+        const local = await this._threadInstance.callClientTool(
+          request,
+          canPark && toolCallId ? { toolCallId, side } : void 0
+        );
         if (local.ok || !this.isNoClient(local)) return local;
         const env = this._threadInstance.env;
         if (env?.AGENT_BUILDER_THREAD) {
@@ -19938,7 +19941,7 @@ ${resultContent}${attachmentSummary}`;
   }
   /** Whether any forwarded call is mid-flight (blocking await or parked). */
   async hasInFlightClientCalls() {
-    if (this.pendingClientCalls.size > 0) return true;
+    if ((this.pendingClientCalls?.size ?? 0) > 0) return true;
     await this.ensureMigrated();
     await this.ensurePendingClientTable();
     const cursor = await this.ctx.storage.sql.exec(
@@ -19997,7 +20000,7 @@ ${resultContent}${attachmentSummary}`;
    * always produce a normal tool error (no client connected, timeout, or user
    * denial) for the model to reason about.
    */
-  async callClientTool(request) {
+  async callClientTool(request, durability) {
     const owner = await this.getExecutionOwner();
     const socket = this.getOpenBridgeSocket(owner?.client_id ?? null);
     if (!socket) {
@@ -20007,7 +20010,33 @@ ${resultContent}${attachmentSummary}`;
         data: { noClient: true }
       };
     }
-    const id = crypto.randomUUID();
+    if (durability) {
+      try {
+        await this.ensureMigrated();
+        await this.ensurePendingClientTable();
+        const ownerId = owner?.client_id ?? null;
+        const socketClientId = this.bridgeClientInfo.get(socket)?.clientId ?? null;
+        const fenced = owner && socketClientId === owner.client_id;
+        await this.ctx.storage.sql.exec(
+          `INSERT OR REPLACE INTO pending_client_calls
+             (tool_call_id, tool, args, request_permission, risk, side, status, created_at,
+              dispatched_client_id, dispatched_generation)
+           VALUES (?, ?, ?, ?, ?, ?, 'pending', ?, ?, ?)`,
+          durability.toolCallId,
+          request.tool,
+          JSON.stringify(request.args ?? {}),
+          request.requestPermission ?? null,
+          typeof request.risk === "number" ? request.risk : null,
+          durability.side,
+          Date.now(),
+          fenced ? ownerId : null,
+          fenced ? owner.generation : 0
+        );
+      } catch (error) {
+        console.error("[DurableThread] Failed to persist fast-path call (continuing):", error);
+      }
+    }
+    const id = durability?.toolCallId ?? crypto.randomUUID();
     const timeoutMs = typeof request.timeoutMs === "number" && request.timeoutMs > 0 ? request.timeoutMs : DEFAULT_CLIENT_TOOL_TIMEOUT_MS;
     this.bridgeLastSeen.set(socket, Date.now());
     return new Promise((resolve) => {
@@ -20058,6 +20087,13 @@ ${resultContent}${attachmentSummary}`;
     this.pendingClientCalls.delete(id);
     if (pending.timer) clearTimeout(pending.timer);
     if (pending.liveness) clearInterval(pending.liveness);
+    try {
+      void this.ctx.storage.sql.exec(
+        `UPDATE pending_client_calls SET status = 'resolved' WHERE tool_call_id = ? AND status = 'pending'`,
+        id
+      );
+    } catch {
+    }
     pending.resolve(res);
   }
   /** Close and forget a bridge socket we've deemed dead, failing remaining calls. */
@@ -20309,6 +20345,26 @@ ${resultContent}${attachmentSummary}`;
       toolStatus,
       toolCallId
     );
+    const updated = await this.ctx.storage.sql.exec(
+      `SELECT COUNT(*) AS total FROM messages WHERE tool_call_id = ? AND role = 'tool'`,
+      toolCallId
+    );
+    if (Number(updated.toArray()[0]?.total ?? 0) === 0) {
+      const toolRow = await this.ctx.storage.sql.exec(
+        `SELECT tool FROM pending_client_calls WHERE tool_call_id = ? LIMIT 1`,
+        toolCallId
+      );
+      await this.ctx.storage.sql.exec(
+        `INSERT INTO messages (id, role, content, name, tool_call_id, tool_status, created_at, status, prompt)
+         VALUES (?, 'tool', ?, ?, ?, ?, ?, 'completed', NULL)`,
+        crypto.randomUUID(),
+        content,
+        toolRow.toArray()[0]?.tool ?? null,
+        toolCallId,
+        toolStatus,
+        Date.now() * TIMESTAMP_MULTIPLIER
+      );
+    }
     await this.ctx.storage.sql.exec(
       `UPDATE pending_client_calls SET status = 'resolved' WHERE tool_call_id = ?`,
       toolCallId
@@ -21246,6 +21302,31 @@ ${resultContent}${attachmentSummary}`;
       `SELECT COUNT(*) AS c FROM message_queue`
     )).toArray()[0]?.c ?? 0;
     if (stopped || finalizedCount === 0 && queued === 0) {
+      let orphanedClientCalls = false;
+      if (!stopped) {
+        try {
+          orphanedClientCalls = await this.hasInFlightClientCalls();
+        } catch {
+          orphanedClientCalls = false;
+        }
+      }
+      if (orphanedClientCalls) {
+        const owner = await this.getExecutionOwner();
+        const socket = this.getOpenBridgeSocket(owner?.client_id ?? null);
+        if (socket) {
+          void this.resendPendingClientCalls(socket);
+        } else if (threadId) {
+          try {
+            const meta = await this.getThreadMetadata(threadId);
+            if (meta.user_id) await this.requestHubWake(meta.user_id, threadId);
+          } catch {
+          }
+        }
+        console.warn(
+          `[DurableThread] Watchdog: pending forwarded call with no executor on ${threadId} \u2014 ${socket ? "re-dispatched to the connected bridge" : "requested owner wake"}`
+        );
+        return report("observing", "none", { queuedMessages: queued });
+      }
       if (finalizedCount > 0) {
         return report("parked", "finalized_parked", {
           queuedMessages: queued,