@standardagents/builder 0.27.12 → 0.28.0

package/dist/runtime.js

@@ -28,6 +28,28 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/agents/client-forwarding.ts
+function encodeStreamChunk(bytes) {
+  let binary = "";
+  const step = 32768;
+  for (let i = 0; i < bytes.length; i += step) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + step));
+  }
+  return btoa(binary);
+}
+function decodeStreamChunk(data) {
+  const binary = atob(data);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+var CLIENT_STREAM_CHUNK_BYTES;
+var init_client_forwarding = __esm({
+  "src/agents/client-forwarding.ts"() {
+    CLIENT_STREAM_CHUNK_BYTES = 256 * 1024;
+  }
+});
+
 // src/agents/types.ts
 var SUBAGENT_INITIAL_ARGUMENTS_THREAD_PROPERTY, MAX_STEPS, MAX_RETRIES_PER_MODEL, TIMESTAMP_MULTIPLIER, STREAM_COOLDOWN, BACKOFF_BASE;
 var init_types = __esm({
@@ -920,6 +942,20 @@ var init_ProviderRegistry = __esm({
         const threadEnv = state.thread.metadata?.env ?? state.thread.metadata?.tenvs ?? null;
         const agentBuilderId = state.env.AGENT_BUILDER.idFromName("singleton");
         const agentBuilder = state.env.AGENT_BUILDER.get(agentBuilderId);
+        let instanceEnv = null;
+        if (typeof agentBuilder.getInstanceEnvEntries === "function") {
+          try {
+            const entries = await agentBuilder.getInstanceEnvEntries();
+            if (Array.isArray(entries) && entries.length > 0) {
+              instanceEnv = {};
+              for (const entry of entries) {
+                if (entry?.name) instanceEnv[entry.name] = entry.value;
+              }
+            }
+          } catch (error) {
+            console.warn("buildThreadScopedEnv: instance env lookup failed:", error);
+          }
+        }
         let userId = state.thread.metadata?.user_id ?? null;
         let parent = state.thread.metadata?.parent ?? null;
         let hops = 0;
@@ -956,11 +992,12 @@ var init_ProviderRegistry = __esm({
             console.warn("buildThreadScopedEnv:", diagnostic);
           }
         }
-        if (!userEnv && !threadEnv) {
+        if (!instanceEnv && !userEnv && !threadEnv) {
           this.scopeDiagnostics.set(state.env, diagnostic);
           return state.env;
         }
-        const merged = { ...state.env, ...userEnv ?? {}, ...threadEnv ?? {} };
+        if (instanceEnv) diagnostic = `${diagnostic ? diagnostic + "; " : ""}instance env: ${Object.keys(instanceEnv).length} entries`;
+        const merged = { ...state.env, ...instanceEnv ?? {}, ...userEnv ?? {}, ...threadEnv ?? {} };
         this.scopeDiagnostics.set(merged, diagnostic);
         return merged;
       }
@@ -974,7 +1011,7 @@ var init_ProviderRegistry = __esm({
        * @param thread - Thread instance for loading model from virtual modules
        * @returns Provider and model definition
        */
-      async getProvider(modelName, env, thread) {
+      async getProvider(modelName, env, thread, getState) {
         if (!thread) {
           throw new Error("Thread instance required for model lookup");
         }
@@ -1007,6 +1044,18 @@ var init_ProviderRegistry = __esm({
             );
           }
           const config = resolved.providerConfig;
+          if (typeof providerDefinition.createFetch === "function") {
+            const state = getState ? await getState() : void 0;
+            const configWithFetch = {
+              ...config,
+              fetch: providerDefinition.createFetch({
+                providerName,
+                config,
+                state
+              })
+            };
+            return this.buildResult(providerFactory(configWithFetch), modelDef, false);
+          }
           const fingerprint = this.getProviderFingerprint(providerName, modelDef, config);
           const cached = this.providerCache.get(modelName);
           if (cached?.fingerprint === fingerprint) {
@@ -1879,7 +1928,16 @@ var init_LLMRequest = __esm({
       static async callModel(modelId, context, state, logId) {
         const { ProviderRegistry: ProviderRegistry2 } = await Promise.resolve().then(() => (init_providers(), providers_exports));
         const providerEnv = await ProviderRegistry2.buildThreadScopedEnv(state);
-        const { provider, modelName, modelDef, viaPlatform, platformProxyOrigin } = await ProviderRegistry2.getProvider(modelId, providerEnv, state.thread.instance);
+        const getThreadState = async () => {
+          const { ThreadStateImpl: ThreadStateImpl2 } = await Promise.resolve().then(() => (init_ThreadStateImpl(), ThreadStateImpl_exports));
+          return ThreadStateImpl2.fromFlowState(state);
+        };
+        const { provider, modelName, modelDef, viaPlatform, platformProxyOrigin } = await ProviderRegistry2.getProvider(
+          modelId,
+          providerEnv,
+          state.thread.instance,
+          getThreadState
+        );
         const streamAbort = new AbortController();
         const parentSignal = state.abortController?.signal;
         let onParentAbort;
@@ -4329,8 +4387,17 @@ ${errorLines.join("\n")}`);
               responseParts.push(`Other tools run: ${successfulToolNames.join(", ")}`);
             }
           } else {
-            if (toolResponseOptions.include_text_response && textContent) {
-              responseParts.push(textContent);
+            if (toolResponseOptions.include_text_response) {
+              let responseText = textContent;
+              if (!responseText) {
+                const recovered = await state.storage.sql.exec(
+                  `SELECT content FROM messages WHERE parent_id = ? AND role = 'assistant' AND content IS NOT NULL AND content != '' AND (tool_calls IS NULL OR tool_calls = '') ORDER BY created_at DESC LIMIT 1`,
+                  toolMessageId
+                );
+                const recoveredRow = recovered.toArray()[0];
+                if (recoveredRow?.content) responseText = recoveredRow.content;
+              }
+              if (responseText) responseParts.push(responseText);
             }
             if (toolResponseOptions.include_tool_calls || toolResponseOptions.include_errors) {
               const childAssistantMessagesResult = await state.storage.sql.exec(
@@ -6424,12 +6491,14 @@ var init_FlowEngine = __esm({
           } catch (error) {
             console.error("Fatal error in executeAsync:", error);
             await this.logError(state, error, "fatal_execution_error", "FlowEngine.executeAsync");
+            await this.settleTerminalFailure(state, error);
             throw error;
           }
         } else {
           this.executeAsync(state, state.threadId).catch(async (error) => {
             console.error("Fatal error in executeAsync:", error);
             await this.logError(state, error, "fatal_execution_error", "FlowEngine.executeAsync");
+            await this.settleTerminalFailure(state, error);
           });
         }
         return {
@@ -6483,10 +6552,27 @@ var init_FlowEngine = __esm({
           console.warn(
             `[FlowEngine] Finalized ${rows.length} orphaned incomplete log(s) for thread ${state.threadId}`
           );
+          await state.thread.instance.failPendingMessagesAndBroadcast?.();
         } catch (err) {
           console.error("[FlowEngine] Failed to finalize orphaned logs (non-fatal):", err);
         }
       }
+      /**
+       * A terminal execution failure ended the run without a normal assistant
+       * reply. Persist a durable failed assistant message + settle pending
+       * messages so every connected head lands on a visible end state instead of
+       * a stuck "Working" spinner. Best-effort — never masks the original error.
+       */
+      static async settleTerminalFailure(state, error) {
+        try {
+          const detail = error instanceof Error ? error.message : String(error);
+          await state.thread.instance.settleTerminalFailure?.(
+            `The agent run failed unexpectedly: ${detail}`
+          );
+        } catch (settleError) {
+          console.error("[FlowEngine] Failed to settle terminal failure (non-fatal):", settleError);
+        }
+      }
       static async executeAsync(state, threadId) {
         const effectiveMaxSteps = Math.max(
           MAX_STEPS,
@@ -12761,6 +12847,7 @@ function runCodeViaThreadRpc(threadInstance, threadId, source, options) {
 var ThreadStateImpl, ExecutionStateImpl;
 var init_ThreadStateImpl = __esm({
   "src/agents/ThreadStateImpl.ts"() {
+    init_client_forwarding();
     init_types();
     init_utilities();
     init_code_execution();
@@ -13345,9 +13432,10 @@ var init_ThreadStateImpl = __esm({
         }
         const instance = this._threadInstance;
         const toolCallId = this._flowState?.currentToolCall?.id;
-        const mustPark = request.requestPermission != null && await this.forwardedCallNeedsApproval(request);
-        if (mustPark && toolCallId && this._executionState && typeof instance.dispatchClientTool === "function" && typeof instance.hasBridge === "function" && await instance.hasBridge()) {
-          const side = this._flowState?.currentSide === "b" ? "b" : "a";
+        const canPark = !!(toolCallId && this._executionState && typeof instance.dispatchClientTool === "function");
+        const side = this._flowState?.currentSide === "b" ? "b" : "a";
+        const mustParkForApproval = request.requestPermission != null && await this.forwardedCallNeedsApproval(request);
+        if (mustParkForApproval && canPark && toolCallId && typeof instance.hasBridge === "function" && await instance.hasBridge()) {
           await instance.dispatchClientTool(request, toolCallId, side);
           this._executionState.stop();
           return {
@@ -13359,6 +13447,55 @@ var init_ThreadStateImpl = __esm({
         const local = await this._threadInstance.callClientTool(request);
         if (local.ok || !this.isNoClient(local)) return local;
         const env = this._threadInstance.env;
+        if (env?.AGENT_BUILDER_THREAD) {
+          const seen = /* @__PURE__ */ new Set([this._metadata.id]);
+          let parentId = await this.resolveParentThreadId(this._metadata.id);
+          while (parentId && !seen.has(parentId)) {
+            seen.add(parentId);
+            try {
+              const stub = env.AGENT_BUILDER_THREAD.get(env.AGENT_BUILDER_THREAD.idFromName(parentId));
+              const res = await stub.callClientTool(request);
+              if (res.ok || !this.isNoClient(res)) return res;
+            } catch {
+            }
+            parentId = await this.resolveParentThreadId(parentId);
+          }
+        }
+        if (canPark && toolCallId) {
+          await instance.dispatchClientTool(request, toolCallId, side);
+          if (typeof instance.notifyClientWaiting === "function") {
+            try {
+              await instance.notifyClientWaiting(toolCallId, this._metadata.id, this._metadata.user_id ?? null);
+            } catch {
+            }
+          }
+          this._executionState.stop();
+          return {
+            ok: true,
+            result: `\u23F3 Waiting for your machine to reconnect to run ${request.tool}\u2026`,
+            data: { deferred: true, parked: true, waitingForClient: true, toolCallId }
+          };
+        }
+        return local;
+      }
+      /**
+       * Open a bidirectional byte stream to the connected client (e.g. a raw TCP
+       * tunnel for Worker-side TLS termination). Streams require a LIVE bridge on
+       * this thread and never park — a stream is only meaningful while the client
+       * is attached. Subagents must not call this directly; they proxy whole
+       * requests up to the root thread instead (request-up / stream-down).
+       */
+      async callClientStream(request) {
+        const instance = this._threadInstance;
+        if (typeof instance.openClientStream !== "function") {
+          return {
+            ok: false,
+            error: "This thread runtime cannot open client streams. Client streaming requires the DurableThread bridge."
+          };
+        }
+        const local = await instance.openClientStream(request);
+        if (local.ok || !this.isNoClient(local)) return local;
+        const env = this._threadInstance.env;
         if (!env?.AGENT_BUILDER_THREAD) return local;
         const seen = /* @__PURE__ */ new Set([this._metadata.id]);
         let parentId = await this.resolveParentThreadId(this._metadata.id);
@@ -13366,14 +13503,86 @@ var init_ThreadStateImpl = __esm({
           seen.add(parentId);
           try {
             const stub = env.AGENT_BUILDER_THREAD.get(env.AGENT_BUILDER_THREAD.idFromName(parentId));
-            const res = await stub.callClientTool(request);
-            if (res.ok || !this.isNoClient(res)) return res;
+            if (typeof stub.proxyStreamOpen === "function") {
+              const opened = await stub.proxyStreamOpen(request);
+              if (opened.ok && opened.id) {
+                return { ok: true, duplex: this.buildProxyDuplex(stub, opened.id) };
+              }
+              if (opened.error && !opened.noClient) {
+                return { ok: false, error: opened.error };
+              }
+            }
           } catch {
           }
           parentId = await this.resolveParentThreadId(parentId);
         }
         return local;
       }
+      /**
+       * Build a client duplex that bridges to a stream opened on an ancestor DO
+       * (the bridge holder) via chunk-pull RPCs. `readable` polls `proxyStreamPull`;
+       * `writable` forwards each chunk with `proxyStreamWrite`; teardown calls
+       * `proxyStreamAbort`.
+       */
+      buildProxyDuplex(stub, id) {
+        let settleDone;
+        const done = new Promise((r) => settleDone = r);
+        let closed = false;
+        const readable = new ReadableStream({
+          async pull(controller) {
+            while (!closed) {
+              let res;
+              try {
+                res = await stub.proxyStreamPull(id);
+              } catch (error) {
+                controller.error(error instanceof Error ? error : new Error(String(error)));
+                settleDone({ ok: false, error: "proxy stream pull failed" });
+                return;
+              }
+              for (const chunk of res.chunks) {
+                controller.enqueue(decodeStreamChunk(chunk));
+              }
+              if (res.done) {
+                controller.close();
+                settleDone(res.error ? { ok: false, error: res.error } : { ok: true });
+                return;
+              }
+              if (res.chunks.length > 0) return;
+              await new Promise((r) => setTimeout(r, 25));
+            }
+          },
+          cancel() {
+            closed = true;
+            void stub.proxyStreamAbort(id).catch(() => {
+            });
+          }
+        });
+        const writable = new WritableStream({
+          async write(chunk) {
+            await stub.proxyStreamWrite(id, encodeStreamChunk(chunk));
+          },
+          close() {
+            void stub.proxyStreamEnd?.(id).catch?.(() => {
+            });
+          },
+          abort() {
+            closed = true;
+            void stub.proxyStreamAbort(id).catch(() => {
+            });
+          }
+        });
+        return {
+          readable,
+          writable,
+          close: (error) => {
+            closed = true;
+            void stub.proxyStreamAbort(id).catch(() => {
+            });
+            settleDone(error ? { ok: false, error } : { ok: true });
+          },
+          done
+        };
+      }
       isNoClient(res) {
         return res.ok === false && !!res.data && typeof res.data === "object" && res.data.noClient === true;
       }
@@ -15922,6 +16131,7 @@ function isQualifiedName(name) {
 }
 
 // src/durable-objects/DurableThread.ts
+init_client_forwarding();
 init_sessionTools();
 
 // src/durable-objects/bridge-owner.ts
@@ -16152,6 +16362,11 @@ var DurableThread = class _DurableThread extends DurableObject {
   // setValue() so external KV writes (release/reassign) invalidate it too.
   executionOwnerCache = void 0;
   pendingClientCalls = /* @__PURE__ */ new Map();
+  // Live bidirectional client byte streams (e.g. TCP tunnels for Worker-side
+  // TLS). Keyed by stream id; each stream is bound to the bridge socket it was
+  // opened on and dies with it. Streams are in-memory only — they exist solely
+  // while the client is attached and never park durably.
+  clientStreams = /* @__PURE__ */ new Map();
   alarmQueue;
   alarmQueueRearmed = false;
   currentAbortController = null;
@@ -16211,6 +16426,9 @@ var DurableThread = class _DurableThread extends DurableObject {
           case "watchdogCheck":
             await this.watchdogCheck(args.threadId);
             break;
+          case "clientParkTimeout":
+            await this.failParkedClientCall(args.toolCallId, args.threadId);
+            break;
           default:
             throw new Error(`Unknown method: ${method}`);
         }
@@ -18194,6 +18412,69 @@ ${resultContent}${attachmentSummary}`;
    * Stop the currently executing thread (RPC method)
    * Simple "off" switch - stops turns, only cleared by user messages
    */
+  /**
+   * Flip every still-`pending` message to `failed` and broadcast the change to
+   * all connected heads. This is THE settle path for any terminal condition
+   * that leaves a turn half-open — user stop, lost execution, terminal
+   * execution failure, and expired parked forwarded calls — so no head is
+   * left rendering a stuck "Working" state. Returns the failure timestamp.
+   */
+  async failPendingMessagesAndBroadcast() {
+    const now = Date.now() * TIMESTAMP_MULTIPLIER;
+    await this.ctx.storage.sql.exec(
+      `UPDATE messages SET status = 'failed', response_completed_at = ? WHERE status = 'pending'`,
+      now
+    );
+    const cursor = await this.ctx.storage.sql.exec(
+      `SELECT id, role, content, tool_calls, tool_call_id, tool_status, created_at, log_id, status, request_sent_at, response_completed_at FROM messages WHERE response_completed_at = ?`,
+      now
+    );
+    for (const row of cursor) {
+      this.broadcastMessage({
+        id: row.id,
+        role: row.role,
+        content: row.content,
+        tool_calls: row.tool_calls,
+        tool_call_id: row.tool_call_id,
+        tool_status: row.tool_status,
+        created_at: row.created_at,
+        log_id: row.log_id,
+        status: "failed",
+        request_sent_at: row.request_sent_at,
+        response_completed_at: row.response_completed_at
+      });
+    }
+    return now;
+  }
+  /**
+   * A terminal failure ended a turn without a normal assistant reply: settle
+   * every pending message and persist a durable `failed` assistant message so
+   * all connected heads land on a real, visible end state — never a stuck
+   * "Working" spinner. Used by the FlowEngine's terminal catch and the parked
+   * forwarded-call TTL.
+   */
+  async settleTerminalFailure(errorMessage) {
+    await this.ensureMigrated();
+    await this.failPendingMessagesAndBroadcast();
+    const messageId = crypto.randomUUID();
+    const timestamp = Date.now() * TIMESTAMP_MULTIPLIER;
+    await this.ctx.storage.sql.exec(
+      `INSERT INTO messages (id, role, content, created_at, status, prompt) VALUES (?, ?, ?, ?, ?, ?)`,
+      messageId,
+      "assistant",
+      errorMessage,
+      timestamp,
+      "failed",
+      null
+    );
+    this.broadcastMessage({
+      id: messageId,
+      role: "assistant",
+      content: errorMessage,
+      created_at: timestamp,
+      status: "failed"
+    });
+  }
   async stop() {
     await this.ensureMigrated();
     try {
@@ -18203,30 +18484,7 @@ ${resultContent}${attachmentSummary}`;
       if (this.currentAbortController) {
         this.currentAbortController.abort();
       }
-      const now = Date.now() * TIMESTAMP_MULTIPLIER;
-      const updateCursor = await this.ctx.storage.sql.exec(
-        `UPDATE messages SET status = 'failed', response_completed_at = ? WHERE status = 'pending'`,
-        now
-      );
-      const cursor = await this.ctx.storage.sql.exec(
-        `SELECT id, role, content, tool_calls, tool_call_id, tool_status, created_at, log_id, status, request_sent_at, response_completed_at FROM messages WHERE response_completed_at = ?`,
-        now
-      );
-      for (const row of cursor) {
-        this.broadcastMessage({
-          id: row.id,
-          role: row.role,
-          content: row.content,
-          tool_calls: row.tool_calls,
-          tool_call_id: row.tool_call_id,
-          tool_status: row.tool_status,
-          created_at: row.created_at,
-          log_id: row.log_id,
-          status: "failed",
-          request_sent_at: row.request_sent_at,
-          response_completed_at: row.response_completed_at
-        });
-      }
+      const now = await this.failPendingMessagesAndBroadcast();
       const messagesWithToolsCursor = await this.ctx.storage.sql.exec(
         `SELECT id, tool_calls, depth FROM messages WHERE tool_calls IS NOT NULL AND tool_calls != 'null' AND (depth IS NULL OR depth = 0)`
       );
@@ -19703,6 +19961,7 @@ ${resultContent}${attachmentSummary}`;
       socket.close();
     } catch {
     }
+    this.failClientStreamsForSocket(socket);
     this.failPendingClientCallsIfNoBridge();
   }
   /**
@@ -19958,6 +20217,352 @@ ${resultContent}${attachmentSummary}`;
     }
     return { side };
   }
+  // ─── Client byte streams (Worker-side TLS tunnels) ─────────────────────────
+  // A stream is a bidirectional byte pipe over the bridge WebSocket: the
+  // client opens a raw TCP socket per the stream's `meta` and shuttles bytes
+  // both ways; the Worker terminates TLS over those bytes (node:tls over the
+  // duplex), so the client only ever relays ciphertext. Streams are bound to a
+  // live socket and never park.
+  /** Default time to wait for the client to accept a stream open. */
+  static CLIENT_STREAM_OPEN_TIMEOUT_MS = 3e4;
+  /** 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);
+    if (!socket) {
+      return {
+        ok: false,
+        error: "The workspace is not available right now. Try again in a moment.",
+        data: { noClient: true }
+      };
+    }
+    const id = crypto.randomUUID();
+    let controller = null;
+    const readable = new ReadableStream({
+      start: (c) => {
+        controller = c;
+      },
+      cancel: () => {
+        this.abortClientStream(id, "The stream reader was canceled.");
+      }
+    });
+    let settleDone;
+    const done = new Promise((resolve) => {
+      settleDone = resolve;
+    });
+    const state = {
+      socket,
+      controller,
+      opened: null,
+      openTimer: null,
+      settleDone,
+      settled: false
+    };
+    this.clientStreams.set(id, state);
+    this.bridgeLastSeen.set(socket, Date.now());
+    const openResult = await new Promise((resolve) => {
+      state.opened = resolve;
+      const timeoutMs = typeof request.timeoutMs === "number" && request.timeoutMs > 0 ? request.timeoutMs : _DurableThread.CLIENT_STREAM_OPEN_TIMEOUT_MS;
+      state.openTimer = setTimeout(() => {
+        resolve({
+          ok: false,
+          error: `The client did not accept the ${request.tool} stream within ${Math.round(timeoutMs / 1e3)}s.`
+        });
+      }, timeoutMs);
+      try {
+        socket.send(
+          JSON.stringify({
+            type: "stream_open",
+            id,
+            tool: request.tool,
+            meta: request.meta ?? {}
+          })
+        );
+      } catch (error) {
+        resolve({
+          ok: false,
+          error: `Failed to reach the client: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+    });
+    state.opened = null;
+    if (state.openTimer) {
+      clearTimeout(state.openTimer);
+      state.openTimer = null;
+    }
+    if (!openResult.ok) {
+      this.clientStreams.delete(id);
+      state.settled = true;
+      settleDone({ ok: false, error: openResult.error });
+      return { ok: false, error: openResult.error ?? "Stream open failed." };
+    }
+    const sendChunked = (bytes) => {
+      for (let i = 0; i < bytes.length; i += CLIENT_STREAM_CHUNK_BYTES) {
+        const chunk = bytes.subarray(i, i + CLIENT_STREAM_CHUNK_BYTES);
+        socket.send(JSON.stringify({ type: "stream_data", id, data: encodeStreamChunk(chunk) }));
+      }
+    };
+    const writable = new WritableStream({
+      write: (chunk) => {
+        if (!this.clientStreams.has(id)) {
+          throw new Error("The client stream is closed.");
+        }
+        sendChunked(chunk);
+      },
+      close: () => {
+        try {
+          if (this.clientStreams.has(id)) {
+            socket.send(JSON.stringify({ type: "stream_end", id }));
+          }
+        } catch {
+        }
+      },
+      abort: (reason) => {
+        this.abortClientStream(id, reason instanceof Error ? reason.message : String(reason));
+      }
+    });
+    const duplex = {
+      readable,
+      writable,
+      close: (error) => this.abortClientStream(id, error),
+      done
+    };
+    return { ok: true, duplex };
+  }
+  // ─── Subagent stream proxy-up (chunk-pull, no cross-DO ReadableStream) ─────
+  // A subagent (child thread, no bridge) proxies its whole stream request UP to
+  // this bridge-holding root. We open the client stream locally, then buffer
+  // incoming bytes so the child can drain them over plain request/response RPCs
+  // — sidestepping the unproven DO-to-DO ReadableStream return.
+  proxyStreams = /* @__PURE__ */ new Map();
+  async proxyStreamOpen(request) {
+    const opened = await this.openClientStream(request);
+    if (!opened.ok) {
+      const noClient = !!(opened.data && opened.data.noClient);
+      return { ok: false, error: opened.error, noClient };
+    }
+    const id = crypto.randomUUID();
+    const duplex = opened.duplex;
+    const reader = duplex.readable.getReader();
+    const writer = duplex.writable.getWriter();
+    const entry = {
+      writer,
+      reader,
+      buffer: [],
+      done: false,
+      error: void 0,
+      pump: Promise.resolve(),
+      close: (error) => duplex.close(error)
+    };
+    entry.pump = (async () => {
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          if (value) entry.buffer.push(value);
+        }
+      } catch (error) {
+        entry.error = error instanceof Error ? error.message : String(error);
+      } finally {
+        entry.done = true;
+      }
+    })();
+    void duplex.done.then((d) => {
+      entry.done = true;
+      if (!d.ok && !entry.error) entry.error = d.error;
+    });
+    this.proxyStreams.set(id, entry);
+    return { ok: true, id };
+  }
+  async proxyStreamWrite(id, dataB64) {
+    const entry = this.proxyStreams.get(id);
+    if (!entry) return;
+    try {
+      await entry.writer.write(decodeStreamChunk(dataB64));
+    } catch {
+    }
+  }
+  async proxyStreamPull(id) {
+    const entry = this.proxyStreams.get(id);
+    if (!entry) return { chunks: [], done: true, error: "unknown proxy stream" };
+    const chunks = entry.buffer.splice(0).map((b) => encodeStreamChunk(b));
+    if (entry.done && entry.buffer.length === 0) {
+      this.proxyStreams.delete(id);
+      return { chunks, done: true, error: entry.error };
+    }
+    return { chunks, done: false };
+  }
+  async proxyStreamEnd(id) {
+    const entry = this.proxyStreams.get(id);
+    if (!entry) return;
+    try {
+      await entry.writer.close();
+    } catch {
+    }
+  }
+  async proxyStreamAbort(id) {
+    const entry = this.proxyStreams.get(id);
+    if (!entry) return;
+    this.proxyStreams.delete(id);
+    try {
+      entry.close("aborted");
+    } catch {
+    }
+  }
+  /** Settle and remove a client stream exactly once. */
+  settleClientStream(id, result) {
+    const state = this.clientStreams.get(id);
+    if (!state) return;
+    this.clientStreams.delete(id);
+    if (state.openTimer) clearTimeout(state.openTimer);
+    if (state.opened) state.opened({ ok: false, error: result.error ?? "Stream closed." });
+    if (!state.settled) {
+      state.settled = true;
+      try {
+        if (result.ok) state.controller?.close();
+        else state.controller?.error(new Error(result.error ?? "Client stream aborted."));
+      } catch {
+      }
+      state.settleDone(result);
+    }
+  }
+  /** Abort a stream from the Worker side, telling the client to tear down. */
+  abortClientStream(id, error) {
+    const state = this.clientStreams.get(id);
+    if (!state) return;
+    try {
+      if (state.socket.readyState === WebSocket.OPEN) {
+        state.socket.send(JSON.stringify({ type: "stream_abort", id, error: error ?? null }));
+      }
+    } catch {
+    }
+    this.settleClientStream(id, error ? { ok: false, error } : { ok: true });
+  }
+  /** Handle an incoming stream_* frame from a bridge client. */
+  handleClientStreamFrame(ws, parsed) {
+    const id = typeof parsed.id === "string" ? parsed.id : null;
+    if (!id) return;
+    const state = this.clientStreams.get(id);
+    if (!state || state.socket !== ws) return;
+    switch (parsed.type) {
+      case "stream_opened": {
+        if (state.opened) {
+          const resolve = state.opened;
+          state.opened = null;
+          if (state.openTimer) {
+            clearTimeout(state.openTimer);
+            state.openTimer = null;
+          }
+          resolve({ ok: true });
+        }
+        return;
+      }
+      case "stream_error": {
+        const error = typeof parsed.error === "string" ? parsed.error : "Client stream error.";
+        this.settleClientStream(id, { ok: false, error });
+        return;
+      }
+      case "stream_data": {
+        if (typeof parsed.data !== "string") return;
+        try {
+          state.controller?.enqueue(decodeStreamChunk(parsed.data));
+        } catch {
+          this.abortClientStream(id, "Failed to deliver stream data.");
+        }
+        return;
+      }
+      case "stream_end": {
+        this.settleClientStream(id, { ok: true });
+        return;
+      }
+      case "stream_abort": {
+        const error = typeof parsed.error === "string" ? parsed.error : void 0;
+        this.settleClientStream(id, { ok: false, error: error ?? "Client aborted the stream." });
+        return;
+      }
+    }
+  }
+  /** Fail every stream bound to a socket that closed or died. */
+  failClientStreamsForSocket(ws) {
+    for (const [id, state] of Array.from(this.clientStreams.entries())) {
+      if (state.socket === ws) {
+        this.settleClientStream(id, { ok: false, error: "The client connection was lost." });
+      }
+    }
+  }
+  // ─── Parked-call wake + bounded TTL ────────────────────────────────────────
+  /** How long a parked forwarded call waits for a client before failing visibly. */
+  static CLIENT_PARK_TTL_MS = 30 * 60 * 1e3;
+  /**
+   * A forwarded call parked with NO client attached: ask the user's hub to
+   * summon the owning machine's daemon to this thread, and arm the bounded
+   * park TTL that turns an unreachable host into a visible durable failure
+   * instead of a silent hang.
+   */
+  async notifyClientWaiting(toolCallId, threadId, userId) {
+    try {
+      await this.alarmQueue.enqueue(
+        "clientParkTimeout",
+        { toolCallId, threadId },
+        _DurableThread.CLIENT_PARK_TTL_MS
+      );
+    } catch (error) {
+      console.error("[DurableThread] Failed to arm park TTL (non-fatal):", error);
+    }
+    if (!userId) return;
+    try {
+      const namespace = this.env.AGENT_BUILDER_USER_HUB;
+      if (!namespace) return;
+      const hub = namespace.get(namespace.idFromName(userId));
+      await hub.requestWake(threadId);
+    } catch (error) {
+      console.error("[DurableThread] Hub wake failed (non-fatal):", error);
+    }
+  }
+  /**
+   * Park TTL expired: if the call is still pending, settle it as a durable,
+   * VISIBLE failure — rewrite the waiting placeholder, mark the pending row
+   * failed, fail any still-pending assistant messages, and persist a durable
+   * failed assistant message so every connected head settles instead of
+   * showing "Working" forever.
+   */
+  async failParkedClientCall(toolCallId, threadId) {
+    await this.ensureMigrated();
+    await this.ensurePendingClientTable();
+    const cursor = await this.ctx.storage.sql.exec(
+      `SELECT status, tool FROM pending_client_calls WHERE tool_call_id = ? LIMIT 1`,
+      toolCallId
+    );
+    const row = cursor.toArray()[0];
+    if (!row || row.status !== "pending") return;
+    const errorText = "Could not reach your machine to run this operation. Reconnect it and retry.";
+    await this.ctx.storage.sql.exec(
+      `UPDATE pending_client_calls SET status = 'failed' WHERE tool_call_id = ?`,
+      toolCallId
+    );
+    await this.ctx.storage.sql.exec(
+      `UPDATE messages SET content = ?, tool_status = 'error' WHERE tool_call_id = ? AND role = 'tool'`,
+      `Error: ${errorText}`,
+      toolCallId
+    );
+    try {
+      const msgCursor = await this.ctx.storage.sql.exec(
+        `SELECT id, role, content, tool_call_id, tool_status, created_at, depth
+         FROM messages WHERE tool_call_id = ? AND role = 'tool' LIMIT 1`,
+        toolCallId
+      );
+      const msg = msgCursor.toArray()[0];
+      if (msg) this.broadcastMessage(msg);
+    } catch {
+    }
+    await this.settleTerminalFailure(errorText);
+    if (threadId) {
+      try {
+        await this.disarmExecutionWatchdog(threadId);
+      } catch {
+      }
+    }
+  }
   /**
    * Broadcast a log record to all connected WebSocket clients
    */
@@ -20174,6 +20779,10 @@ ${resultContent}${attachmentSummary}`;
           this.resolveClientCall(ws, parsed);
           return;
         }
+        if (parsed && typeof parsed.type === "string" && parsed.type.startsWith("stream_") && parsed.type !== "stream_ping" && parsed.type !== "stream_pong") {
+          this.handleClientStreamFrame(ws, parsed);
+          return;
+        }
       }
     } catch (error) {
       console.error("[DurableThread] Error handling WebSocket message:", error);
@@ -20194,6 +20803,7 @@ ${resultContent}${attachmentSummary}`;
       this.bridgeSockets.delete(ws);
       this.bridgeLastSeen.delete(ws);
       this.bridgeClientInfo.delete(ws);
+      this.failClientStreamsForSocket(ws);
       this.failPendingClientCallsIfNoBridge();
     }
   }
@@ -20215,6 +20825,7 @@ ${resultContent}${attachmentSummary}`;
       this.bridgeSockets.delete(ws);
       this.bridgeLastSeen.delete(ws);
       this.bridgeClientInfo.delete(ws);
+      this.failClientStreamsForSocket(ws);
       this.failPendingClientCallsIfNoBridge();
     }
   }
@@ -20532,6 +21143,11 @@ ${resultContent}${attachmentSummary}`;
         data: { id, is_complete: true, error, error_type: errorType }
       });
     }
+    try {
+      await this.failPendingMessagesAndBroadcast();
+    } catch (error2) {
+      console.error("[DurableThread] Failed to settle pending messages (non-fatal):", error2);
+    }
   }
   /**
    * A subagent whose execution the watchdog gave up on leaves its parent
@@ -23523,11 +24139,24 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
       throw new Error("User value user_id must be a non-empty string");
     }
   }
+  /**
+   * The per-user hub is the sharded home for account-wide KV. When the binding
+   * exists, the singleton delegates so the global object is no longer a
+   * per-user bottleneck; without it (pre-hub deploys, unit tests) it keeps the
+   * local `user_values` table.
+   */
+  userHub(userId) {
+    const namespace = this.env.AGENT_BUILDER_USER_HUB;
+    if (!namespace) return null;
+    return namespace.get(namespace.idFromName(userId));
+  }
   /** Read one JSON value from a user's account-wide key-value store. */
   async getUserValue(userId, key) {
     await this.ensureMigrated();
     this.assertValidUserValueUserId(userId);
     this.assertValidUserValueKey(key);
+    const hub = this.userHub(userId);
+    if (hub) return hub.getUserValue(userId, key);
     const cursor = await this.ctx.storage.sql.exec(
       `SELECT value FROM user_values WHERE user_id = ? AND key = ? LIMIT 1`,
       userId,
@@ -23548,6 +24177,8 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     await this.ensureMigrated();
     this.assertValidUserValueUserId(userId);
     this.assertValidUserValueKey(key);
+    const hub = this.userHub(userId);
+    if (hub) return hub.setUserValue(userId, key, value);
     if (value === null || value === void 0) {
       await this.ctx.storage.sql.exec(
         `DELETE FROM user_values WHERE user_id = ? AND key = ?`,
@@ -23584,6 +24215,8 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
   async listUserValues(userId, options = {}) {
     await this.ensureMigrated();
     this.assertValidUserValueUserId(userId);
+    const hub = this.userHub(userId);
+    if (hub) return hub.listUserValues(userId, options);
     const limit = Math.min(Math.max(Math.trunc(options.limit ?? 100), 1), 500);
     const offset = Math.max(Math.trunc(options.offset ?? 0), 0);
     const prefix = typeof options.prefix === "string" && options.prefix.length > 0 ? options.prefix : null;
@@ -25332,6 +25965,192 @@ function formatMs(ms) {
   const minutes = Math.floor(seconds / 60);
   return `${minutes}m${String(seconds % 60).padStart(2, "0")}s`;
 }
+var DurableUserHub = class extends DurableObject {
+  /** Persistent client (daemon) sockets, restored across hibernation. */
+  clientSockets = /* @__PURE__ */ new Set();
+  clientInfo = /* @__PURE__ */ new Map();
+  migrated = false;
+  constructor(ctx, env) {
+    super(ctx, env);
+    if (typeof WebSocketRequestResponsePair !== "undefined") {
+      ctx.setWebSocketAutoResponse(
+        new WebSocketRequestResponsePair("stream_ping", "stream_pong")
+      );
+    }
+    for (const ws of ctx.getWebSockets()) {
+      const attachment = ws.deserializeAttachment();
+      if (attachment?.type === "hub_client") {
+        this.clientSockets.add(ws);
+        this.clientInfo.set(ws, {
+          clientId: typeof attachment.clientId === "string" ? attachment.clientId : null,
+          clientName: typeof attachment.clientName === "string" ? attachment.clientName : null,
+          clientKind: typeof attachment.clientKind === "string" ? attachment.clientKind : null
+        });
+      }
+    }
+  }
+  ensureMigrated() {
+    if (this.migrated) return;
+    this.ctx.storage.sql.exec(`
+      CREATE TABLE IF NOT EXISTS user_values (
+        user_id TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (user_id, key)
+      )
+    `);
+    this.ctx.storage.sql.exec(
+      `CREATE INDEX IF NOT EXISTS idx_user_values_user ON user_values(user_id)`
+    );
+    this.migrated = true;
+  }
+  // ─── Persistent client socket ──────────────────────────────────────────────
+  /**
+   * Accept the user's persistent client (daemon) WebSocket. The daemon holds
+   * this ONE socket for its whole lifetime; per-thread bridge sockets are
+   * opened separately and only while a thread is active.
+   */
+  async fetch(request) {
+    const url = new URL(request.url);
+    if (request.headers.get("Upgrade") === "websocket") {
+      const pair = new WebSocketPair();
+      const [client, server] = [pair[0], pair[1]];
+      const info = {
+        clientId: url.searchParams.get("client_id"),
+        clientName: url.searchParams.get("client_name"),
+        clientKind: url.searchParams.get("client_kind")
+      };
+      this.ctx.acceptWebSocket(server);
+      server.serializeAttachment({ type: "hub_client", ...info });
+      this.clientSockets.add(server);
+      this.clientInfo.set(server, info);
+      try {
+        server.send(JSON.stringify({ type: "hub_ready" }));
+      } catch {
+      }
+      return new Response(null, { status: 101, webSocket: client });
+    }
+    return new Response("Not found", { status: 404 });
+  }
+  async webSocketMessage(ws, _message) {
+    if (!this.clientSockets.has(ws)) this.clientSockets.add(ws);
+  }
+  async webSocketClose(ws) {
+    this.clientSockets.delete(ws);
+    this.clientInfo.delete(ws);
+  }
+  async webSocketError(ws) {
+    this.clientSockets.delete(ws);
+    this.clientInfo.delete(ws);
+  }
+  /** Whether a persistent client (daemon) is connected right now. */
+  async hasClient() {
+    for (const ws of this.clientSockets) {
+      if (ws.readyState === WebSocket.OPEN) return true;
+    }
+    return false;
+  }
+  // ─── Wake orchestration (the load-bearing RPC) ─────────────────────────────
+  /**
+   * Signal the connected daemon to attach a bridge to `threadId`. Called by a
+   * cold thread DO that parked a forwarded call with no client attached. The
+   * daemon reacts by opening a per-thread bridge socket, which triggers the
+   * thread's drain-on-attach. Returns whether a daemon was reachable.
+   */
+  async requestWake(threadId) {
+    const frame = { type: "wake", threadId };
+    const payload = JSON.stringify(frame);
+    let delivered = false;
+    for (const ws of Array.from(this.clientSockets)) {
+      if (ws.readyState !== WebSocket.OPEN) {
+        this.clientSockets.delete(ws);
+        this.clientInfo.delete(ws);
+        continue;
+      }
+      try {
+        ws.send(payload);
+        delivered = true;
+      } catch {
+        this.clientSockets.delete(ws);
+        this.clientInfo.delete(ws);
+      }
+    }
+    return { delivered };
+  }
+  // ─── Account-wide KV (sharded off the singleton) ───────────────────────────
+  async getUserValue(userId, key) {
+    this.ensureMigrated();
+    const cursor = await this.ctx.storage.sql.exec(
+      `SELECT value FROM user_values WHERE user_id = ? AND key = ? LIMIT 1`,
+      userId,
+      key
+    );
+    const raw = cursor.toArray()[0]?.value;
+    if (raw === void 0) return null;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async setUserValue(userId, key, value) {
+    this.ensureMigrated();
+    if (value === null || value === void 0) {
+      await this.ctx.storage.sql.exec(
+        `DELETE FROM user_values WHERE user_id = ? AND key = ?`,
+        userId,
+        key
+      );
+      return;
+    }
+    const serialized = JSON.stringify(value);
+    const now = Date.now();
+    await this.ctx.storage.sql.exec(
+      `INSERT INTO user_values (user_id, key, value, created_at, updated_at)
+       VALUES (?1, ?2, ?3, ?4, ?4)
+       ON CONFLICT(user_id, key) DO UPDATE SET
+         value = excluded.value,
+         updated_at = excluded.updated_at`,
+      userId,
+      key,
+      serialized,
+      now
+    );
+  }
+  async listUserValues(userId, options = {}) {
+    this.ensureMigrated();
+    const limit = Math.min(Math.max(Math.trunc(options.limit ?? 100), 1), 500);
+    const offset = Math.max(Math.trunc(options.offset ?? 0), 0);
+    const prefix = typeof options.prefix === "string" && options.prefix.length > 0 ? options.prefix : null;
+    const escapedPrefix = prefix ? `${prefix.replace(/[\\%_]/g, (m) => `\\${m}`)}%` : null;
+    const where = escapedPrefix ? `WHERE user_id = ? AND key LIKE ? ESCAPE '\\'` : `WHERE user_id = ?`;
+    const whereArgs = escapedPrefix ? [userId, escapedPrefix] : [userId];
+    const totalCursor = await this.ctx.storage.sql.exec(
+      `SELECT COUNT(*) AS total FROM user_values ${where}`,
+      ...whereArgs
+    );
+    const total = Number(totalCursor.toArray()[0]?.total ?? 0);
+    const cursor = await this.ctx.storage.sql.exec(
+      `SELECT key, value, updated_at FROM user_values ${where}
+       ORDER BY key ASC LIMIT ? OFFSET ?`,
+      ...whereArgs,
+      limit,
+      offset
+    );
+    const entries = cursor.toArray().map((row) => {
+      let value = null;
+      try {
+        value = JSON.parse(row.value);
+      } catch {
+        value = null;
+      }
+      return { key: row.key, value, updated_at: Number(row.updated_at) };
+    });
+    return { entries, total, limit, offset };
+  }
+};
 
 // src/runtime.ts
 init_utilities();
@@ -25694,6 +26513,6 @@ init_context();
 init_ProviderRegistry();
 init_types2();
 
-export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, FlowStateSdk, NamespaceResolutionError, ProviderRegistry, ThreadWatchdog, authenticate, buildImageDescription, cat, createNamespaceContext, createThreadEndpointHandler, defineController2 as defineController, 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 };
+export { CodeExecutionBridge, DurableAgentBuilder, DurableThread, DurableUserHub, FlowStateSdk, NamespaceResolutionError, ProviderRegistry, ThreadWatchdog, authenticate, buildImageDescription, cat, createNamespaceContext, createThreadEndpointHandler, defineController2 as defineController, 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 };
 //# sourceMappingURL=runtime.js.map
 //# sourceMappingURL=runtime.js.map