@standardagents/builder 0.29.0 → 0.29.2

package/dist/{index-Cp_Zcrhy.d.ts → index-CcnGEkPh.d.ts}

@@ -131,6 +131,18 @@ interface ClientStreamRequest {
     meta?: Record<string, unknown>;
     /** Milliseconds to wait for the client to accept the stream. */
     timeoutMs?: number;
+    /**
+     * Builder-internal reconnect hint, never sent to the client: when the
+     * thread's elected execution owner has no live socket, ask this user's hub
+     * to summon the owning machine's daemon to `threadId` and wait for the
+     * bridge to re-attach before failing the open. Without it a transient
+     * disconnect (daemon restart, network blip) surfaces instantly as
+     * "workspace unavailable" mid-turn.
+     */
+    wake?: {
+        threadId: string;
+        userId: string;
+    };
 }
 /**
  * A live bidirectional byte pipe between the thread runtime and the client.
@@ -384,7 +396,10 @@ interface ThreadInstance {
     getValue<T = unknown>(key: string): Promise<T | null>;
     setValue(key: string, value: unknown): Promise<void>;
     emitThreadEvent?(threadId: string, event: string, data: unknown): void | Promise<void>;
-    callClientTool?(request: ClientToolRequest): Promise<ClientToolResponse>;
+    callClientTool?(request: ClientToolRequest, durability?: {
+        toolCallId: string;
+        side: "a" | "b";
+    }): Promise<ClientToolResponse>;
     openClientStream?(request: ClientStreamRequest): Promise<ClientStreamResponse>;
     dispatchClientTool?(request: ClientToolRequest, toolCallId: string, side: "a" | "b"): Promise<{
         dispatched: boolean;

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { ModelDefinition, AgentDefinition } from './runtime.js';
 export { AgentBuilderEnv, AuthContext, AuthUser, BroadcastOptions, CodeExecutionBridge, DurableAgentBuilder, DurableThread, DurableUserHub, FlowStateSdk, FlowStateWithSdk, HubClientInfo, ImageContextConfig, InjectMessageOptions, LLMProviderInterface, NamespaceResolutionError, PromptContent, PromptDefinition, PromptIncludePart, PromptPart, PromptToolConfig, Provider, ProviderContentPart, ProviderFilePart, ProviderImagePart, ProviderRegistry, ProviderTextPart, SessionToolBinding, SessionToolConfig, SideConfig, SubagentToolConfig, SubpromptConfig, ThreadRegistryEntry, ThreadWatchdog, ThreadWatchdogState, ToolConfig, UpdateThreadParams, User, WatchdogCheckin, WatchdogProbeResult, authenticate, buildImageDescription, cat, createNamespaceContext, emitThreadEvent, enhanceFlowState, exists, find, forceTurn, generateImageDescription, getFileStats, getMessages, getMessagesToSummarize, getShortName, getThumbnail, getUnsummarizedImageAttachments, getVisibleAgentNames, getVisibleModelNames, getVisiblePromptNames, getVisibleToolNames, grep, hasImageAttachments, head, injectMessage, isQualifiedName, linkFile, mkdir, move, optimizeImageContext, parseQualifiedName, qualifyName, queueTool, readFile, readdir, reloadHistory, rename, replaceImagesWithDescriptions, requireAdmin, requireAuth, resolveAgent, resolveHook, resolveModel, resolvePrompt, resolveTool, rmdir, stat, tail, unlink, updateThread, writeFile, writeImage } from './runtime.js';
 export { AgentPluginOptions, agentbuilder, builder } from './plugin.js';
-export { A as Agent, x as AttachmentRef, f as BuilderThreadEndpointHandler, C as CLIENT_STREAM_CHUNK_BYTES, o as ClientDuplex, p as ClientForwarding, m as ClientStreamRequest, n as ClientStreamResponse, k as ClientToolRequest, l as ClientToolResponse, B as Controller, a as ControllerContext, E as Env, w as FileRecord, y as FileStats, u as FlowResult, F as FlowState, G as GrepResult, D as ImageContentPart, I as ImageMetadata, L as LLMResponse, M as Message, J as MessageContent, H as MultimodalContent, R as RequestContext, S as StorageBackend, v as TelemetryEvent, z as TextContentPart, b as ThreadEndpointContext, e as ThreadEnv, q as ThreadInstance, r as ThreadMetadata, T as ToolCall, t as ToolResult, g as callClient, h as callClientStream, c as createThreadEndpointHandler, j as decodeStreamChunk, d as defineController, i as encodeStreamChunk, s as supportsClientForwarding } from './index-Cp_Zcrhy.js';
+export { A as Agent, x as AttachmentRef, f as BuilderThreadEndpointHandler, C as CLIENT_STREAM_CHUNK_BYTES, o as ClientDuplex, p as ClientForwarding, m as ClientStreamRequest, n as ClientStreamResponse, k as ClientToolRequest, l as ClientToolResponse, B as Controller, a as ControllerContext, E as Env, w as FileRecord, y as FileStats, u as FlowResult, F as FlowState, G as GrepResult, D as ImageContentPart, I as ImageMetadata, L as LLMResponse, M as Message, J as MessageContent, H as MultimodalContent, R as RequestContext, S as StorageBackend, v as TelemetryEvent, z as TextContentPart, b as ThreadEndpointContext, e as ThreadEnv, q as ThreadInstance, r as ThreadMetadata, T as ToolCall, t as ToolResult, 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';
 export { AgentType, DefinitionLoader, GlobalNamespaceContext, HookSignatures, ImageContent, ModelCapabilities, ModelProvider, NamespaceContext, PackageSignature, PackedExports, PackedMeta, PackedMetadata, PackedNamespaceContext, PromptInput, PromptTextPart, ProviderAssistantMessage, ProviderConfigSlot, ProviderConfigSlots, ProviderConfigValueSource, ProviderDefinition, ProviderError, ProviderErrorCode, ProviderFactory, ProviderFactoryConfig, ProviderFinishReason, ProviderGeneratedImage, ProviderMessage, ProviderMessageContent, ProviderMethodOverrides, ModelCapabilities as ProviderModelCapabilities, ProviderOverride, ProviderOverrideContext, ProviderReasoningDetail, ProviderRequest, ProviderResponse, ProviderStreamChunk, ProviderSyncOverride, ProviderSystemMessage, ProviderTool, ProviderToolCallPart, ProviderToolMessage, ProviderToolResultContent, ProviderUsage, ProviderUserMessage, ReasoningConfig, StructuredPrompt, TextContent, Tool, ToolArgs, ToolArgsNode, ToolArgsRawShape, ToolContent, belongsToPackage, defineAgent, defineHook, defineModel, definePrompt, defineProvider, defineTool, isPacked, isVisibleInNamespace, mapReasoningLevel, providerConst, providerEnv, providerValue } from '@standardagents/spec';
 export { C as ConstituentItem, D as DiscoveredPackage, N as NamespacedRegistry, P as PackingAnalysis, a as PackingOptions, b as PackingResult, c as UnpackOptions, d as UnpackResult } from './types-Bpe7IANZ.js';
 export { D as DiscoveryConfig, P as PackageDiscoveryService, d as discoverPackages } from './discovery-DiMJWisl.js';

package/dist/index.js

@@ -13545,7 +13545,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) {
@@ -13592,7 +13595,9 @@ var init_ThreadStateImpl = __esm({
             error: "This thread runtime cannot open client streams. Client streaming requires the DurableThread bridge."
           };
         }
-        const local = await instance.openClientStream(request);
+        const wakeUserId = this._metadata.user_id ?? null;
+        const withWake = (threadId) => wakeUserId ? { ...request, wake: { threadId, userId: wakeUserId } } : request;
+        const local = await instance.openClientStream(withWake(this._metadata.id));
         if (local.ok || !this.isNoClient(local)) return local;
         const env = this._threadInstance.env;
         if (!env?.AGENT_BUILDER_THREAD) return local;
@@ -13603,7 +13608,7 @@ var init_ThreadStateImpl = __esm({
           try {
             const stub = env.AGENT_BUILDER_THREAD.get(env.AGENT_BUILDER_THREAD.idFromName(parentId));
             if (typeof stub.proxyStreamOpen === "function") {
-              const opened = await stub.proxyStreamOpen(request);
+              const opened = await stub.proxyStreamOpen(withWake(parentId));
               if (opened.ok && opened.id) {
                 return { ok: true, duplex: this.buildProxyDuplex(stub, opened.id) };
               }
@@ -28277,7 +28282,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(
@@ -28336,7 +28341,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) {
@@ -28346,7 +28351,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((resolve2) => {
@@ -28397,6 +28428,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. */
@@ -28648,6 +28686,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
@@ -28670,10 +28728,40 @@ ${resultContent}${attachmentSummary}`;
   // they are bound to one bridge socket and never park.
   /** Default time to wait for the client to accept a stream open. */
   static CLIENT_STREAM_OPEN_TIMEOUT_MS = 3e4;
+  /** Poll cadence while waiting for a disconnected owner's bridge to return. */
+  static OWNER_REATTACH_POLL_MS = 250;
+  /**
+   * The thread HAS an elected execution owner, but its bridge socket is gone
+   * (daemon restart, network blip, DO handoff). Summon the owning machine
+   * through the per-user hub and wait for a bridge to re-attach instead of
+   * failing the stream open instantly — that instant failure is what ended
+   * Sama One turns with "workspace unavailable" whenever a slow tool/approval
+   * outlived the socket. Threads with NO recorded owner (subagent children)
+   * still fail fast so ancestor walk-up routing stays immediate.
+   */
+  async awaitOwnerBridgeSocket(request) {
+    if (request.wake?.userId) {
+      void this.requestHubWake(request.wake.userId, request.wake.threadId);
+    }
+    const timeoutMs = typeof request.timeoutMs === "number" && request.timeoutMs > 0 ? request.timeoutMs : _DurableThread.CLIENT_STREAM_OPEN_TIMEOUT_MS;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await new Promise(
+        (resolve2) => setTimeout(resolve2, _DurableThread.OWNER_REATTACH_POLL_MS)
+      );
+      const owner = await this.getExecutionOwner();
+      const socket = this.getOpenBridgeSocket(owner?.client_id ?? null);
+      if (socket) return socket;
+    }
+    return null;
+  }
   /** Open a bidirectional byte stream to the connected owner client. */
   async openClientStream(request) {
     const owner = await this.getExecutionOwner();
-    const socket = this.getOpenBridgeSocket(owner?.client_id ?? null);
+    let socket = this.getOpenBridgeSocket(owner?.client_id ?? null);
+    if (!socket && owner) {
+      socket = await this.awaitOwnerBridgeSocket(request);
+    }
     if (!socket) {
       return {
         ok: false,
@@ -28967,6 +29055,11 @@ ${resultContent}${attachmentSummary}`;
       console.error("[DurableThread] Failed to arm park TTL (non-fatal):", error);
     }
     if (!userId) return;
+    await this.requestHubWake(userId, threadId);
+  }
+  /** Ask the user's hub to summon the owning machine's daemon to a thread.
+   *  Best-effort: wake failure must never fail the caller's own path. */
+  async requestHubWake(userId, threadId) {
     try {
       const namespace = this.env.AGENT_BUILDER_USER_HUB;
       if (!namespace) return;
@@ -29550,6 +29643,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,