@standardagents/builder 0.28.0 → 0.29.0

package/dist/built-in-routes.js

@@ -49,6 +49,39 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/agents/client-forwarding.ts
+function createRuntimeStreams(openClientStream) {
+  return {
+    async open(request) {
+      const opened = await openClientStream({
+        tool: request.capability,
+        meta: request.metadata,
+        timeoutMs: request.timeoutMs
+      });
+      if (!opened.ok) {
+        const failureData = opened.data;
+        return {
+          ok: false,
+          error: opened.error,
+          code: failureData?.code
+        };
+      }
+      let closed = false;
+      return {
+        ok: true,
+        stream: {
+          readable: opened.duplex.readable,
+          writable: opened.duplex.writable,
+          closed: opened.duplex.done,
+          close: (reason) => {
+            if (closed) return;
+            closed = true;
+            opened.duplex.close(reason);
+          }
+        }
+      };
+    }
+  };
+}
 function encodeStreamChunk(bytes) {
   let binary = "";
   const step = 32768;
@@ -12544,6 +12577,14 @@ var init_ThreadStateImpl = __esm({
         }
         return this.getMetadataArguments();
       }
+      /**
+       * Optional spec byte streams backed by the execution owner's existing
+       * bridge. Streams are live resources: they proxy through ancestors when a
+       * subagent opens one, but they never park or outlive a bridge disconnect.
+       */
+      get runtimeStreams() {
+        return createRuntimeStreams((request) => this.callClientStream(request));
+      }
       getMetadataArguments() {
         const value = this._metadata.properties?.[SUBAGENT_INITIAL_ARGUMENTS_THREAD_PROPERTY];
         if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -13120,11 +13161,9 @@ var init_ThreadStateImpl = __esm({
         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).
+       * Legacy bridge implementation used by `runtimeStreams`. Streams require a
+       * live execution owner and never park. A child thread proxies the complete
+       * request to the nearest bridge-holding ancestor (request-up/stream-down).
        */
       async callClientStream(request) {
         const instance = this._threadInstance;
@@ -13150,7 +13189,11 @@ var init_ThreadStateImpl = __esm({
                 return { ok: true, duplex: this.buildProxyDuplex(stub, opened.id) };
               }
               if (opened.error && !opened.noClient) {
-                return { ok: false, error: opened.error };
+                return {
+                  ok: false,
+                  error: opened.error,
+                  data: opened.code ? { code: opened.code } : void 0
+                };
               }
             }
           } catch {
@@ -13169,6 +13212,12 @@ var init_ThreadStateImpl = __esm({
         let settleDone;
         const done = new Promise((r) => settleDone = r);
         let closed = false;
+        let settled = false;
+        const settle = (result) => {
+          if (settled) return;
+          settled = true;
+          settleDone(result);
+        };
         const readable = new ReadableStream({
           async pull(controller) {
             while (!closed) {
@@ -13177,7 +13226,7 @@ var init_ThreadStateImpl = __esm({
                 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" });
+                settle({ ok: false, error: "proxy stream pull failed" });
                 return;
               }
               for (const chunk of res.chunks) {
@@ -13185,7 +13234,7 @@ var init_ThreadStateImpl = __esm({
               }
               if (res.done) {
                 controller.close();
-                settleDone(res.error ? { ok: false, error: res.error } : { ok: true });
+                settle(res.error ? { ok: false, error: res.error } : { ok: true });
                 return;
               }
               if (res.chunks.length > 0) return;
@@ -13196,6 +13245,7 @@ var init_ThreadStateImpl = __esm({
             closed = true;
             void stub.proxyStreamAbort(id).catch(() => {
             });
+            settle({ ok: false, error: "proxy stream reader canceled" });
           }
         });
         const writable = new WritableStream({
@@ -13210,16 +13260,18 @@ var init_ThreadStateImpl = __esm({
             closed = true;
             void stub.proxyStreamAbort(id).catch(() => {
             });
+            settle({ ok: false, error: "proxy stream writer aborted" });
           }
         });
         return {
           readable,
           writable,
           close: (error) => {
+            if (closed) return;
             closed = true;
             void stub.proxyStreamAbort(id).catch(() => {
             });
-            settleDone(error ? { ok: false, error } : { ok: true });
+            settle(error ? { ok: false, error } : { ok: true });
           },
           done
         };
@@ -66504,7 +66556,7 @@ var config_get_default = defineController2(async ({ config, env: env2, req }) =>
 });
 
 // src/version.ts
-var BUILDER_VERSION = "0.28.0".length > 0 ? "0.28.0" : "dev";
+var BUILDER_VERSION = "0.29.0".length > 0 ? "0.29.0" : "dev";
 
 // src/api/diagnostics.get.ts
 init_LLMRequest();