@standardagents/builder 0.27.12 → 0.28.0

package/dist/built-in-routes.js

@@ -48,6 +48,26 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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 init_client_forwarding = __esm({
+  "src/agents/client-forwarding.ts"() {
+  }
+});
+
 // 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({
@@ -945,6 +965,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;
@@ -981,11 +1015,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;
       }
@@ -999,7 +1034,7 @@ var init_ProviderRegistry = __esm({
        * @param thread - Thread instance for loading model from virtual modules
        * @returns Provider and model definition
        */
-      async getProvider(modelName, env2, thread) {
+      async getProvider(modelName, env2, thread, getState) {
         if (!thread) {
           throw new Error("Thread instance required for model lookup");
         }
@@ -1032,6 +1067,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) {
@@ -1904,7 +1951,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;
@@ -4354,8 +4410,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(
@@ -6356,12 +6421,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 {
@@ -6415,10 +6482,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,
@@ -12220,6 +12304,10 @@ var init_code_execution = __esm({
 });
 
 // src/agents/ThreadStateImpl.ts
+var ThreadStateImpl_exports = {};
+__export(ThreadStateImpl_exports, {
+  ThreadStateImpl: () => ThreadStateImpl
+});
 function hasLocalCodeExecutionRuntime(threadInstance) {
   const candidate = threadInstance;
   return Boolean(candidate.env && candidate.ctx);
@@ -12400,6 +12488,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();
@@ -12984,9 +13073,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 {
@@ -12998,6 +13088,55 @@ var init_ThreadStateImpl = __esm({
         const local = await this._threadInstance.callClientTool(request);
         if (local.ok || !this.isNoClient(local)) return local;
         const env2 = this._threadInstance.env;
+        if (env2?.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 = env2.AGENT_BUILDER_THREAD.get(env2.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 env2 = this._threadInstance.env;
         if (!env2?.AGENT_BUILDER_THREAD) return local;
         const seen = /* @__PURE__ */ new Set([this._metadata.id]);
         let parentId = await this.resolveParentThreadId(this._metadata.id);
@@ -13005,14 +13144,86 @@ var init_ThreadStateImpl = __esm({
           seen.add(parentId);
           try {
             const stub = env2.AGENT_BUILDER_THREAD.get(env2.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;
       }
@@ -43229,11 +43440,13 @@ var init_dist6 = __esm({
         if (!this.client) {
           const { default: OpenAI } = await import('openai');
           const defaultHeaders = this.config.defaultHeaders;
+          const fetchOverride = this.config.fetch;
           this.client = new OpenAI({
             apiKey: this.config.apiKey,
             baseURL: this.config.baseUrl,
             timeout: this.config.timeout,
-            ...defaultHeaders ? { defaultHeaders } : {}
+            ...defaultHeaders ? { defaultHeaders } : {},
+            ...fetchOverride ? { fetch: fetchOverride } : {}
           });
         }
         return this.client;
@@ -43658,26 +43871,26 @@ var init_dist6 = __esm({
           const status = anyError.status || anyError.statusCode;
           const retryAfter = anyError.headers?.["retry-after"] ? parseInt(anyError.headers["retry-after"], 10) : void 0;
           if (status === 429) {
-            return new ProviderError(error.message, "rate_limit", status, retryAfter);
+            return new ProviderError(error.message, "rate_limit", status, retryAfter, { cause: error });
           }
           if (status === 403 && _OpenAIProvider.isEdgeBlock(anyError)) {
-            return new ProviderError(error.message, "server_error", status, retryAfter ?? 3);
+            return new ProviderError(error.message, "server_error", status, retryAfter ?? 3, { cause: error });
           }
           if (status === 401 || status === 403) {
-            return new ProviderError(error.message, "auth_error", status);
+            return new ProviderError(error.message, "auth_error", status, void 0, { cause: error });
           }
           if (status === 400) {
-            return new ProviderError(error.message, "invalid_request", status);
+            return new ProviderError(error.message, "invalid_request", status, void 0, { cause: error });
           }
           if (status >= 500) {
-            return new ProviderError(error.message, "server_error", status);
+            return new ProviderError(error.message, "server_error", status, void 0, { cause: error });
           }
           if (error.name === "AbortError" || anyError.code === "ETIMEDOUT") {
-            return new ProviderError(error.message, "timeout");
+            return new ProviderError(error.message, "timeout", void 0, void 0, { cause: error });
           }
-          return new ProviderError(error.message, "unknown", status);
+          return new ProviderError(error.message, "unknown", status, void 0, { cause: error });
         }
-        return new ProviderError(String(error), "unknown");
+        return new ProviderError(String(error), "unknown", void 0, void 0, { cause: error });
       }
       // ============================================================================
       // Inspection
@@ -66291,7 +66504,7 @@ var config_get_default = defineController2(async ({ config, env: env2, req }) =>
 });
 
 // src/version.ts
-var BUILDER_VERSION = "0.27.12".length > 0 ? "0.27.12" : "dev";
+var BUILDER_VERSION = "0.28.0".length > 0 ? "0.28.0" : "dev";
 
 // src/api/diagnostics.get.ts
 init_LLMRequest();
@@ -72200,6 +72413,44 @@ var env_patch_default2 = defineController2(async ({ req, env: env2 }) => {
   }
 });
 
+// src/api/users/me/hub.ts
+var hub_default = defineController2(async ({ req, env: env2 }) => {
+  const authResult = await requireAuth(req, env2);
+  if (authResult instanceof Response) {
+    return authResult;
+  }
+  if (authResult.authType === "super_admin") {
+    return Response.json(
+      { error: "Super admin sessions have no per-user hub. Sign in as a user account." },
+      { status: 400 }
+    );
+  }
+  if (req.headers.get("upgrade")?.toLowerCase() !== "websocket") {
+    return Response.json(
+      { error: "This endpoint only supports WebSocket connections" },
+      { status: 400 }
+    );
+  }
+  const namespace = env2.AGENT_BUILDER_USER_HUB;
+  if (!namespace) {
+    return Response.json(
+      { error: "The per-user hub is not available on this runtime" },
+      { status: 500 }
+    );
+  }
+  try {
+    const hubId = namespace.idFromName(authResult.user.id);
+    const stub = namespace.get(hubId);
+    return await stub.fetch(req);
+  } catch (error) {
+    console.error("Error establishing user hub socket:", error);
+    return Response.json(
+      { error: error.message || "Failed to establish hub connection" },
+      { status: 500 }
+    );
+  }
+});
+
 // src/api/users/me/kv/index.delete.ts
 var index_delete_default = defineController2(async ({ req, env: env2 }) => {
   try {
@@ -73558,6 +73809,7 @@ var routeHandlers = {
   "GET:/auth/sa/start": start_get_default,
   "GET:/users/me/env": env_get_default2,
   "PATCH:/users/me/env": env_patch_default2,
+  "GET:/users/me/hub": hub_default,
   "DELETE:/users/me/kv": index_delete_default,
   "GET:/users/me/kv": index_get_default4,
   "POST:/users/me/kv": index_post_default8,