@standardagents/builder 0.29.1 → 0.30.0

package/dist/built-in-routes.js

@@ -13126,7 +13126,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 env2 = this._threadInstance.env;
         if (env2?.AGENT_BUILDER_THREAD) {
@@ -13676,10 +13679,35 @@ var init_ThreadStateImpl = __esm({
         return { parentThreadId, parentStub };
       }
       _getAgentBuilderStub() {
-        const env2 = this._threadInstance.env;
+        const env2 = this._getRuntimeEnv();
         const agentBuilderId = env2.AGENT_BUILDER.idFromName("singleton");
         return env2.AGENT_BUILDER.get(agentBuilderId);
       }
+      /**
+       * Environment bindings for this state. In-DO construction uses the thread
+       * instance's own env; stub-backed states (thread endpoints, the user
+       * scope's `thread()`) have no `instance.env` over RPC and use the env the
+       * dispatcher recorded in the runtime context instead.
+       */
+      _getRuntimeEnv() {
+        const instanceEnv = this._threadInstance.env;
+        const env2 = instanceEnv?.AGENT_BUILDER ? instanceEnv : this._runtimeContext.env;
+        if (!env2?.AGENT_BUILDER) {
+          throw new Error(
+            "No runtime environment available on this ThreadState. Stub-backed states must be constructed with runtimeContext.env."
+          );
+        }
+        return env2;
+      }
+      /** The per-user hub stub for this thread's user (user-scope surfaces). */
+      _getUserHubStub(userId) {
+        const env2 = this._getRuntimeEnv();
+        const namespace = env2.AGENT_BUILDER_USER_HUB;
+        if (!namespace) {
+          throw new Error("User scope unavailable: AGENT_BUILDER_USER_HUB binding is missing.");
+        }
+        return namespace.get(namespace.idFromName(userId));
+      }
       // ─────────────────────────────────────────────────────────────────────────
       // Skills — instance-global Agent Skills library, backed by the
       // DurableAgentBuilder singleton (skills are never stored per-thread or on
@@ -13696,7 +13724,67 @@ var init_ThreadStateImpl = __esm({
         const stub = this._getAgentBuilderStub();
         const user = await stub.getUserById(userId).catch(() => null);
         if (!user) return null;
+        const inUserScope = this._runtimeContext.inUserScope === true;
+        const agentId = this._metadata.agent_id;
+        const hub = () => this._getUserHubStub(userId);
+        const capabilities = {
+          call: async (endpoint, payload) => {
+            if (inUserScope) {
+              throw new Error(
+                "Reentrant user-scope call: this ThreadState was raised from user-scope code; state.user().call() is unavailable here."
+              );
+            }
+            const path9 = endpoint.replace(/^\/+/, "");
+            return hub().fetch(
+              new Request(`https://user-hub/users/${encodeURIComponent(userId)}/endpoints/${path9}`, {
+                method: "POST",
+                headers: {
+                  "Content-Type": "application/json",
+                  // Runtime-internal caller channel — the public routes overwrite
+                  // this header, so only thread-scope code can present "thread".
+                  "X-Standard-Agents-Caller": "thread"
+                },
+                body: payload === void 0 ? void 0 : JSON.stringify(payload)
+              })
+            );
+          },
+          getValue: async (key) => {
+            return await stub.getUserValue?.(userId, key);
+          },
+          setValue: async (key, value) => {
+            await stub.setUserValue?.(userId, key, value);
+          },
+          emit: (event, data) => {
+            const delivery = hub().broadcastUserEvent(userId, event, data).catch(() => {
+            });
+            this._pendingEventDeliveries.add(delivery);
+            void delivery.finally(
+              () => this._pendingEventDeliveries.delete(delivery)
+            );
+          },
+          fetch: async (grant, input, init) => {
+            const body = init?.body;
+            if (body !== void 0 && body !== null && typeof body !== "string") {
+              throw new Error("Grant fetch bodies must be strings in this runtime.");
+            }
+            return hub().fetch(
+              new Request(`https://user-hub/users/${encodeURIComponent(userId)}/grant-fetch`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                  grant,
+                  url: String(input),
+                  method: init?.method ?? "GET",
+                  headers: init?.headers ? Object.fromEntries(new Headers(init.headers)) : {},
+                  body: body ?? null,
+                  caller: { kind: "agent", name: agentId }
+                })
+              })
+            );
+          }
+        };
         return {
+          ...capabilities,
           id: user.id,
           username: user.username,
           role: user.role,
@@ -66558,7 +66646,7 @@ var config_get_default = defineController2(async ({ config, env: env2, req }) =>
 });
 
 // src/version.ts
-var BUILDER_VERSION = "0.29.1".length > 0 ? "0.29.1" : "dev";
+var BUILDER_VERSION = "0.30.0".length > 0 ? "0.30.0" : "dev";
 
 // src/api/diagnostics.get.ts
 init_LLMRequest();
@@ -72109,6 +72197,48 @@ var analyze_get_default2 = defineController2(async ({ req }) => {
   }
 });
 
