@standardagents/builder 0.40.5-next.3b25e2a → 0.40.6

package/dist/runtime.js

@@ -1,11 +1,13 @@
 import { getProviderModelPricing } from '@standardagents/provider-pricing';
 import { jsonPathReader } from '@formkit/jsonreader';
 import { ProviderError, mapReasoningLevel, THREAD_STREAM_REASONING_PARAM, isUserEndpoint } from '@standardagents/spec';
-export { ProviderError, belongsToPackage, defineAgent, defineHook, defineModel, definePrompt, defineTool, isPacked, isVisibleInNamespace, mapReasoningLevel } from '@standardagents/spec';
+export { ProviderError, belongsToPackage, defineAgent, defineHook, defineModel, definePrompt, defineProvider, defineTool, isPacked, isVisibleInNamespace, mapReasoningLevel, providerConst, providerEnv, providerValue } from '@standardagents/spec';
 import 'virtual:@standardagents-providers';
 import { z } from 'zod';
 import { transform, collect } from '@standardagents/sip';
 import { DurableObject, WorkerEntrypoint } from 'cloudflare:workers';
+import 'fs';
+import 'path';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -454,8 +456,8 @@ async function readCompletedArg(partialJson, argName) {
         controller.close();
       }
     }).getReader();
-    for await (const [value, path] of jsonPathReader(reader, [argName])) {
-      if (path === argName) {
+    for await (const [value, path2] of jsonPathReader(reader, [argName])) {
+      if (path2 === argName) {
         return typeof value === "string" ? value : void 0;
       }
     }
@@ -1535,11 +1537,11 @@ function stripBase64FromMessages(messages, imagePathMap) {
             const data = part.data;
             if (typeof data === "string") {
               if (data.startsWith("data:") || data.length > 1e3) {
-                const path = imagePathMap?.get(data);
+                const path2 = imagePathMap?.get(data);
                 return {
                   ...part,
                   data: "[base64 omitted]",
-                  ...path ? { path } : {}
+                  ...path2 ? { path: path2 } : {}
                 };
               }
             }
@@ -2105,14 +2107,14 @@ 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 providerEnv2 = await ProviderRegistry2.buildThreadScopedEnv(state);
         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,
+          providerEnv2,
           state.thread.instance,
           getThreadState
         );
@@ -2755,11 +2757,11 @@ var init_LLMRequest = __esm({
               ...choice.message,
               images: choice.message?.images?.map(
                 (img) => {
-                  const path = img._id ? imagePathMap.get(img._id) : void 0;
-                  if (path) {
+                  const path2 = img._id ? imagePathMap.get(img._id) : void 0;
+                  if (path2) {
                     return {
                       type: img.type,
-                      image_url: { url: path }
+                      image_url: { url: path2 }
                     };
                   }
                   return img;
@@ -3286,20 +3288,20 @@ function detectStorageBackend(location) {
     return "url";
   return "local";
 }
-function basename(path) {
-  const parts = path.split("/").filter(Boolean);
+function basename(path2) {
+  const parts = path2.split("/").filter(Boolean);
   return parts[parts.length - 1] || "";
 }
-function normalizePath(path) {
-  let normalized = path.replace(/\/+/g, "/");
+function normalizePath(path2) {
+  let normalized = path2.replace(/\/+/g, "/");
   if (!normalized.startsWith("/")) normalized = "/" + normalized;
   if (normalized.length > 1 && normalized.endsWith("/")) {
     normalized = normalized.slice(0, -1);
   }
   return normalized;
 }
-function dirname(path) {
-  const normalized = normalizePath(path);
+function dirname(path2) {
+  const normalized = normalizePath(path2);
   const lastSlash = normalized.lastIndexOf("/");
   if (lastSlash <= 0) return "/";
   return normalized.slice(0, lastSlash);
@@ -3317,7 +3319,7 @@ function validateMovePaths(source, destination, isDirectory) {
     );
   }
 }
-function resolveRenameDestination(path, newName) {
+function resolveRenameDestination(path2, newName) {
   if (typeof newName !== "string" || newName.length === 0) {
     throw new Error("New name must be a non-empty string");
   }
@@ -3327,7 +3329,7 @@ function resolveRenameDestination(path, newName) {
   if (newName === "." || newName === "..") {
     throw new Error("New name must not be '.' or '..'");
   }
-  const normalized = normalizePath(path);
+  const normalized = normalizePath(path2);
   const parent = dirname(normalized);
   return parent === "/" ? `/${newName}` : `${parent}/${newName}`;
 }
@@ -3451,8 +3453,8 @@ var init_files = __esm({
        * Write a file to storage.
        * Files > CHUNK_SIZE are automatically chunked into file_chunks table.
        */
-      async writeFile(path, data, mimeType, options) {
-        const normalizedPath = normalizePath(path);
+      async writeFile(path2, data, mimeType, options) {
+        const normalizedPath = normalizePath(path2);
         const name = basename(normalizedPath);
         const isText = isTextMimeType(mimeType);
         const now = Date.now();
@@ -3564,8 +3566,8 @@ var init_files = __esm({
       /**
        * Link to an external file (URL, S3, R2)
        */
-      async linkFile(path, location, options) {
-        const normalizedPath = normalizePath(path);
+      async linkFile(path2, location, options) {
+        const normalizedPath = normalizePath(path2);
         const name = basename(normalizedPath);
         const storage = detectStorageBackend(location);
         const now = Date.now();
@@ -3604,8 +3606,8 @@ var init_files = __esm({
        * WARNING: For large chunked files, this loads the entire file into memory.
        * Use streamFile() for memory-efficient access to large files.
        */
-      async readFile(path) {
-        const normalizedPath = normalizePath(path);
+      async readFile(path2) {
+        const normalizedPath = normalizePath(path2);
         const cursor = await this.sql.exec(
           `SELECT data, content, storage, is_chunked, chunk_count FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3657,8 +3659,8 @@ var init_files = __esm({
        * Memory-efficient way to read large chunked files.
        * Yields one chunk at a time for streaming HTTP responses.
        */
-      async *streamFile(path) {
-        const normalizedPath = normalizePath(path);
+      async *streamFile(path2) {
+        const normalizedPath = normalizePath(path2);
         const cursor = await this.sql.exec(
           `SELECT data, content, storage, is_chunked, chunk_count FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3692,8 +3694,8 @@ var init_files = __esm({
       /**
        * Read text file content
        */
-      async readTextFile(path) {
-        const normalizedPath = normalizePath(path);
+      async readTextFile(path2) {
+        const normalizedPath = normalizePath(path2);
         const cursor = await this.sql.exec(
           `SELECT content, data, storage FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3711,8 +3713,8 @@ var init_files = __esm({
       /**
        * Get file metadata (stat)
        */
-      async stat(path) {
-        const normalizedPath = normalizePath(path);
+      async stat(path2) {
+        const normalizedPath = normalizePath(path2);
         const cursor = await this.sql.exec(
           `SELECT path, name, mime_type, storage, location, size, metadata, is_directory, created_at, width, height, is_chunked, chunk_count
        FROM files WHERE path = ?`,
@@ -3725,8 +3727,8 @@ var init_files = __esm({
       /**
        * Check if file or directory exists
        */
-      async exists(path) {
-        const normalizedPath = normalizePath(path);
+      async exists(path2) {
+        const normalizedPath = normalizePath(path2);
         const cursor = await this.sql.exec(
           `SELECT COUNT(*) as count FROM files WHERE path = ?`,
           normalizedPath
@@ -3736,8 +3738,8 @@ var init_files = __esm({
       /**
        * Delete a file
        */
-      async unlink(path) {
-        const normalizedPath = normalizePath(path);
+      async unlink(path2) {
+        const normalizedPath = normalizePath(path2);
         await this.sql.exec(
           `DELETE FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -3747,8 +3749,8 @@ var init_files = __esm({
       /**
        * Create a directory marker
        */
-      async mkdir(path) {
-        const normalizedPath = normalizePath(path);
+      async mkdir(path2) {
+        const normalizedPath = normalizePath(path2);
         const name = basename(normalizedPath);
         const now = Date.now();
         await this.sql.exec(
@@ -3773,8 +3775,8 @@ var init_files = __esm({
       /**
        * List directory contents
        */
-      async readdir(path) {
-        const normalizedPath = normalizePath(path);
+      async readdir(path2) {
+        const normalizedPath = normalizePath(path2);
         const prefix = normalizedPath === "/" ? "/" : normalizedPath + "/";
         const cursor = await this.sql.exec(
           `SELECT path, name, mime_type, storage, location, size, metadata, is_directory, created_at
@@ -3792,8 +3794,8 @@ var init_files = __esm({
       /**
        * Remove empty directory
        */
-      async rmdir(path) {
-        const normalizedPath = normalizePath(path);
+      async rmdir(path2) {
+        const normalizedPath = normalizePath(path2);
         const prefix = normalizedPath + "/";
         const cursor = await this.sql.exec(
           `SELECT COUNT(*) as count FROM files WHERE path LIKE ? || '%'`,
@@ -3891,9 +3893,9 @@ var init_files = __esm({
        * Rename a file or directory in place, keeping it in the same parent
        * directory. `newName` must be a bare file name with no path separators.
        */
-      async rename(path, newName) {
-        const destination = resolveRenameDestination(path, newName);
-        return this.move(normalizePath(path), destination);
+      async rename(path2, newName) {
+        const destination = resolveRenameDestination(path2, newName);
+        return this.move(normalizePath(path2), destination);
       }
       /**
        * Get storage statistics
@@ -3923,8 +3925,8 @@ var init_files = __esm({
       /**
        * Get thumbnail for an image
        */
-      async getThumbnail(path) {
-        const normalizedPath = normalizePath(path);
+      async getThumbnail(path2) {
+        const normalizedPath = normalizePath(path2);
         const cursor = await this.sql.exec(
           `SELECT thumbnail FROM files WHERE path = ? AND is_directory = 0`,
           normalizedPath
@@ -4375,8 +4377,8 @@ var init_ToolExecutor = __esm({
             const validation = argsSchema.safeParse(args);
             if (!validation.success) {
               const errorMessage = validation.error.issues.map((issue) => {
-                const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
-                return `[${path}] ${issue.message}`;
+                const path2 = issue.path.length > 0 ? issue.path.map(String).join(".") : "root";
+                return `[${path2}] ${issue.message}`;
               }).join("; ");
               return {
                 status: "error",
@@ -5074,9 +5076,7 @@ Message one with subagent_message(referenceId, message).`
             if (resumable) {
               await this.settleResumableChildAfterRun(
                 state,
-                stub,
-                childThreadId,
-                childResult
+                childThreadId
               );
             } else if (stub.terminateThread) {
               await stub.terminateThread(childThreadId);
@@ -5088,7 +5088,7 @@ Message one with subagent_message(referenceId, message).`
               attachments: copiedAttachments,
               subagent_id: childThreadId
             };
-            return resumable && !this.isTerminalSubagentResult(childResult) ? this.withReferenceInToolResult(toolResult, childThreadId) : toolResult;
+            return resumable ? this.withReferenceInToolResult(toolResult, childThreadId) : toolResult;
           }
           const backgroundRun = (async () => {
             try {
@@ -5123,9 +5123,7 @@ Message one with subagent_message(referenceId, message).`
               if (resumable) {
                 await this.settleResumableChildAfterRun(
                   state,
-                  stub,
-                  childThreadId,
-                  childResult
+                  childThreadId
                 );
               } else if (stub.terminateThread) {
                 await stub.terminateThread(childThreadId);
@@ -5374,13 +5372,13 @@ Message one with subagent_message(referenceId, message).`
             new Set(
               issues.map(
                 (issue) => Array.isArray(issue.path) ? issue.path.map(String).join(".") : String(issue.path ?? "")
-              ).filter((path) => path.length > 0)
+              ).filter((path2) => path2.length > 0)
             )
           );
           const detail = issues.map((issue) => {
-            const path = Array.isArray(issue.path) ? issue.path.map(String).join(".") : "";
+            const path2 = Array.isArray(issue.path) ? issue.path.map(String).join(".") : "";
             const message = typeof issue.message === "string" ? issue.message : "invalid value";
-            return path ? `${path}: ${message}` : message;
+            return path2 ? `${path2}: ${message}` : message;
           }).join("; ") || parsed.error.message || "invalid arguments";
           const agentLabel = agentDef.title || agentDef.name || options.agentName || qualifiedPromptName;
           return {
@@ -5520,18 +5518,8 @@ Message one with subagent_message(referenceId, message).`
           JSON.stringify(next)
         );
       }
-      static isTerminalSubagentResult(result) {
-        return result.terminal === true;
-      }
-      static async settleResumableChildAfterRun(state, childThread, reference, result) {
-        if (!this.isTerminalSubagentResult(result)) {
-          await this.updateChildStatus(state, reference, "idle");
-          return;
-        }
-        await this.updateChildStatus(state, reference, "terminated");
-        if (typeof childThread.terminateThread === "function") {
-          await childThread.terminateThread(reference);
-        }
+      static async settleResumableChildAfterRun(state, reference) {
+        await this.updateChildStatus(state, reference, "idle");
       }
       static async buildChildInvocationMessages(state, childThread, content, receivesMessages, parentAttachments, initialArguments) {
         const copiedAttachments = await this.copyAttachmentsBetweenThreads(
@@ -5739,8 +5727,8 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         }
         return [];
       }
-      static inferMimeTypeFromPath(path) {
-        const normalized = path.toLowerCase();
+      static inferMimeTypeFromPath(path2) {
+        const normalized = path2.toLowerCase();
         if (normalized.endsWith(".png")) return "image/png";
         if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) return "image/jpeg";
         if (normalized.endsWith(".webp")) return "image/webp";
@@ -5779,7 +5767,7 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
           ext: value.slice(lastDot + 1).toLowerCase()
         };
       }
-      static resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path) {
+      static resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path2) {
         const source = sourceMimeType?.trim();
         if (source && source !== "application/octet-stream") {
           return source;
@@ -5788,7 +5776,7 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         if (fallback && fallback !== "application/octet-stream") {
           return fallback;
         }
-        return this.inferMimeTypeFromPath(path) ?? source ?? fallback ?? "application/octet-stream";
+        return this.inferMimeTypeFromPath(path2) ?? source ?? fallback ?? "application/octet-stream";
       }
       static buildAttachmentTargetPath(preferredName, mimeType, sourcePath) {
         const safeName = this.sanitizeFilename(preferredName);
@@ -5885,8 +5873,8 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         }
         return copied;
       }
-      static async readAttachmentDataFromSource(sourceThread, path, sourceFile, allowedAttachmentFetchHosts) {
-        const sourceData = await sourceThread.readFile(path);
+      static async readAttachmentDataFromSource(sourceThread, path2, sourceFile, allowedAttachmentFetchHosts) {
+        const sourceData = await sourceThread.readFile(path2);
         if (sourceData.success && sourceData.data) {
           return sourceData.data;
         }
@@ -5923,7 +5911,7 @@ Reference: ${referenceId}` : `Reference: ${referenceId}`;
         if (!attachments || attachments.length === 0) {
           return "";
         }
-        const paths = attachments.map((attachment) => attachment.path).filter((path) => typeof path === "string" && path.length > 0);
+        const paths = attachments.map((attachment) => attachment.path).filter((path2) => typeof path2 === "string" && path2.length > 0);
         if (paths.length === 0) {
           return "";
         }
@@ -6220,7 +6208,7 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
                   mappedAttachmentValue
                 );
                 const resolvedPaths = new Set(mappedRefs.map((ref) => ref.path));
-                const missingPaths = candidatePaths.filter((path) => !resolvedPaths.has(path));
+                const missingPaths = candidatePaths.filter((path2) => !resolvedPaths.has(path2));
                 if (candidatePaths.length === 0 || missingPaths.length > 0) {
                   processedResult = {
                     status: "error",
@@ -6402,8 +6390,8 @@ ${attachmentPaths}`;
           if (mimeType.startsWith("image/")) {
             return true;
           }
-          const path = ref.path.toLowerCase();
-          return path.endsWith(".png") || path.endsWith(".jpg") || path.endsWith(".jpeg") || path.endsWith(".webp") || path.endsWith(".gif") || path.endsWith(".bmp") || path.endsWith(".svg");
+          const path2 = ref.path.toLowerCase();
+          return path2.endsWith(".png") || path2.endsWith(".jpg") || path2.endsWith(".jpeg") || path2.endsWith(".webp") || path2.endsWith(".gif") || path2.endsWith(".bmp") || path2.endsWith(".svg");
         });
         if (imageRefs.length === 0) {
           return;
@@ -6469,27 +6457,27 @@ ${attachmentPaths}`;
        */
       static async processToolAttachments(attachments, state) {
         const { FileStorage: FileStorage2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-        const fs = new FileStorage2(state.storage.sql);
+        const fs2 = new FileStorage2(state.storage.sql);
         const refs = [];
         for (const attachment of attachments) {
           try {
             const attachmentId = crypto.randomUUID();
             const timestamp = Date.now();
             const ext = attachment.mimeType === "image/png" ? "png" : attachment.mimeType === "image/jpeg" ? "jpg" : attachment.mimeType === "image/gif" ? "gif" : attachment.mimeType === "image/webp" ? "webp" : attachment.name.split(".").pop() || "bin";
-            const path = `/attachments/${timestamp}-${attachmentId.slice(0, 8)}.${ext}`;
+            const path2 = `/attachments/${timestamp}-${attachmentId.slice(0, 8)}.${ext}`;
             const binaryString = atob(attachment.data);
             const dataBuffer = new Uint8Array(binaryString.length);
             for (let i = 0; i < binaryString.length; i++) {
               dataBuffer[i] = binaryString.charCodeAt(i);
             }
-            await fs.writeFile(path, dataBuffer.buffer, attachment.mimeType, {
+            await fs2.writeFile(path2, dataBuffer.buffer, attachment.mimeType, {
               width: attachment.width,
               height: attachment.height
             });
             const ref = {
               id: attachmentId,
               type: "file",
-              path,
+              path: path2,
               name: attachment.name,
               mimeType: attachment.mimeType,
               size: dataBuffer.byteLength
@@ -10852,20 +10840,20 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
             continue;
           }
           const attachmentId = crypto.randomUUID();
-          const path = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
+          const path2 = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
           try {
-            const written = await state.thread.instance.writeFile(path, base64Data, mimeType);
+            const written = await state.thread.instance.writeFile(path2, base64Data, mimeType);
             if (written && written.success === false) {
               console.error("[FlowEngine] Generated image write failed:", written.error);
               continue;
             }
             if (image.id) {
-              imagePathMap.set(image.id, path);
+              imagePathMap.set(image.id, path2);
             }
             refs.push({
               id: attachmentId,
               type: "file",
-              path,
+              path: path2,
               name: `generated-${attachmentId}.${ext}`,
               mimeType,
               size: Math.ceil(base64Data.length * 3 / 4)
@@ -10930,9 +10918,9 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
             continue;
           }
           const attachmentId = crypto.randomUUID();
-          const path = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
+          const path2 = `/attachments/${Date.now()}-${attachmentId.slice(0, 8)}.${ext}`;
           try {
-            const written = await state.thread.instance.writeFile(path, base64Data, mimeType);
+            const written = await state.thread.instance.writeFile(path2, base64Data, mimeType);
             if (written && written.success === false) {
               console.error(`[FlowEngine] ${toolName} image write failed:`, written.error);
               continue;
@@ -10940,7 +10928,7 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
             const attachmentRef = {
               id: attachmentId,
               type: "file",
-              path,
+              path: path2,
               name: `generated-${attachmentId}.${ext}`,
               mimeType,
               size: Math.ceil(base64Data.length * 3 / 4)
@@ -11003,7 +10991,7 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
                   content: "Image generated successfully",
                   status: "success",
                   timestamp: Date.now(),
-                  attachment_path: path
+                  attachment_path: path2
                 });
                 await state.storage.sql.exec(
                   `UPDATE logs SET tool_results = ?1 WHERE id = ?2`,
@@ -11025,7 +11013,7 @@ ${msg.content}` : `${imageDescriptions}${nonImageList}`;
               }
             }
             if (image.id) {
-              imagePathMap.set(image.id, path);
+              imagePathMap.set(image.id, path2);
             }
           } catch (error) {
             console.error(`[FlowEngine] Failed to store provider tool result for ${toolName}:`, error);
@@ -11890,7 +11878,7 @@ async function updateThread(thread, params) {
   }
   return result.thread;
 }
-async function writeFile(flow, path, data, mimeType, options) {
+async function writeFile(flow, path2, data, mimeType, options) {
   const instance = flow.thread.instance;
   let base64Data;
   if (typeof data === "string") {
@@ -11912,7 +11900,7 @@ async function writeFile(flow, path, data, mimeType, options) {
     }
     base64Thumbnail = btoa(binary);
   }
-  const result = await instance.writeFile(path, base64Data, mimeType, {
+  const result = await instance.writeFile(path2, base64Data, mimeType, {
     metadata: options?.metadata,
     thumbnail: base64Thumbnail
   });
@@ -11921,20 +11909,20 @@ async function writeFile(flow, path, data, mimeType, options) {
   }
   return result.file;
 }
-async function writeImage(flow, path, data, mimeType, options) {
-  return writeFile(flow, path, data, mimeType, options);
+async function writeImage(flow, path2, data, mimeType, options) {
+  return writeFile(flow, path2, data, mimeType, options);
 }
-async function linkFile(flow, path, location, options) {
+async function linkFile(flow, path2, location, options) {
   const instance = flow.thread.instance;
-  const result = await instance.linkFile(path, location, options);
+  const result = await instance.linkFile(path2, location, options);
   if (!result.success) {
     throw new Error(result.error || "Failed to link file");
   }
   return result.file;
 }
-async function readFile(flow, path) {
+async function readFile(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.readFile(path);
+  const result = await instance.readFile(path2);
   if (!result.success) {
     return null;
   }
@@ -11945,45 +11933,45 @@ async function readFile(flow, path) {
   }
   return bytes.buffer;
 }
-async function stat(flow, path) {
+async function stat(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.statFile(path);
+  const result = await instance.statFile(path2);
   if (!result.success) {
     return null;
   }
   return result.file;
 }
-async function exists(flow, path) {
+async function exists(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.fileExists(path);
+  const result = await instance.fileExists(path2);
   return result.success && result.exists;
 }
-async function unlink(flow, path) {
+async function unlink(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.unlinkFile(path);
+  const result = await instance.unlinkFile(path2);
   if (!result.success) {
     throw new Error(result.error || "Failed to delete file");
   }
 }
-async function mkdir(flow, path) {
+async function mkdir(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.mkdirFile(path);
+  const result = await instance.mkdirFile(path2);
   if (!result.success) {
     throw new Error(result.error || "Failed to create directory");
   }
   return result.directory;
 }
-async function readdir(flow, path) {
+async function readdir(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.readdirFile(path);
+  const result = await instance.readdirFile(path2);
   if (!result.success) {
     throw new Error(result.error || "Failed to read directory");
   }
   return result.files;
 }
-async function rmdir(flow, path) {
+async function rmdir(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.rmdirFile(path);
+  const result = await instance.rmdirFile(path2);
   if (!result.success) {
     throw new Error(result.error || "Failed to remove directory");
   }
@@ -11996,9 +11984,9 @@ async function move(flow, sourcePath, destinationPath) {
   }
   return result.file;
 }
-async function rename(flow, path, newName) {
+async function rename(flow, path2, newName) {
   const instance = flow.thread.instance;
-  const result = await instance.renameFile(path, newName);
+  const result = await instance.renameFile(path2, newName);
   if (!result.success) {
     throw new Error(result.error || "Failed to rename file");
   }
@@ -12012,9 +12000,9 @@ async function getFileStats(flow) {
   }
   return result.stats;
 }
-async function getThumbnail(flow, path) {
+async function getThumbnail(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.getFileThumbnail(path);
+  const result = await instance.getFileThumbnail(path2);
   if (!result.success) {
     return null;
   }
@@ -12025,22 +12013,22 @@ async function getThumbnail(flow, path) {
   }
   return bytes.buffer;
 }
-async function cat(flow, path) {
+async function cat(flow, path2) {
   const instance = flow.thread.instance;
-  const result = await instance.readTextFile(path);
+  const result = await instance.readTextFile(path2);
   if (!result.success) {
     return null;
   }
   return result.content;
 }
-async function head(flow, path, lines = 10) {
-  const content = await cat(flow, path);
+async function head(flow, path2, lines = 10) {
+  const content = await cat(flow, path2);
   if (content === null) return null;
   const allLines = content.split("\n");
   return allLines.slice(0, lines).join("\n");
 }
-async function tail(flow, path, lines = 10) {
-  const content = await cat(flow, path);
+async function tail(flow, path2, lines = 10) {
+  const content = await cat(flow, path2);
   if (content === null) return null;
   const allLines = content.split("\n");
   return allLines.slice(-lines).join("\n");
@@ -12579,32 +12567,32 @@ function prepareBridge(options, reports, logs) {
     logs
   };
 }
-function prepareNamespaceRecord(value, path, functions) {
+function prepareNamespaceRecord(value, path2, functions) {
   const out = {};
   for (const [key, namespace] of Object.entries(value)) {
-    out[key] = prepareValueRecord(namespace, `${path}.${key}`, functions);
+    out[key] = prepareValueRecord(namespace, `${path2}.${key}`, functions);
   }
   return out;
 }
-function prepareValueRecord(value, path, functions) {
+function prepareValueRecord(value, path2, functions) {
   const out = {};
   for (const [key, item] of Object.entries(value)) {
-    out[key] = prepareBridgeValue(item, `${path}.${key}`, functions);
+    out[key] = prepareBridgeValue(item, `${path2}.${key}`, functions);
   }
   return out;
 }
-function prepareBridgeValue(value, path, functions) {
+function prepareBridgeValue(value, path2, functions) {
   if (typeof value === "function") {
-    functions.set(path, value);
-    return { __agentbuilderType: "function", id: path };
+    functions.set(path2, value);
+    return { __agentbuilderType: "function", id: path2 };
   }
   if (isThenable(value)) {
-    const promiseId = `${path}.__promise`;
+    const promiseId = `${path2}.__promise`;
     functions.set(promiseId, async () => value);
     return { __agentbuilderType: "promise", id: promiseId };
   }
   if (Array.isArray(value)) {
-    return value.map((item, index) => prepareBridgeValue(item, `${path}.${index}`, functions));
+    return value.map((item, index) => prepareBridgeValue(item, `${path2}.${index}`, functions));
   }
   if (value && typeof value === "object") {
     if (value instanceof Date || value instanceof Map || value instanceof Set || ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
@@ -12615,7 +12603,7 @@ function prepareBridgeValue(value, path, functions) {
     }
     const out = {};
     for (const [key, item] of Object.entries(value)) {
-      out[key] = prepareBridgeValue(item, `${path}.${key}`, functions);
+      out[key] = prepareBridgeValue(item, `${path2}.${key}`, functions);
     }
     return out;
   }
@@ -13490,12 +13478,12 @@ function normalizeVirtualModulePath(basePath, specifier) {
   }
   return normalized;
 }
-function dirnameModulePath(path) {
-  const index = path.lastIndexOf("/");
-  return index <= 0 ? "" : path.slice(0, index);
+function dirnameModulePath(path2) {
+  const index = path2.lastIndexOf("/");
+  return index <= 0 ? "" : path2.slice(0, index);
 }
-function hasModuleExtension(path) {
-  return /\.[A-Za-z0-9]+$/.test(path);
+function hasModuleExtension(path2) {
+  return /\.[A-Za-z0-9]+$/.test(path2);
 }
 function resolveGraphModuleSpecifier(fromPath, specifier, modulePaths) {
   const base = normalizeVirtualModulePath(dirnameModulePath(fromPath), specifier);
@@ -13852,9 +13840,9 @@ function isPlainObject2(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function findUntransferableOption(value, path, seen = /* @__PURE__ */ new WeakSet()) {
+function findUntransferableOption(value, path2, seen = /* @__PURE__ */ new WeakSet()) {
   if (typeof value === "function" || typeof value === "symbol") {
-    return path;
+    return path2;
   }
   if (!value || typeof value !== "object") {
     return null;
@@ -13868,7 +13856,7 @@ function findUntransferableOption(value, path, seen = /* @__PURE__ */ new WeakSe
   seen.add(value);
   if (Array.isArray(value)) {
     for (const [index, item] of value.entries()) {
-      const found = findUntransferableOption(item, `${path}.${index}`, seen);
+      const found = findUntransferableOption(item, `${path2}.${index}`, seen);
       if (found) return found;
     }
     return null;
@@ -13876,9 +13864,9 @@ function findUntransferableOption(value, path, seen = /* @__PURE__ */ new WeakSe
   if (value instanceof Map) {
     let index = 0;
     for (const [key, item] of value.entries()) {
-      const foundKey = findUntransferableOption(key, `${path}.mapKey${index}`, seen);
+      const foundKey = findUntransferableOption(key, `${path2}.mapKey${index}`, seen);
       if (foundKey) return foundKey;
-      const foundValue = findUntransferableOption(item, `${path}.mapValue${index}`, seen);
+      const foundValue = findUntransferableOption(item, `${path2}.mapValue${index}`, seen);
       if (foundValue) return foundValue;
       index += 1;
     }
@@ -13887,17 +13875,17 @@ function findUntransferableOption(value, path, seen = /* @__PURE__ */ new WeakSe
   if (value instanceof Set) {
     let index = 0;
     for (const item of value.values()) {
-      const found = findUntransferableOption(item, `${path}.setValue${index}`, seen);
+      const found = findUntransferableOption(item, `${path2}.setValue${index}`, seen);
       if (found) return found;
       index += 1;
     }
     return null;
   }
   if (!isPlainObject2(value)) {
-    return path;
+    return path2;
   }
   for (const [key, item] of Object.entries(value)) {
-    const found = findUntransferableOption(item, `${path}.${key}`, seen);
+    const found = findUntransferableOption(item, `${path2}.${key}`, seen);
     if (found) return found;
   }
   return null;
@@ -14727,27 +14715,51 @@ var init_ThreadStateImpl = __esm({
         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;
+        if (typeof instance.createProxyStreamReceiver !== "function" || typeof instance.proxyStreamReceive !== "function") {
+          return local;
+        }
+        let abortRemote = null;
+        const receiver = instance.createProxyStreamReceiver((error) => abortRemote?.(error));
+        const discardReceiver = async (error) => {
+          await instance.proxyStreamReceive(receiver.id, { type: "abort", error });
+        };
+        const namespace = instance.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 stub = namespace.get(namespace.idFromName(parentId));
             if (typeof stub.proxyStreamOpen === "function") {
-              const opened = await stub.proxyStreamOpen(withWake(parentId));
+              const opened = await stub.proxyStreamOpen(withWake(parentId), {
+                threadId: this._metadata.id,
+                receiverId: receiver.id
+              });
               if (opened.ok && opened.id) {
+                if (opened.eventDriven !== true) {
+                  await stub.proxyStreamAbort(opened.id).catch(() => {
+                  });
+                  await discardReceiver("The ancestor runtime does not support event-driven streams.");
+                  return {
+                    ok: false,
+                    error: "The ancestor runtime does not support event-driven streams.",
+                    data: { code: "unsupported" }
+                  };
+                }
+                abortRemote = (error) => {
+                  void stub.proxyStreamAbort(opened.id).catch(() => {
+                  });
+                  if (error) {
+                    void instance.proxyStreamReceive(receiver.id, { type: "abort", error });
+                  }
+                };
                 return {
                   ok: true,
-                  duplex: this.buildProxyDuplex(
-                    stub,
-                    opened.id,
-                    opened.parkedPull === true
-                  )
+                  duplex: this.buildEventProxyDuplex(stub, opened.id, receiver, instance)
                 };
               }
               if (opened.error && !opened.noClient) {
+                await discardReceiver(opened.error);
                 return {
                   ok: false,
                   error: opened.error,
@@ -14759,69 +14771,21 @@ var init_ThreadStateImpl = __esm({
           }
           parentId = await this.resolveParentThreadId(parentId);
         }
+        await discardReceiver(local.error ?? "No execution-owner bridge is available.");
         return local;
       }
       /**
        * Build a client duplex that bridges to a stream opened on an ancestor DO
-       * (the bridge holder) via chunk-pull RPCs. `readable` issues PARKED pulls —
-       * a current ancestor holds one `proxyStreamPull` until bytes, completion,
-       * error, or abort, so an idle open stream performs zero repeated pulls.
-       * Older ancestors use the bounded long-pull compatibility path. `writable`
-       * forwards each chunk with `proxyStreamWrite`; teardown calls
-       * `proxyStreamAbort`.
+       * (the bridge holder). The readable is the receiver registered on this DO;
+       * writes and terminal actions are the only child-to-ancestor RPCs.
        */
-      static PROXY_PULL_MAX_WAIT_MS = 2e4;
-      buildProxyDuplex(stub, id, supportsParkedPull = false) {
-        let settleDone;
-        const done = new Promise((r) => settleDone = r);
+      buildEventProxyDuplex(stub, id, receiver, instance) {
         let closed = false;
-        let settled = false;
-        const settle = (result) => {
-          if (settled) return;
-          settled = true;
-          settleDone(result);
+        const settleLocal = (error) => {
+          if (typeof instance.proxyStreamReceive !== "function") return;
+          const frame = error ? { type: "abort", error } : { type: "end" };
+          void instance.proxyStreamReceive(receiver.id, frame);
         };
-        const readable = new ReadableStream({
-          async pull(controller) {
-            while (!closed) {
-              const pullStartedAt = Date.now();
-              let res;
-              try {
-                res = await stub.proxyStreamPull(
-                  id,
-                  supportsParkedPull ? void 0 : _ThreadStateImpl.PROXY_PULL_MAX_WAIT_MS
-                );
-              } catch (error) {
-                controller.error(error instanceof Error ? error : new Error(String(error)));
-                settle({ ok: false, error: "proxy stream pull failed" });
-                return;
-              }
-              for (const chunk of res.chunks) {
-                controller.enqueue(decodeStreamChunk(chunk));
-              }
-              if (res.done) {
-                controller.close();
-                settle(res.error ? { ok: false, error: res.error } : { ok: true });
-                return;
-              }
-              if (res.chunks.length > 0) return;
-              if (supportsParkedPull) {
-                controller.error(new Error("parked proxy pull returned without data"));
-                settle({ ok: false, error: "parked proxy pull returned without data" });
-                return;
-              }
-              if (Date.now() - pullStartedAt < 250) {
-                await new Promise((r) => setTimeout(r, 250));
-              }
-            }
-          },
-          cancel() {
-            closed = true;
-            void stub.proxyStreamAbort(id).catch(() => {
-            });
-            settle({ ok: false, error: "proxy stream reader canceled" });
-          }
-        });
         const writable = new WritableStream({
           async write(chunk) {
             await stub.proxyStreamWrite(id, encodeStreamChunk(chunk));
@@ -14834,20 +14798,20 @@ var init_ThreadStateImpl = __esm({
             closed = true;
             void stub.proxyStreamAbort(id).catch(() => {
             });
-            settle({ ok: false, error: "proxy stream writer aborted" });
+            settleLocal("The proxy stream writer was aborted.");
           }
         });
         return {
-          readable,
+          readable: receiver.readable,
           writable,
           close: (error) => {
             if (closed) return;
             closed = true;
             void stub.proxyStreamAbort(id).catch(() => {
             });
-            settle(error ? { ok: false, error } : { ok: true });
+            settleLocal(error);
           },
-          done
+          done: receiver.done
         };
       }
       isNoClient(res) {
@@ -14873,7 +14837,7 @@ var init_ThreadStateImpl = __esm({
       // ─────────────────────────────────────────────────────────────────────────
       // File System
       // ─────────────────────────────────────────────────────────────────────────
-      async writeFile(path, data, mimeType, options) {
+      async writeFile(path2, data, mimeType, options) {
         const isText = this._isTextMimeType(mimeType);
         if (isText) {
           let textContent;
@@ -14882,7 +14846,7 @@ var init_ThreadStateImpl = __esm({
           } else {
             textContent = new TextDecoder().decode(data);
           }
-          const result = await this._threadInstance.writeTextFile(path, textContent, mimeType, options);
+          const result = await this._threadInstance.writeTextFile(path2, textContent, mimeType, options);
           return this._mapFileRecord(result.file);
         } else {
           let base64Data;
@@ -14902,7 +14866,7 @@ var init_ThreadStateImpl = __esm({
             }
             base64Data = btoa(binary);
           }
-          const result = await this._threadInstance.writeFile(path, base64Data, mimeType, options);
+          const result = await this._threadInstance.writeFile(path2, base64Data, mimeType, options);
           return this._mapFileRecord(result.file);
         }
       }
@@ -14974,8 +14938,8 @@ var init_ThreadStateImpl = __esm({
           (type) => mimeType === type || mimeType.startsWith(type + ";")
         );
       }
-      async readFile(path) {
-        const result = await this._threadInstance.readFile(path);
+      async readFile(path2) {
+        const result = await this._threadInstance.readFile(path2);
         if (!result.success || !result.data) {
           return null;
         }
@@ -14986,8 +14950,8 @@ var init_ThreadStateImpl = __esm({
         }
         return bytes.buffer;
       }
-      async readFileStream(path, options) {
-        const fileInfo = this._unwrapStatRecord(await this._threadInstance.statFile(path));
+      async readFileStream(path2, options) {
+        const fileInfo = this._unwrapStatRecord(await this._threadInstance.statFile(path2));
         if (!fileInfo) {
           return null;
         }
@@ -15002,7 +14966,7 @@ var init_ThreadStateImpl = __esm({
         return {
           [Symbol.asyncIterator]: async function* () {
             if (!isChunked) {
-              const result = await threadInstance.readFile(path);
+              const result = await threadInstance.readFile(path2);
               if (!result.success || !result.data) {
                 return;
               }
@@ -15023,7 +14987,7 @@ var init_ThreadStateImpl = __esm({
               if (signal?.aborted) {
                 return;
               }
-              const result = await threadInstance.readFileChunk(path, i);
+              const result = await threadInstance.readFileChunk(path2, i);
               if (!result.success || !result.data) {
                 throw new Error(result.error || `Failed to read chunk ${i}`);
               }
@@ -15056,31 +15020,31 @@ var init_ThreadStateImpl = __esm({
         if (!("path" in record) && !("name" in record)) return null;
         return record;
       }
-      async statFile(path) {
-        const record = this._unwrapStatRecord(await this._threadInstance.statFile(path));
+      async statFile(path2) {
+        const record = this._unwrapStatRecord(await this._threadInstance.statFile(path2));
         return record ? this._mapFileRecord(record) : null;
       }
-      async readdirFile(path) {
-        const result = await this._threadInstance.readdirFile(path);
+      async readdirFile(path2) {
+        const result = await this._threadInstance.readdirFile(path2);
         const entries = Array.isArray(result) ? result : result?.files;
         if (!Array.isArray(entries)) {
           throw new Error(
-            result?.error || `Could not list directory: ${path}`
+            result?.error || `Could not list directory: ${path2}`
           );
         }
         return {
           entries: entries.map((e) => this._mapFileRecord(e))
         };
       }
-      async unlinkFile(path) {
-        await this._threadInstance.unlinkFile(path);
+      async unlinkFile(path2) {
+        await this._threadInstance.unlinkFile(path2);
       }
-      async mkdirFile(path) {
-        const result = await this._threadInstance.mkdirFile(path);
+      async mkdirFile(path2) {
+        const result = await this._threadInstance.mkdirFile(path2);
         return this._mapFileRecord(result);
       }
-      async rmdirFile(path) {
-        await this._threadInstance.rmdirFile(path);
+      async rmdirFile(path2) {
+        await this._threadInstance.rmdirFile(path2);
       }
       async moveFile(sourcePath, destinationPath) {
         const result = await this._threadInstance.moveFile(sourcePath, destinationPath);
@@ -15089,8 +15053,8 @@ var init_ThreadStateImpl = __esm({
         }
         return this._mapFileRecord(result.file);
       }
-      async renameFile(path, newName) {
-        const result = await this._threadInstance.renameFile(path, newName);
+      async renameFile(path2, newName) {
+        const result = await this._threadInstance.renameFile(path2, newName);
         if (!result.success || !result.file) {
           throw new Error(result.error || "Failed to rename file");
         }
@@ -15117,8 +15081,8 @@ var init_ThreadStateImpl = __esm({
           paths: Array.isArray(results) ? results : results.paths || []
         };
       }
-      async getFileThumbnail(path) {
-        return this._threadInstance.getFileThumbnail(path);
+      async getFileThumbnail(path2) {
+        return this._threadInstance.getFileThumbnail(path2);
       }
       // ─────────────────────────────────────────────────────────────────────────
       // Execution State
@@ -15423,7 +15387,7 @@ var init_ThreadStateImpl = __esm({
             const skillMd = await stub.getSkillFile(scope, name, "SKILL.md") ?? "";
             return { metadata, skillMd };
           },
-          readFile: (name, path) => stub.getSkillFile(scope, name, path),
+          readFile: (name, path2) => stub.getSkillFile(scope, name, path2),
           install: async (files) => {
             await requireMutationAdmin();
             return stub.upsertSkill(scope, files);
@@ -15710,7 +15674,14 @@ function isHostedInstance(env) {
   }
   return Boolean(value);
 }
-function isTrustedLocalDevelopmentRequest(request, env) {
+function compiledTrustedDevHosts() {
+  try {
+    return typeof __STANDARD_AGENTS_TRUSTED_DEV_HOSTS__ !== "undefined" && Array.isArray(__STANDARD_AGENTS_TRUSTED_DEV_HOSTS__) ? __STANDARD_AGENTS_TRUSTED_DEV_HOSTS__ : [];
+  } catch {
+    return [];
+  }
+}
+function isTrustedLocalDevelopmentRequest(request, env, trustedDevHosts = compiledTrustedDevHosts()) {
   if (isHostedInstance(env)) return false;
   let hostname;
   try {
@@ -15718,7 +15689,7 @@ function isTrustedLocalDevelopmentRequest(request, env) {
   } catch {
     return false;
   }
-  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost") || hostname.endsWith(".orb.local");
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.endsWith(".localhost") || hostname.endsWith(".orb.local") || trustedDevHosts.some((trusted) => trusted.trim().toLowerCase() === hostname);
 }
 function isPublicApiRoute(routePath, request, env) {
   if (PUBLIC_ROUTES.has(routePath)) return true;
@@ -19013,10 +18984,10 @@ var DurableAgentBuilder = class extends DurableObject {
     for (const entry of value) {
       if (!entry || typeof entry !== "object") continue;
       const attachment = entry;
-      const path = typeof attachment.path === "string" ? attachment.path.trim() : "";
-      if (!path) continue;
+      const path2 = typeof attachment.path === "string" ? attachment.path.trim() : "";
+      if (!path2) continue;
       output.push({
-        path,
+        path: path2,
         name: typeof attachment.name === "string" ? attachment.name : void 0,
         mimeType: typeof attachment.mimeType === "string" ? attachment.mimeType : void 0,
         size: typeof attachment.size === "number" ? attachment.size : void 0,
@@ -19033,8 +19004,8 @@ var DurableAgentBuilder = class extends DurableObject {
     const trimmed = sanitized.replace(/^[-.]+|[-.]+$/g, "");
     return trimmed || "attachment";
   }
-  inferMimeTypeFromPath(path) {
-    const normalized = path.toLowerCase();
+  inferMimeTypeFromPath(path2) {
+    const normalized = path2.toLowerCase();
     if (normalized.endsWith(".png")) return "image/png";
     if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) return "image/jpeg";
     if (normalized.endsWith(".webp")) return "image/webp";
@@ -19072,7 +19043,7 @@ var DurableAgentBuilder = class extends DurableObject {
     if (!attachments || attachments.length === 0) {
       return "";
     }
-    const paths = attachments.map((attachment) => attachment.path).filter((path) => typeof path === "string" && path.length > 0);
+    const paths = attachments.map((attachment) => attachment.path).filter((path2) => typeof path2 === "string" && path2.length > 0);
     if (paths.length === 0) {
       return "";
     }
@@ -20474,12 +20445,9 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
             await parentThread.updateChildRegistryStatus(
               params.parent_thread_id,
               childThread.id,
-              childResult.terminal ? "terminated" : "idle"
+              "idle"
             );
           }
-          if (childResult.terminal && typeof childThreadStub.terminateThread === "function") {
-            await childThreadStub.terminateThread(childThread.id);
-          }
         } else if (typeof childThreadStub.terminateThread === "function") {
           await childThreadStub.terminateThread(childThread.id);
         }
@@ -21752,7 +21720,7 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     for (const row of cursor.toArray()) {
       if (skills.has(row.name)) continue;
       const parsedFiles = row.files ? JSON.parse(row.files) : [];
-      const files = Array.isArray(parsedFiles) ? parsedFiles.filter((path) => typeof path === "string").sort() : [];
+      const files = Array.isArray(parsedFiles) ? parsedFiles.filter((path2) => typeof path2 === "string").sort() : [];
       skills.set(row.name, {
         name: row.name,
         description: row.description,
@@ -21770,7 +21738,7 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
     return all.find((s) => s.name === name) ?? null;
   }
   /** One bundled file's text (null when the skill or file is missing). */
-  async getSkillFile(scope, name, path) {
+  async getSkillFile(scope, name, path2) {
     await this.ensureMigrated();
     const cursor = await this.ctx.storage.sql.exec(
       `SELECT f.content FROM skill_files f
@@ -21780,7 +21748,7 @@ ${result ?? error ?? "No result content."}${attachmentSummary}`;
        ORDER BY CASE WHEN f.owner_id = ? THEN 0 ELSE 1 END
        LIMIT 1`,
       name,
-      path.replace(/^\.\//, ""),
+      path2.replace(/^\.\//, ""),
       scope.ownerId,
       scope.includeShared ? 1 : 0,
       scope.ownerId
@@ -22075,12 +22043,12 @@ async function authorizesToolDelivery(pending, proof) {
   return matchesToolDeliveryOwner(pending, proof) && await matchesToolDeliveryToken(pending.delivery_token_hash, proof.token);
 }
 var RUNTIME_STORAGE_PREFIX = "__agentbuilder_runtime_storage__:";
-function normalizeEndpointThreadPath(path) {
-  if (!path || /^[A-Za-z][A-Za-z\d+\-.]*:/.test(path)) {
+function normalizeEndpointThreadPath(path2) {
+  if (!path2 || /^[A-Za-z][A-Za-z\d+\-.]*:/.test(path2)) {
     throw new Error("Use a relative thread filesystem path");
   }
   const parts = [];
-  for (const part of path.replace(/\\/g, "/").split("/")) {
+  for (const part of path2.replace(/\\/g, "/").split("/")) {
     if (!part || part === ".") continue;
     if (part === "..") {
       if (parts.length === 0) throw new Error("Path cannot escape the thread filesystem root");
@@ -22130,12 +22098,12 @@ function createEndpointFetchBridge() {
 function createEndpointFsBridge(state) {
   const decoder = new TextDecoder();
   return {
-    readFile: async (path) => {
-      const data = await state.readFile(normalizeEndpointThreadPath(path));
+    readFile: async (path2) => {
+      const data = await state.readFile(normalizeEndpointThreadPath(path2));
       return data ? decoder.decode(data) : null;
     },
-    writeFile: async (path, content, mimeType = "text/plain") => {
-      return state.writeFile(normalizeEndpointThreadPath(path), content, mimeType);
+    writeFile: async (path2, content, mimeType = "text/plain") => {
+      return state.writeFile(normalizeEndpointThreadPath(path2), content, mimeType);
     }
   };
 }
@@ -22204,24 +22172,24 @@ function createEndpointThreadStateBridge(state) {
     emit: (event, data) => state.emit(event, data),
     getValue: (key) => state.getValue(key),
     setValue: (key, value) => state.setValue(key, value),
-    readFile: (path) => state.readFile(normalizeEndpointThreadPath(path)),
-    writeFile: (path, data, mimeType = "application/octet-stream", options) => {
-      return state.writeFile(normalizeEndpointThreadPath(path), data, mimeType, options);
+    readFile: (path2) => state.readFile(normalizeEndpointThreadPath(path2)),
+    writeFile: (path2, data, mimeType = "application/octet-stream", options) => {
+      return state.writeFile(normalizeEndpointThreadPath(path2), data, mimeType, options);
     },
-    statFile: (path) => state.statFile(normalizeEndpointThreadPath(path)),
-    readdirFile: (path) => state.readdirFile(normalizeEndpointThreadPath(path)),
-    unlinkFile: (path) => state.unlinkFile(normalizeEndpointThreadPath(path)),
-    mkdirFile: (path) => state.mkdirFile(normalizeEndpointThreadPath(path)),
-    rmdirFile: (path) => state.rmdirFile(normalizeEndpointThreadPath(path)),
+    statFile: (path2) => state.statFile(normalizeEndpointThreadPath(path2)),
+    readdirFile: (path2) => state.readdirFile(normalizeEndpointThreadPath(path2)),
+    unlinkFile: (path2) => state.unlinkFile(normalizeEndpointThreadPath(path2)),
+    mkdirFile: (path2) => state.mkdirFile(normalizeEndpointThreadPath(path2)),
+    rmdirFile: (path2) => state.rmdirFile(normalizeEndpointThreadPath(path2)),
     moveFile: (sourcePath, destinationPath) => state.moveFile(
       normalizeEndpointThreadPath(sourcePath),
       normalizeEndpointThreadPath(destinationPath)
     ),
-    renameFile: (path, newName) => state.renameFile(normalizeEndpointThreadPath(path), newName),
+    renameFile: (path2, newName) => state.renameFile(normalizeEndpointThreadPath(path2), newName),
     getFileStats: () => state.getFileStats(),
     grepFiles: (pattern) => state.grepFiles(pattern),
     findFiles: (pattern) => state.findFiles(pattern),
-    getFileThumbnail: (path) => state.getFileThumbnail(normalizeEndpointThreadPath(path))
+    getFileThumbnail: (path2) => state.getFileThumbnail(normalizeEndpointThreadPath(path2))
   };
 }
 function routeBridgeClientFrame(socket, message, handlers) {
@@ -22274,6 +22242,8 @@ var DurableThread = class _DurableThread extends DurableObject {
   // 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();
+  proxyStreamReceivers = /* @__PURE__ */ new Map();
+  eventProxyStreams = /* @__PURE__ */ new Map();
   alarmQueue;
   runtimeSafety;
   alarmQueueRearmed = false;
@@ -22385,6 +22355,10 @@ var DurableThread = class _DurableThread extends DurableObject {
           clientName: typeof attachment.clientName === "string" ? attachment.clientName : null,
           clientKind: typeof attachment.clientKind === "string" ? attachment.clientKind : null
         });
+        const interrupted = this.parseProxyStreamAttachments(attachment.proxyStreams);
+        if (interrupted.length > 0) {
+          this.recoverInterruptedProxyStreams(ws, interrupted);
+        }
       }
     }
   }
@@ -22973,7 +22947,7 @@ var DurableThread = class _DurableThread extends DurableObject {
     this.assertJsonSerializableThreadValue(value, "$", /* @__PURE__ */ new WeakSet());
     return JSON.stringify(value);
   }
-  assertJsonSerializableThreadValue(value, path, seen) {
+  assertJsonSerializableThreadValue(value, path2, seen) {
     if (value === null) {
       return;
     }
@@ -22983,36 +22957,36 @@ var DurableThread = class _DurableThread extends DurableObject {
         return;
       case "number":
         if (!Number.isFinite(value)) {
-          throw new Error(`Thread value at ${path} must be a finite number`);
+          throw new Error(`Thread value at ${path2} must be a finite number`);
         }
         return;
       case "object": {
         if (seen.has(value)) {
-          throw new Error(`Thread value at ${path} cannot contain circular references`);
+          throw new Error(`Thread value at ${path2} cannot contain circular references`);
         }
         seen.add(value);
         if (Array.isArray(value)) {
           for (let i = 0; i < value.length; i += 1) {
-            this.assertJsonSerializableThreadValue(value[i], `${path}[${i}]`, seen);
+            this.assertJsonSerializableThreadValue(value[i], `${path2}[${i}]`, seen);
           }
           seen.delete(value);
           return;
         }
         const prototype = Object.getPrototypeOf(value);
         if (prototype !== Object.prototype && prototype !== null) {
-          throw new Error(`Thread value at ${path} must be a JSON object, array, or primitive`);
+          throw new Error(`Thread value at ${path2} must be a JSON object, array, or primitive`);
         }
         if (Object.getOwnPropertySymbols(value).length > 0) {
-          throw new Error(`Thread value at ${path} cannot contain symbol keys`);
+          throw new Error(`Thread value at ${path2} cannot contain symbol keys`);
         }
         for (const [entryKey, entryValue] of Object.entries(value)) {
-          this.assertJsonSerializableThreadValue(entryValue, `${path}.${entryKey}`, seen);
+          this.assertJsonSerializableThreadValue(entryValue, `${path2}.${entryKey}`, seen);
         }
         seen.delete(value);
         return;
       }
       default:
-        throw new Error(`Thread value at ${path} must be JSON-serializable`);
+        throw new Error(`Thread value at ${path2} must be JSON-serializable`);
     }
   }
   // ============================================================
@@ -24213,8 +24187,8 @@ var DurableThread = class _DurableThread extends DurableObject {
     );
     return terminalCursor.toArray()[0] ?? null;
   }
-  inferMimeTypeFromPath(path) {
-    const normalized = path.toLowerCase();
+  inferMimeTypeFromPath(path2) {
+    const normalized = path2.toLowerCase();
     if (normalized.endsWith(".png")) return "image/png";
     if (normalized.endsWith(".jpg") || normalized.endsWith(".jpeg")) return "image/jpeg";
     if (normalized.endsWith(".webp")) return "image/webp";
@@ -24253,7 +24227,7 @@ var DurableThread = class _DurableThread extends DurableObject {
       ext: value.slice(lastDot + 1).toLowerCase()
     };
   }
-  resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path) {
+  resolveAttachmentMimeType(sourceMimeType, fallbackMimeType, path2) {
     const source = sourceMimeType?.trim();
     if (source && source !== "application/octet-stream") {
       return source;
@@ -24262,7 +24236,7 @@ var DurableThread = class _DurableThread extends DurableObject {
     if (fallback && fallback !== "application/octet-stream") {
       return fallback;
     }
-    return this.inferMimeTypeFromPath(path) ?? source ?? fallback ?? "application/octet-stream";
+    return this.inferMimeTypeFromPath(path2) ?? source ?? fallback ?? "application/octet-stream";
   }
   buildAttachmentTargetPath(preferredName, mimeType, sourcePath) {
     const safeName = this.sanitizeFilename(preferredName);
@@ -24357,8 +24331,8 @@ var DurableThread = class _DurableThread extends DurableObject {
     }
     return copied;
   }
-  async readAttachmentDataFromSource(path, sourceFile) {
-    const sourceData = await this.readFile(path);
+  async readAttachmentDataFromSource(path2, sourceFile) {
+    const sourceData = await this.readFile(path2);
     if (sourceData.success && sourceData.data) {
       return sourceData.data;
     }
@@ -24395,7 +24369,7 @@ var DurableThread = class _DurableThread extends DurableObject {
     if (!attachments || attachments.length === 0) {
       return "";
     }
-    const paths = attachments.map((attachment) => attachment.path).filter((path) => typeof path === "string" && path.length > 0);
+    const paths = attachments.map((attachment) => attachment.path).filter((path2) => typeof path2 === "string" && path2.length > 0);
     if (paths.length === 0) {
       return "";
     }
@@ -24475,11 +24449,13 @@ ${paths.join("\n")}`;
     try {
       const parentId = this.env.AGENT_BUILDER_THREAD.idFromName(parentThreadId);
       const parentStub = this.env.AGENT_BUILDER_THREAD.get(parentId);
-      const parentCommunication = await this.getParentCommunicationModeForChild(
+      const childRegistryEntry = await this.getParentRegistryEntryForChild(
         parentStub,
         parentThreadId,
         threadId
       );
+      const parentCommunication = childRegistryEntry?.parentCommunication === "explicit" ? "explicit" : "implicit";
+      const resumableChild = childRegistryEntry?.resumable === true;
       const copiedRefs = await this.copyAttachmentRefsToThread(
         refs,
         parentStub,
@@ -24502,10 +24478,11 @@ ${resultContent}${attachmentSummary}`;
         });
       }
       const terminalChildRun = sessionStopped || hasTerminalSessionTools;
+      const terminateChildThread = terminalChildRun && !resumableChild;
       await parentStub.updateChildRegistryStatus(
         parentThreadId,
         threadId,
-        terminalChildRun ? "terminated" : "idle"
+        terminateChildThread ? "terminated" : "idle"
       );
       if (parentCommunication !== "explicit") {
         await this.persistParentHandoffStatusMessage(
@@ -24513,23 +24490,22 @@ ${resultContent}${attachmentSummary}`;
           isErrorTerminal ? "failure" : "result"
         );
       }
-      if (terminalChildRun) {
+      if (terminateChildThread) {
         await this.terminateThread(threadId);
       }
     } catch (error) {
       console.error("[DurableThread] Failed to deliver subagent completion to parent:", error);
     }
   }
-  async getParentCommunicationModeForChild(parentStub, parentThreadId, childThreadId) {
+  async getParentRegistryEntryForChild(parentStub, parentThreadId, childThreadId) {
     if (typeof parentStub.getChildrenRegistry !== "function") {
-      return "implicit";
+      return void 0;
     }
     try {
       const entries = await parentStub.getChildrenRegistry(parentThreadId);
-      const childEntry = entries.find((entry) => entry.reference === childThreadId);
-      return childEntry?.parentCommunication === "explicit" ? "explicit" : "implicit";
+      return entries.find((entry) => entry.reference === childThreadId);
     } catch {
-      return "implicit";
+      return void 0;
     }
   }
   /**
@@ -26077,7 +26053,7 @@ ${resultContent}${attachmentSummary}`;
           void 0,
           INTERNAL_TOOL_DELIVERY
         );
-        if (delivered?.resume) sides.add(delivered.side);
+        if (delivered) sides.add(delivered.side);
       }
       if (threadId) {
         for (const side of sides) {
@@ -26379,17 +26355,14 @@ ${resultContent}${attachmentSummary}`;
   deliveredResultWaiters = /* @__PURE__ */ new Map();
   notifyDeliveredResultWaiters(toolCallId) {
     const waiters = this.deliveredResultWaiters?.get(toolCallId);
-    if (!waiters || waiters.size === 0) return false;
+    if (!waiters) return;
     this.deliveredResultWaiters.delete(toolCallId);
-    let notified = false;
     for (const wake of waiters) {
       try {
         wake();
-        notified = true;
       } catch {
       }
     }
-    return notified;
   }
   /**
    * Await a parked forwarded call's delivered result: one immediate read,
@@ -26534,46 +26507,37 @@ ${resultContent}${attachmentSummary}`;
     const side = pending.side === "b" ? "b" : "a";
     const content = ok ? result ?? "" : `Error: ${error ?? "tool failed"}`;
     const toolStatus = ok ? "success" : "error";
-    const resultMessageId = crypto.randomUUID();
-    const resultCreatedAt = Date.now() * TIMESTAMP_MULTIPLIER;
-    const accepted = this.ctx.storage.transactionSync(() => {
-      const claimed = this.ctx.storage.sql.exec(
-        `UPDATE pending_client_calls
-            SET status = 'resolved'
-          WHERE tool_call_id = ? AND status = 'pending'`,
+    await this.ctx.storage.sql.exec(
+      `UPDATE messages SET content = ?, tool_status = ? WHERE tool_call_id = ? AND role = 'tool'`,
+      content,
+      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
       );
-      if (claimed.rowsWritten !== 1) return false;
-      this.ctx.storage.sql.exec(
-        `UPDATE messages SET content = ?, tool_status = ? WHERE tool_call_id = ? AND role = 'tool'`,
+      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,
-        toolCallId
-      );
-      const updated = this.ctx.storage.sql.exec(
-        `SELECT COUNT(*) AS total FROM messages WHERE tool_call_id = ? AND role = 'tool'`,
-        toolCallId
+        Date.now() * TIMESTAMP_MULTIPLIER
       );
-      if (Number(updated.toArray()[0]?.total ?? 0) === 0) {
-        const toolRow = this.ctx.storage.sql.exec(
-          `SELECT tool FROM pending_client_calls WHERE tool_call_id = ? LIMIT 1`,
-          toolCallId
-        );
-        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)`,
-          resultMessageId,
-          content,
-          toolRow.toArray()[0]?.tool ?? null,
-          toolCallId,
-          toolStatus,
-          resultCreatedAt
-        );
-      }
-      return true;
-    });
-    if (!accepted) return null;
-    const resumedInline = this.notifyDeliveredResultWaiters(toolCallId);
+    }
+    await this.ctx.storage.sql.exec(
+      `UPDATE pending_client_calls SET status = 'resolved' WHERE tool_call_id = ?`,
+      toolCallId
+    );
+    this.notifyDeliveredResultWaiters(toolCallId);
     try {
       const msgCursor = await this.ctx.storage.sql.exec(
         `SELECT id, role, content, name, tool_call_id, tool_status, created_at, depth
@@ -26584,7 +26548,7 @@ ${resultContent}${attachmentSummary}`;
       if (msg) this.broadcastMessage(msg);
     } catch {
     }
-    return { side, resume: !resumedInline };
+    return { side };
   }
   // ─── Runtime byte streams ──────────────────────────────────────────────────
   // The existing bridge frames carry opaque capability metadata and bytes
@@ -26650,8 +26614,138 @@ ${resultContent}${attachmentSummary}`;
       });
     }
   }
+  parseProxyStreamAttachments(value) {
+    if (!Array.isArray(value)) return [];
+    const parsed = [];
+    for (const item of value) {
+      if (!item || typeof item !== "object") continue;
+      const candidate = item;
+      if (typeof candidate.id === "string" && candidate.target && typeof candidate.target.threadId === "string" && typeof candidate.target.receiverId === "string") {
+        parsed.push({
+          id: candidate.id,
+          target: {
+            threadId: candidate.target.threadId,
+            receiverId: candidate.target.receiverId
+          }
+        });
+      }
+    }
+    return parsed;
+  }
+  /** Keep live proxy routes on the hibernating bridge socket for restart cleanup. */
+  updateBridgeProxyAttachment(socket) {
+    if (typeof socket.serializeAttachment !== "function") return;
+    let attachment = { type: "bridge" };
+    try {
+      const current = socket.deserializeAttachment();
+      if (current && typeof current === "object") {
+        attachment = { ...current };
+      }
+    } catch {
+    }
+    const proxyStreams = Array.from(this.clientStreams.entries()).filter(([, state]) => state.socket === socket && state.proxyTarget !== null).map(([id, state]) => ({ id, target: state.proxyTarget }));
+    try {
+      socket.serializeAttachment({ ...attachment, proxyStreams });
+    } catch {
+    }
+  }
+  async deliverProxyStreamFrame(target, frame) {
+    try {
+      const namespace = this.env.AGENT_BUILDER_THREAD;
+      const stub = namespace.get(namespace.idFromName(target.threadId));
+      return await stub.proxyStreamReceive(target.receiverId, frame);
+    } catch {
+      return false;
+    }
+  }
+  /** Abort live proxy routes restored without their in-memory stream state. */
+  recoverInterruptedProxyStreams(socket, streams) {
+    const error = "The stream ended because its runtime restarted.";
+    for (const stream of streams) {
+      try {
+        if (socket.readyState === WebSocket.OPEN) {
+          socket.send(JSON.stringify({ type: "stream_abort", id: stream.id, error }));
+        }
+      } catch {
+      }
+      this.ctx.waitUntil(
+        this.deliverProxyStreamFrame(stream.target, { type: "abort", error }).then(() => {
+        })
+      );
+    }
+    this.updateBridgeProxyAttachment(socket);
+  }
+  /** Register the child side before any ancestor opens an owner stream. */
+  createProxyStreamReceiver(onCancel) {
+    const id = crypto.randomUUID();
+    let controller = null;
+    let settleDone;
+    const done = new Promise((resolve) => {
+      settleDone = resolve;
+    });
+    const readable = new ReadableStream({
+      start(value) {
+        controller = value;
+      },
+      cancel: (reason) => {
+        const receiver2 = this.proxyStreamReceivers.get(id);
+        if (!receiver2 || receiver2.settled) return;
+        const error = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "The proxy stream reader was canceled.";
+        receiver2.settle({ ok: false, error });
+        receiver2.onCancel(error);
+      }
+    });
+    const receiver = {
+      controller,
+      settle: (result) => {
+        if (receiver.settled) return;
+        receiver.settled = true;
+        this.proxyStreamReceivers.delete(id);
+        settleDone(result);
+      },
+      onCancel,
+      settled: false
+    };
+    this.proxyStreamReceivers.set(id, receiver);
+    return { id, readable, done };
+  }
+  async proxyStreamReceiverExists(receiverId) {
+    return this.proxyStreamReceivers.has(receiverId);
+  }
+  async proxyStreamReceive(receiverId, frame) {
+    const receiver = this.proxyStreamReceivers.get(receiverId);
+    if (!receiver || receiver.settled) return false;
+    if (frame.type === "data") {
+      try {
+        receiver.controller?.enqueue(decodeStreamChunk(frame.data));
+      } catch (error2) {
+        const message = error2 instanceof Error ? error2.message : String(error2);
+        try {
+          receiver.controller?.error(error2 instanceof Error ? error2 : new Error(message));
+        } catch {
+        }
+        receiver.settle({ ok: false, error: message });
+      }
+      return true;
+    }
+    if (frame.type === "end") {
+      try {
+        receiver.controller?.close();
+      } catch {
+      }
+      receiver.settle({ ok: true });
+      return true;
+    }
+    const error = frame.error ?? "The proxied client stream was aborted.";
+    try {
+      receiver.controller?.error(new Error(error));
+    } catch {
+    }
+    receiver.settle({ ok: false, error });
+    return true;
+  }
   /** Open a bidirectional byte stream to the connected owner client. */
-  async openClientStream(request) {
+  async openClientStream(request, proxyTarget = null) {
     const owner = await this.getExecutionOwner();
     let socket = this.getOpenBridgeSocket(owner?.client_id ?? null);
     if (!socket && owner) {
@@ -26684,9 +26778,12 @@ ${resultContent}${attachmentSummary}`;
       opened: null,
       openTimer: null,
       settleDone,
-      settled: false
+      settled: false,
+      proxyTarget,
+      delivery: Promise.resolve()
     };
     this.clientStreams.set(id, state);
+    this.updateBridgeProxyAttachment(socket);
     this.bridgeLastSeen.set(socket, Date.now());
     const openResult = await new Promise((resolve) => {
       state.opened = resolve;
@@ -26722,6 +26819,7 @@ ${resultContent}${attachmentSummary}`;
     }
     if (!openResult.ok) {
       this.clientStreams.delete(id);
+      this.updateBridgeProxyAttachment(socket);
       state.settled = true;
       settleDone({ ok: false, error: openResult.error });
       return {
@@ -26763,14 +26861,28 @@ ${resultContent}${attachmentSummary}`;
     };
     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);
+  // ─── Event-driven subagent stream proxy ──────────────────────────────────
+  // A child registers a local receiver before the bridge-holding ancestor
+  // opens the client stream. The ancestor invokes that receiver only for real
+  // data/end/abort events; there is no pull loop or permanently outstanding
+  // cross-DO RPC while the stream is idle.
+  async proxyStreamOpen(request, target) {
+    const namespace = this.env.AGENT_BUILDER_THREAD;
+    let receiverExists = false;
+    try {
+      const destination = namespace.get(namespace.idFromName(target.threadId));
+      receiverExists = await destination.proxyStreamReceiverExists(target.receiverId);
+    } catch {
+      receiverExists = false;
+    }
+    if (!receiverExists) {
+      return {
+        ok: false,
+        error: "The destination stream receiver is unavailable.",
+        code: "unavailable"
+      };
+    }
+    const opened = await this.openClientStream(request, target);
     if (!opened.ok) {
       const failureData = opened.data;
       const noClient = failureData?.noClient === true;
@@ -26782,82 +26894,23 @@ ${resultContent}${attachmentSummary}`;
       };
     }
     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),
-      waiter: null,
-      notify: () => {
-        const waiter = entry.waiter;
-        entry.waiter = null;
-        waiter?.();
-      }
-    };
-    entry.pump = (async () => {
-      try {
-        while (true) {
-          const { value, done } = await reader.read();
-          if (done) break;
-          if (value) {
-            entry.buffer.push(value);
-            entry.notify();
-          }
-        }
-      } catch (error) {
-        entry.error = error instanceof Error ? error.message : String(error);
-      } finally {
-        entry.done = true;
-        entry.notify();
-      }
-    })();
-    void duplex.done.then((d) => {
-      entry.done = true;
-      if (!d.ok && !entry.error) entry.error = d.error;
-      entry.notify();
+    this.eventProxyStreams.set(id, {
+      writer: opened.duplex.writable.getWriter(),
+      close: (error) => opened.duplex.close(error),
+      target
     });
-    this.proxyStreams.set(id, entry);
-    return { ok: true, id, parkedPull: true };
+    return { ok: true, id, eventDriven: true };
   }
   async proxyStreamWrite(id, dataB64) {
-    const entry = this.proxyStreams.get(id);
+    const entry = this.eventProxyStreams.get(id);
     if (!entry) return;
     try {
       await entry.writer.write(decodeStreamChunk(dataB64));
     } catch {
     }
   }
-  async proxyStreamPull(id, maxWaitMs) {
-    const entry = this.proxyStreams.get(id);
-    if (!entry) return { chunks: [], done: true, error: "unknown proxy stream" };
-    if (entry.buffer.length === 0 && !entry.done) {
-      await new Promise((resolve) => {
-        const deadline = typeof maxWaitMs === "number" && maxWaitMs > 0 ? setTimeout(() => {
-          if (entry.waiter === wake) entry.waiter = null;
-          resolve();
-        }, maxWaitMs) : null;
-        const wake = () => {
-          if (deadline) clearTimeout(deadline);
-          resolve();
-        };
-        entry.waiter = wake;
-      });
-    }
-    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);
+    const entry = this.eventProxyStreams.get(id);
     if (!entry) return;
     try {
       await entry.writer.close();
@@ -26865,30 +26918,49 @@ ${resultContent}${attachmentSummary}`;
     }
   }
   async proxyStreamAbort(id) {
-    const entry = this.proxyStreams.get(id);
+    const entry = this.eventProxyStreams.get(id);
     if (!entry) return;
-    this.proxyStreams.delete(id);
-    entry.done = true;
-    if (!entry.error) entry.error = "aborted";
-    entry.notify();
+    this.eventProxyStreams.delete(id);
     try {
       entry.close("aborted");
     } catch {
     }
   }
+  forgetEventProxyStream(clientStreamId, target) {
+    const matchesTarget = (candidate) => candidate.threadId === target.threadId && candidate.receiverId === target.receiverId;
+    for (const [id, entry] of Array.from(this.eventProxyStreams.entries())) {
+      if (id !== clientStreamId && !matchesTarget(entry.target)) continue;
+      this.eventProxyStreams.delete(id);
+      try {
+        entry.writer.releaseLock();
+      } catch {
+      }
+    }
+  }
   /** Settle and remove a client stream exactly once. */
   settleClientStream(id, result, openCode) {
     const state = this.clientStreams.get(id);
     if (!state) return;
     this.clientStreams.delete(id);
+    this.updateBridgeProxyAttachment(state.socket);
     if (state.openTimer) clearTimeout(state.openTimer);
     if (state.opened) state.opened({ ok: false, error: result.error ?? "Stream closed.", code: openCode });
     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 {
+      if (state.proxyTarget) {
+        const target = state.proxyTarget;
+        const frame = result.ok ? { type: "end" } : { type: "abort", error: result.error ?? "Client stream aborted." };
+        state.delivery = state.delivery.then(async () => {
+          await this.deliverProxyStreamFrame(target, frame);
+        });
+        this.ctx.waitUntil(state.delivery);
+        this.forgetEventProxyStream(id, target);
+      } else {
+        try {
+          if (result.ok) state.controller?.close();
+          else state.controller?.error(new Error(result.error ?? "Client stream aborted."));
+        } catch {
+        }
       }
       state.settleDone(result);
     }
@@ -26931,6 +27003,18 @@ ${resultContent}${attachmentSummary}`;
       }
       case "stream_data": {
         if (typeof parsed.data !== "string") return;
+        if (state.proxyTarget) {
+          const target = state.proxyTarget;
+          const frame = { type: "data", data: parsed.data };
+          state.delivery = state.delivery.then(async () => {
+            const delivered = await this.deliverProxyStreamFrame(target, frame);
+            if (!delivered && this.clientStreams.get(id) === state) {
+              this.abortClientStream(id, "The destination stream receiver is unavailable.");
+            }
+          });
+          this.ctx.waitUntil(state.delivery);
+          return;
+        }
         try {
           state.controller?.enqueue(decodeStreamChunk(parsed.data));
         } catch {
@@ -27758,11 +27842,12 @@ ${resultContent}${attachmentSummary}`;
       if (!parentThreadId) return;
       const parentId = this.env.AGENT_BUILDER_THREAD.idFromName(parentThreadId);
       const parentStub = this.env.AGENT_BUILDER_THREAD.get(parentId);
-      const parentCommunication = await this.getParentCommunicationModeForChild(
+      const childRegistryEntry = await this.getParentRegistryEntryForChild(
         parentStub,
         parentThreadId,
         threadId
       );
+      const parentCommunication = childRegistryEntry?.parentCommunication === "explicit" ? "explicit" : "implicit";
       if (parentCommunication !== "explicit") {
         await parentStub.queueMessage(parentThreadId, {
           role: "user",
@@ -28521,11 +28606,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Write a file to storage (RPC method)
    */
-  async writeFile(path, data, mimeType, options) {
+  async writeFile(path2, data, mimeType, options) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const existingFile = await fs.stat(path);
+      const fs2 = this.getFileStorage();
+      const existingFile = await fs2.stat(path2);
       const isUpdate = existingFile !== null;
       const binaryString = atob(data);
       const dataBuffer = new Uint8Array(binaryString.length);
@@ -28547,12 +28632,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
           }
         }
       }
-      const record = await fs.writeFile(path, dataBuffer, mimeType, {
+      const record = await fs2.writeFile(path2, dataBuffer, mimeType, {
         metadata: options?.metadata,
         thumbnail: thumbnailBuffer
       });
       this.broadcastEvent(isUpdate ? "file_updated" : "file_created", {
-        path,
+        path: path2,
         file: record
       });
       return { success: true, file: record };
@@ -28564,15 +28649,15 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Write a text file to storage (RPC method)
    */
-  async writeTextFile(path, content, mimeType = "text/plain", options) {
+  async writeTextFile(path2, content, mimeType = "text/plain", options) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const existingFile = await fs.stat(path);
+      const fs2 = this.getFileStorage();
+      const existingFile = await fs2.stat(path2);
       const isUpdate = existingFile !== null;
-      const record = await fs.writeFile(path, content, mimeType, options);
+      const record = await fs2.writeFile(path2, content, mimeType, options);
       this.broadcastEvent(isUpdate ? "file_updated" : "file_created", {
-        path,
+        path: path2,
         file: record
       });
       return { success: true, file: record };
@@ -28609,11 +28694,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Link to an external file (RPC method)
    */
-  async linkFile(path, location, options) {
+  async linkFile(path2, location, options) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const record = await fs.linkFile(path, location, options);
+      const fs2 = this.getFileStorage();
+      const record = await fs2.linkFile(path2, location, options);
       return { success: true, file: record };
     } catch (error) {
       console.error("Error in linkFile:", error);
@@ -28624,11 +28709,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Read a file from storage (RPC method)
    * Returns base64-encoded data
    */
-  async readFile(path) {
+  async readFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const data = await fs.readFile(path);
+      const fs2 = this.getFileStorage();
+      const data = await fs2.readFile(path2);
       if (data === null) {
         return { success: false, error: "File not found or external" };
       }
@@ -28647,11 +28732,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Read a text file from storage (RPC method)
    */
-  async readTextFile(path) {
+  async readTextFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const content = await fs.readTextFile(path);
+      const fs2 = this.getFileStorage();
+      const content = await fs2.readTextFile(path2);
       if (content === null) {
         return { success: false, error: "File not found or external" };
       }
@@ -28664,11 +28749,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Get file metadata (RPC method)
    */
-  async statFile(path) {
+  async statFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const record = await fs.stat(path);
+      const fs2 = this.getFileStorage();
+      const record = await fs2.stat(path2);
       if (record === null) {
         return { success: false, error: "File not found" };
       }
@@ -28681,11 +28766,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Check if file exists (RPC method)
    */
-  async fileExists(path) {
+  async fileExists(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const exists2 = await fs.exists(path);
+      const fs2 = this.getFileStorage();
+      const exists2 = await fs2.exists(path2);
       return { success: true, exists: exists2 };
     } catch (error) {
       console.error("Error in fileExists:", error);
@@ -28695,12 +28780,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Delete a file (RPC method)
    */
-  async unlinkFile(path) {
+  async unlinkFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      await fs.unlink(path);
-      this.broadcastEvent("file_deleted", { path });
+      const fs2 = this.getFileStorage();
+      await fs2.unlink(path2);
+      this.broadcastEvent("file_deleted", { path: path2 });
       return { success: true };
     } catch (error) {
       console.error("Error in unlinkFile:", error);
@@ -28710,12 +28795,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Create a directory (RPC method)
    */
-  async mkdirFile(path) {
+  async mkdirFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const record = await fs.mkdir(path);
-      this.broadcastEvent("file_created", { path, file: record });
+      const fs2 = this.getFileStorage();
+      const record = await fs2.mkdir(path2);
+      this.broadcastEvent("file_created", { path: path2, file: record });
       return { success: true, directory: record };
     } catch (error) {
       console.error("Error in mkdirFile:", error);
@@ -28725,11 +28810,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * List directory contents (RPC method)
    */
-  async readdirFile(path) {
+  async readdirFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const files = await fs.readdir(path);
+      const fs2 = this.getFileStorage();
+      const files = await fs2.readdir(path2);
       return { success: true, files };
     } catch (error) {
       console.error("Error in readdirFile:", error);
@@ -28739,12 +28824,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Remove empty directory (RPC method)
    */
-  async rmdirFile(path) {
+  async rmdirFile(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      await fs.rmdir(path);
-      this.broadcastEvent("file_deleted", { path });
+      const fs2 = this.getFileStorage();
+      await fs2.rmdir(path2);
+      this.broadcastEvent("file_deleted", { path: path2 });
       return { success: true };
     } catch (error) {
       console.error("Error in rmdirFile:", error);
@@ -28759,9 +28844,9 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const fs = this.getFileStorage();
+      const fs2 = this.getFileStorage();
       const from = normalizePath2(sourcePath);
-      const record = await fs.move(sourcePath, destinationPath);
+      const record = await fs2.move(sourcePath, destinationPath);
       this.broadcastEvent("file_moved", { from, path: record.path, file: record });
       this.broadcastEvent("file_deleted", { path: from });
       this.broadcastEvent("file_created", { path: record.path, file: record });
@@ -28774,13 +28859,13 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Rename a file or directory in place (RPC method).
    */
-  async renameFile(path, newName) {
+  async renameFile(path2, newName) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const fs = this.getFileStorage();
-      const from = normalizePath2(path);
-      const record = await fs.rename(path, newName);
+      const fs2 = this.getFileStorage();
+      const from = normalizePath2(path2);
+      const record = await fs2.rename(path2, newName);
       this.broadcastEvent("file_moved", { from, path: record.path, file: record });
       this.broadcastEvent("file_deleted", { path: from });
       this.broadcastEvent("file_created", { path: record.path, file: record });
@@ -28796,8 +28881,8 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   async getFileStats() {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const stats = await fs.getFileStats();
+      const fs2 = this.getFileStorage();
+      const stats = await fs2.getFileStats();
       return { success: true, stats };
     } catch (error) {
       console.error("Error in getFileStats:", error);
@@ -28808,11 +28893,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Get thumbnail for an image (RPC method)
    * Returns base64-encoded data
    */
-  async getFileThumbnail(path) {
+  async getFileThumbnail(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const data = await fs.getThumbnail(path);
+      const fs2 = this.getFileStorage();
+      const data = await fs2.getThumbnail(path2);
       if (data === null) {
         return { success: false, error: "Thumbnail not found" };
       }
@@ -28834,8 +28919,8 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   async grepFiles(pattern, options) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const results = await fs.grep(pattern, options);
+      const fs2 = this.getFileStorage();
+      const results = await fs2.grep(pattern, options);
       return { success: true, results };
     } catch (error) {
       console.error("Error in grepFiles:", error);
@@ -28848,8 +28933,8 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   async findFiles(pattern, options) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const files = await fs.find(pattern, options);
+      const fs2 = this.getFileStorage();
+      const files = await fs2.find(pattern, options);
       return { success: true, files };
     } catch (error) {
       console.error("Error in findFiles:", error);
@@ -28864,11 +28949,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Creates file record with is_chunked=1 and chunk_count=null.
    * Caller should then use writeFileChunk() to write chunks.
    */
-  async startChunkedUpload(path, totalSize, mimeType, options) {
+  async startChunkedUpload(path2, totalSize, mimeType, options) {
     await this.ensureMigrated();
     try {
       const { CHUNK_SIZE: CHUNK_SIZE2, normalizePath: normalizePath2, basename: basename2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const normalizedPath = normalizePath2(path);
+      const normalizedPath = normalizePath2(path2);
       const name = basename2(normalizedPath);
       const now = Date.now();
       const expectedChunks = Math.ceil(totalSize / CHUNK_SIZE2);
@@ -28905,11 +28990,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * @param chunkIndex - 0-based chunk index
    * @param data - Base64 encoded chunk data
    */
-  async writeFileChunk(path, chunkIndex, data) {
+  async writeFileChunk(path2, chunkIndex, data) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const normalizedPath = normalizePath2(path);
+      const normalizedPath = normalizePath2(path2);
       const binaryString = atob(data);
       const dataBuffer = new Uint8Array(binaryString.length);
       for (let i = 0; i < binaryString.length; i++) {
@@ -28931,12 +29016,12 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Complete a chunked file upload.
    * Validates all chunks are present and sets chunk_count.
    */
-  async completeChunkedUpload(path, expectedChunks, options) {
+  async completeChunkedUpload(path2, expectedChunks, options) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const fs = this.getFileStorage();
-      const normalizedPath = normalizePath2(path);
+      const fs2 = this.getFileStorage();
+      const normalizedPath = normalizePath2(path2);
       const countResult = await this.ctx.storage.sql.exec(
         `SELECT COUNT(*) as count FROM file_chunks WHERE file_path = ?`,
         normalizedPath
@@ -28962,7 +29047,7 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
         thumbnailBuffer || null,
         normalizedPath
       );
-      const file = await fs.stat(normalizedPath);
+      const file = await fs2.stat(normalizedPath);
       if (file) {
         this.broadcastEvent("file_created", { path: normalizedPath, file });
       }
@@ -28976,11 +29061,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
    * Read a single chunk of a file.
    * Use for streaming large files to client.
    */
-  async readFileChunk(path, chunkIndex) {
+  async readFileChunk(path2, chunkIndex) {
     await this.ensureMigrated();
     try {
       const { normalizePath: normalizePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
-      const normalizedPath = normalizePath2(path);
+      const normalizedPath = normalizePath2(path2);
       const cursor = await this.ctx.storage.sql.exec(
         `SELECT data FROM file_chunks WHERE file_path = ? AND chunk_index = ?`,
         normalizedPath,
@@ -29005,11 +29090,11 @@ Its execution was lost (the executor restarted or hung) and automatic recovery w
   /**
    * Get file info including chunking metadata.
    */
-  async getFileInfo(path) {
+  async getFileInfo(path2) {
     await this.ensureMigrated();
     try {
-      const fs = this.getFileStorage();
-      const file = await fs.stat(path);
+      const fs2 = this.getFileStorage();
+      const file = await fs2.stat(path2);
       if (!file) {
         return { success: false, error: "File not found" };
       }
@@ -29227,16 +29312,16 @@ function parseUserRouteKey(key) {
   }
   return { key, method, segments, dynamism };
 }
-function matchSegments(route, path) {
+function matchSegments(route, path2) {
   const params = {};
   for (let i = 0; i < route.length; i++) {
     const seg = route[i];
     if (seg === "[*]") {
       if (i !== route.length - 1) return null;
-      params["*"] = path.slice(i).join("/");
+      params["*"] = path2.slice(i).join("/");
       return params;
     }
-    const value = path[i];
+    const value = path2[i];
     if (value === void 0) return null;
     if (seg.startsWith("[") && seg.endsWith("]")) {
       params[seg.slice(1, -1)] = value;
@@ -29244,16 +29329,16 @@ function matchSegments(route, path) {
       return null;
     }
   }
-  return path.length === route.length ? params : null;
+  return path2.length === route.length ? params : null;
 }
 function matchUserRoute(keys, method, endpointPath) {
-  const path = endpointPath.split("/").filter((s) => s.length > 0);
+  const path2 = endpointPath.split("/").filter((s) => s.length > 0);
   const wanted = method.toUpperCase();
   let best = null;
   for (const key of keys) {
     const route = parseUserRouteKey(key);
     if (route.method !== wanted) continue;
-    const params = matchSegments(route.segments, path);
+    const params = matchSegments(route.segments, path2);
     if (!params) continue;
     if (!best || route.dynamism < best.route.dynamism) {
       best = { route, params };