+// src/users/dispatch.ts
+function userHubStub(env2, userId) {
+  const namespace = env2.AGENT_BUILDER_USER_HUB;
+  if (!namespace) return null;
+  return namespace.get(namespace.idFromName(userId));
+}
+async function forwardToUserScope(req, env2, userId, scopePath, channel = "user") {
+  const stub = userHubStub(env2, userId);
+  if (!stub) {
+    return Response.json(
+      { error: "The user scope is not available on this runtime" },
+      { status: 500 }
+    );
+  }
+  const source = new URL(req.url);
+  const target = new URL(
+    `https://user-hub/users/${encodeURIComponent(userId)}/${scopePath}`
+  );
+  target.search = source.search;
+  const forwarded = new Request(target.toString(), req);
+  forwarded.headers.set("X-Standard-Agents-Caller", channel);
+  return stub.fetch(forwarded);
+}
+
+// src/api/users/[id]/[...rest].ts
+var rest_default = defineController2(async ({ req, env: env2, params }) => {
+  const authResult = await requireAuth(req, env2);
+  if (authResult instanceof Response) return authResult;
+  const isAdmin = authResult.authType === "super_admin" || authResult.user?.role === "admin";
+  if (!isAdmin) {
+    return Response.json({ error: "Administrator access required" }, { status: 403 });
+  }
+  const rest = params._ ?? params.rest ?? params["*"] ?? "";
+  return forwardToUserScope(
+    req,
+    env2,
+    params.id,
+    `endpoints/${rest}`,
+    "admin"
+  );
+});
+
 // src/api/users/[id]/env.get.ts
 var env_get_default = defineController2(async ({ req, env: env2, params }) => {
   try {
@@ -72180,6 +72310,23 @@ var env_patch_default = defineController2(async ({ req, env: env2, params }) =>
   }
 });
 
+// src/api/users/[id]/stream.ts
+var stream_default2 = defineController2(async ({ req, env: env2, params }) => {
+  const authResult = await requireAuth(req, env2);
+  if (authResult instanceof Response) return authResult;
+  const isAdmin = authResult.authType === "super_admin" || authResult.user?.role === "admin";
+  if (!isAdmin) {
+    return Response.json({ error: "Administrator access required" }, { status: 403 });
+  }
+  if (req.headers.get("upgrade")?.toLowerCase() !== "websocket") {
+    return Response.json(
+      { error: "This endpoint only supports WebSocket connections" },
+      { status: 426 }
+    );
+  }
+  return forwardToUserScope(req, env2, params.id, "stream", "admin");
+});
+
 // src/api/variables/agents/[name].get.ts
 var name_get_default6 = defineController2(async ({ params, url, prompts, agents, tools, models, env: env2, req }) => {
   const agentName = params.name ? decodeURIComponent(params.name) : "";
@@ -72400,6 +72547,25 @@ var start_get_default = defineController2(async ({ req, env: env2 }) => {
   });
 });
 
+// src/api/users/me/[...rest].ts
+var rest_default2 = defineController2(async ({ req, env: env2, params }) => {
+  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 user scope. Sign in as a user account." },
+      { status: 400 }
+    );
+  }
+  const rest = params._ ?? params.rest ?? params["*"] ?? "";
+  return forwardToUserScope(
+    req,
+    env2,
+    authResult.user.id,
+    `endpoints/${rest}`
+  );
+});
+
 // src/api/users/me/env.get.ts
 var env_get_default2 = defineController2(async ({ req, env: env2 }) => {
   try {
@@ -72638,6 +72804,25 @@ var index_post_default8 = defineController2(async ({ req, env: env2 }) => {
   }
 });
 
+// src/api/users/me/stream.ts
+var stream_default3 = 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 user scope. 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: 426 }
+    );
+  }
+  return forwardToUserScope(req, env2, authResult.user.id, "stream");
+});
+
 // src/api/auth/device/[code]/approve.get.ts
 function page(title, body, ok) {
   return new Response(
@@ -73853,20 +74038,24 @@ var routeHandlers = {
   "GET:/threads/:id/subagents": subagents_get_default,
   "POST:/threads/:id/tool-result": tool_result_post_default,
   "GET:/unpack/:packageId/analyze": analyze_get_default2,
+  "GET:/users/:id/**": rest_default,
   "GET:/users/:id/env": env_get_default,
   "PATCH:/users/:id/env": env_patch_default,
+  "GET:/users/:id/stream": stream_default2,
   "GET:/variables/agents/:name": name_get_default6,
   "GET:/variables/prompts/:name": name_get_default7,
   "GET:/variables/tools/:name": name_get_default8,
   "POST:/auth/device/start": start_post_default,
   "GET:/auth/sa/callback": callback_get_default,
   "GET:/auth/sa/start": start_get_default,
+  "GET:/users/me/**": rest_default2,
   "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,
+  "GET:/users/me/stream": stream_default3,
   "GET:/auth/device/:code/approve": approve_get_default,
   "GET:/skills/:name/files/**": path_get_default,
   "DELETE:/threads/:id/fs/**": path_default3,