@townco/agent 0.1.112 → 0.1.113

package/dist/runner/langchain/tools/subagent.js

@@ -1,46 +1,17 @@
-import { spawn } from "node:child_process";
+import * as crypto from "node:crypto";
 import * as fs from "node:fs/promises";
+import { mkdir } from "node:fs/promises";
 import * as path from "node:path";
-import { PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
 import { context, propagation, trace } from "@opentelemetry/api";
-import { createLogger as coreCreateLogger } from "@townco/core";
 import { z } from "zod";
 import { SUBAGENT_MODE_KEY, } from "../../../acp-server/adapter.js";
-import { getAbortSignal } from "../../session-context.js";
-import { findAvailablePort } from "./port-utils.js";
-import { emitSubagentConnection, emitSubagentMessages, hashQuery, } from "./subagent-connections.js";
+import { makeRunnerFromDefinition } from "../../index.js";
+import { bindGeneratorToSessionContext, getAbortSignal, } from "../../session-context.js";
+import { emitSubagentMessages, hashQuery, } from "./subagent-connections.js";
 /**
  * Name of the Task tool created by makeSubagentsTool
  */
 export const SUBAGENT_TOOL_NAME = "subagent";
-/**
- * Base port for subagent HTTP servers (avoid conflict with main agents at 3100+)
- */
-const SUBAGENT_BASE_PORT = 4000;
-/**
- * Wait for HTTP server to be ready by polling health endpoint
- */
-async function waitForServerReady(port, timeoutMs = 30000) {
-    const startTime = Date.now();
-    const baseDelay = 50;
-    let attempt = 0;
-    while (Date.now() - startTime < timeoutMs) {
-        try {
-            const response = await fetch(`http://localhost:${port}/health`, {
-                signal: AbortSignal.timeout(1000),
-            });
-            if (response.ok) {
-                return;
-            }
-        }
-        catch {
-            // Server not ready yet
-        }
-        await new Promise((r) => setTimeout(r, baseDelay * 1.5 ** attempt));
-        attempt++;
-    }
-    throw new Error(`Subagent server at port ${port} did not become ready within ${timeoutMs}ms`);
-}
 /**
  * Creates a DirectTool that delegates work to one of multiple configured subagents.
  *
@@ -74,8 +45,10 @@ export function makeSubagentsTool(configs) {
         let agentPath;
         let agentDir;
         if ("path" in config) {
-            // Direct path variant
-            agentPath = config.path;
+            // Direct path variant - resolve to absolute path
+            agentPath = path.isAbsolute(config.path)
+                ? config.path
+                : path.resolve(process.cwd(), config.path);
             agentDir = path.dirname(agentPath);
         }
         else {
@@ -181,379 +154,165 @@ assistant: "I'm going to use the Task tool to launch the greeting-responder agen
     };
 }
 /**
- * Internal function that spawns a subagent HTTP server and queries it.
+ * Internal function that runs a subagent in-process and queries it.
  */
 async function querySubagent(agentName, agentPath, agentWorkingDirectory, query) {
     // Get the abort signal from context (set by parent agent's cancellation)
     const parentAbortSignal = getAbortSignal();
     // Check if already cancelled before starting
     if (parentAbortSignal?.aborted) {
-        throw new Error("Subagent query cancelled before starting");
+        throw new Error(`Subagent query cancelled before starting (agent: ${agentName})`);
     }
     // Validate that the agent exists
     try {
         await fs.access(agentPath);
     }
     catch (_error) {
-        throw new Error(`Agent not found at ${agentPath}. Make sure the agent exists and has an index.ts file.`);
+        throw new Error(`Subagent '${agentName}' not found at ${agentPath}. Make sure the agent exists and has an index.ts file.`);
     }
-    // Find an available port for this subagent
-    const port = await findAvailablePort(SUBAGENT_BASE_PORT, 100);
-    // Create a logger for this subagent instance with port prefix
-    // Use core logger directly since service name already identifies the subagent
-    const logger = coreCreateLogger(`subagent:${port}:${agentName}`);
-    let agentProcess = null;
-    let sseAbortController = null;
-    let cleanupTriggered = false;
-    // Cleanup function to kill the process and abort SSE
-    const cleanup = () => {
-        if (cleanupTriggered)
-            return;
-        cleanupTriggered = true;
-        logger.info(`Cleaning up subagent on port ${port} (cancelled by parent)`);
-        if (sseAbortController) {
-            sseAbortController.abort();
-        }
-        if (agentProcess) {
-            agentProcess.kill("SIGTERM");
-        }
-    };
-    // Listen for parent abort signal
-    if (parentAbortSignal) {
-        parentAbortSignal.addEventListener("abort", cleanup, { once: true });
+    // Load agent definition dynamically
+    const agentModule = await import(agentPath);
+    const agentDefinition = agentModule.default || agentModule.agent;
+    // Create runner instance
+    const runner = makeRunnerFromDefinition(agentDefinition);
+    // Generate unique session ID for isolation
+    const subagentSessionId = crypto.randomUUID();
+    // Setup session paths
+    const sessionDir = path.join(agentWorkingDirectory, ".sessions", subagentSessionId);
+    const artifactsDir = path.join(sessionDir, "artifacts");
+    await mkdir(artifactsDir, { recursive: true });
+    // Prepare OTEL context for distributed tracing
+    const activeCtx = context.active();
+    const activeSpan = trace.getSpan(activeCtx);
+    const otelCarrier = {};
+    if (activeSpan) {
+        propagation.inject(trace.setSpan(activeCtx, activeSpan), otelCarrier);
     }
+    // Create invoke request
+    const invokeRequest = {
+        sessionId: subagentSessionId,
+        messageId: crypto.randomUUID(),
+        prompt: [{ type: "text", text: query }],
+        agentDir: agentWorkingDirectory,
+        contextMessages: [],
+        ...(parentAbortSignal ? { abortSignal: parentAbortSignal } : {}),
+        sessionMeta: {
+            [SUBAGENT_MODE_KEY]: true,
+            ...(Object.keys(otelCarrier).length > 0
+                ? { otelTraceContext: otelCarrier }
+                : {}),
+        },
+    };
+    // Bind session context and invoke
+    let generator = runner.invoke(invokeRequest);
+    generator = bindGeneratorToSessionContext({ sessionId: subagentSessionId, sessionDir, artifactsDir }, generator);
+    // Consume stream, accumulate results, and emit incremental updates
+    let responseText = "";
+    const collectedSources = [];
+    const currentMessage = {
+        id: `subagent-${Date.now()}`,
+        content: "",
+        contentBlocks: [],
+        toolCalls: [],
+    };
+    const toolCallMap = new Map();
+    const queryHash = hashQuery(query);
     try {
-        // Get the parent's logs directory to pass to the subagent
-        const parentLogsDir = process.env.TOWN_LOGS_DIR || path.join(process.cwd(), ".logs");
-        // Spawn the agent process in HTTP mode
-        agentProcess = spawn("bun", [agentPath, "http"], {
-            cwd: agentWorkingDirectory,
-            env: {
-                ...process.env,
-                PORT: String(port),
-                TOWN_LOGS_DIR: parentLogsDir,
-                TOWN_SUBAGENT_NAME: agentName,
-            },
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        if (!agentProcess.stderr) {
-            throw new Error("Failed to create stderr pipe for agent process");
-        }
-        // Capture stdout and forward to logger
-        if (agentProcess.stdout) {
-            agentProcess.stdout.on("data", (data) => {
-                const lines = data
-                    .toString()
-                    .split("\n")
-                    .filter((line) => line.trim());
-                for (const line of lines) {
-                    logger.info(line);
+        for await (const update of generator) {
+            let shouldEmit = false;
+            // Handle agent_message_chunk
+            if (update.sessionUpdate === "agent_message_chunk") {
+                const content = update.content;
+                if (content?.type === "text" && typeof content.text === "string") {
+                    responseText += content.text;
+                    currentMessage.content += content.text;
+                    const lastBlock = currentMessage.contentBlocks[currentMessage.contentBlocks.length - 1];
+                    if (lastBlock && lastBlock.type === "text") {
+                        lastBlock.text += content.text;
+                    }
+                    else {
+                        currentMessage.contentBlocks.push({
+                            type: "text",
+                            text: content.text,
+                        });
+                    }
+                    shouldEmit = true; // Emit after each text chunk
                 }
-            });
-        }
-        // Capture stderr and forward to logger as errors
-        agentProcess.stderr.on("data", (data) => {
-            const lines = data
-                .toString()
-                .split("\n")
-                .filter((line) => line.trim());
-            for (const line of lines) {
-                logger.error(line);
             }
-        });
-        // Handle process errors
-        const processErrorPromise = new Promise((_, reject) => {
-            agentProcess?.on("error", (error) => {
-                logger.error(`Process error: ${error.message}`);
-                reject(new Error(`Agent process error: ${error.message}`));
-            });
-            agentProcess?.on("exit", (code, signal) => {
-                if (code !== 0 && code !== null) {
-                    logger.error(`Process exited with code ${code}, signal ${signal}`);
-                    reject(new Error(`Agent process exited unexpectedly with code ${code}, signal ${signal}`));
-                }
-            });
-        });
-        logger.info(`Starting subagent HTTP server on port ${port}`);
-        // Wait for server to be ready
-        await Promise.race([waitForServerReady(port), processErrorPromise]);
-        logger.info(`Subagent server ready on port ${port}`);
-        const baseUrl = `http://localhost:${port}`;
-        // Step 1: Initialize ACP connection
-        const initResponse = await fetch(`${baseUrl}/rpc`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                id: "init-1",
-                method: "initialize",
-                params: {
-                    protocolVersion: PROTOCOL_VERSION,
-                    clientCapabilities: {
-                        fs: { readTextFile: false, writeTextFile: false },
-                    },
-                },
-            }),
-        });
-        if (!initResponse.ok) {
-            throw new Error(`Initialize failed: HTTP ${initResponse.status}`);
-        }
-        // Step 2: Create new session with subagent mode and OTEL context
-        // Prepare OpenTelemetry trace context to propagate to the subagent
-        const otelCarrier = {};
-        const activeCtx = context.active();
-        const activeSpan = trace.getSpan(activeCtx);
-        if (process.env.DEBUG_TELEMETRY === "true") {
-            console.log(`[querySubagent] Active span when tool executes:`, activeSpan?.spanContext());
-        }
-        if (activeSpan) {
-            const ctxForInjection = trace.setSpan(activeCtx, activeSpan);
-            propagation.inject(ctxForInjection, otelCarrier);
-        }
-        const hasOtelContext = Object.keys(otelCarrier).length > 0;
-        const sessionResponse = await fetch(`${baseUrl}/rpc`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                id: "session-1",
-                method: "session/new",
-                params: {
-                    cwd: agentWorkingDirectory,
-                    mcpServers: [],
-                    _meta: {
-                        [SUBAGENT_MODE_KEY]: true,
-                        ...(hasOtelContext ? { otelTraceContext: otelCarrier } : {}),
-                    },
-                },
-            }),
-        });
-        if (!sessionResponse.ok) {
-            throw new Error(`Session creation failed: HTTP ${sessionResponse.status}`);
-        }
-        const sessionResult = (await sessionResponse.json());
-        const sessionId = sessionResult.result?.sessionId;
-        if (!sessionId) {
-            throw new Error("No sessionId in session/new response");
-        }
-        // Emit connection info so the GUI can connect directly to this subagent's SSE
-        const queryHash = hashQuery(query);
-        emitSubagentConnection(queryHash, { port, sessionId });
-        // Step 3: Connect to SSE for receiving streaming responses
-        sseAbortController = new AbortController();
-        let responseText = "";
-        // Track citation sources from subagent's web searches/fetches
-        const collectedSources = [];
-        // Track full message structure for session storage
-        const currentMessage = {
-            id: `subagent-${Date.now()}`,
-            content: "",
-            contentBlocks: [],
-            toolCalls: [],
-        };
-        // Map of tool call IDs to their indices in toolCalls array
-        const toolCallMap = new Map();
-        const ssePromise = (async () => {
-            try {
-                const sseResponse = await fetch(`${baseUrl}/events`, {
-                    headers: { "X-Session-ID": sessionId },
-                    signal: sseAbortController?.signal,
-                });
-                if (!sseResponse.ok || !sseResponse.body) {
-                    throw new Error(`SSE connection failed: HTTP ${sseResponse.status}`);
-                }
-                const reader = sseResponse.body.getReader();
-                const decoder = new TextDecoder();
-                let buffer = "";
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    buffer += decoder.decode(value, { stream: true });
-                    const lines = buffer.split("\n");
-                    buffer = lines.pop() || "";
-                    for (const line of lines) {
-                        if (line.startsWith("data:")) {
-                            const data = line.substring(5).trim();
-                            if (!data)
-                                continue;
-                            try {
-                                const message = JSON.parse(data);
-                                const update = message.params?.update;
-                                if (message.method !== "session/update" || !update)
-                                    continue;
-                                // Handle agent_message_chunk - accumulate text
-                                if (update.sessionUpdate === "agent_message_chunk") {
-                                    const content = update.content;
-                                    if (content?.type === "text" &&
-                                        typeof content.text === "string") {
-                                        responseText += content.text;
-                                        currentMessage.content += content.text;
-                                        // Add to contentBlocks - append to last text block or create new one
-                                        const lastBlock = currentMessage.contentBlocks[currentMessage.contentBlocks.length - 1];
-                                        if (lastBlock && lastBlock.type === "text") {
-                                            lastBlock.text += content.text;
-                                        }
-                                        else {
-                                            currentMessage.contentBlocks.push({
-                                                type: "text",
-                                                text: content.text,
-                                            });
-                                        }
-                                    }
-                                }
-                                // Handle tool_call - track new tool calls
-                                if (update.sessionUpdate === "tool_call" && update.toolCallId) {
-                                    const toolCall = {
-                                        id: update.toolCallId,
-                                        title: update.title || "Tool call",
-                                        prettyName: update._meta?.prettyName,
-                                        icon: update._meta?.icon,
-                                        status: update.status ||
-                                            "pending",
-                                    };
-                                    currentMessage.toolCalls.push(toolCall);
-                                    toolCallMap.set(update.toolCallId, currentMessage.toolCalls.length - 1);
-                                    // Add to contentBlocks for interleaved display
-                                    currentMessage.contentBlocks.push({
-                                        type: "tool_call",
-                                        toolCall,
-                                    });
-                                }
-                                // Handle tool_call_update - update existing tool call status
-                                if (update.sessionUpdate === "tool_call_update" &&
-                                    update.toolCallId) {
-                                    const idx = toolCallMap.get(update.toolCallId);
-                                    if (idx !== undefined && currentMessage.toolCalls[idx]) {
-                                        if (update.status) {
-                                            currentMessage.toolCalls[idx].status =
-                                                update.status;
-                                        }
-                                        // Also update in contentBlocks
-                                        const block = currentMessage.contentBlocks.find((b) => b.type === "tool_call" &&
-                                            b.toolCall.id === update.toolCallId);
-                                        if (block && update.status) {
-                                            block.toolCall.status =
-                                                update.status;
-                                        }
-                                    }
-                                }
-                                // Handle sources - collect citation sources from subagent's web searches
-                                if (update.sessionUpdate === "sources" &&
-                                    Array.isArray(update.sources)) {
-                                    for (const source of update.sources) {
-                                        const citationSource = {
-                                            id: source.id,
-                                            url: source.url,
-                                            title: source.title,
-                                            toolCallId: source.toolCallId,
-                                        };
-                                        if (source.snippet)
-                                            citationSource.snippet = source.snippet;
-                                        if (source.favicon)
-                                            citationSource.favicon = source.favicon;
-                                        if (source.sourceName)
-                                            citationSource.sourceName = source.sourceName;
-                                        collectedSources.push(citationSource);
-                                    }
-                                    logger.info(`Collected ${update.sources.length} sources from subagent`);
-                                }
-                            }
-                            catch {
-                                // Ignore malformed SSE data
-                            }
-                        }
+            // Handle tool_call
+            if (update.sessionUpdate === "tool_call" && update.toolCallId) {
+                const meta = update._meta;
+                const toolCall = {
+                    id: update.toolCallId,
+                    title: update.title || "Tool call",
+                    prettyName: meta?.prettyName,
+                    icon: meta?.icon,
+                    status: update.status || "pending",
+                };
+                currentMessage.toolCalls.push(toolCall);
+                toolCallMap.set(update.toolCallId, currentMessage.toolCalls.length - 1);
+                currentMessage.contentBlocks.push({ type: "tool_call", toolCall });
+                shouldEmit = true; // Emit when new tool call appears
+            }
+            // Handle tool_call_update
+            if (update.sessionUpdate === "tool_call_update" && update.toolCallId) {
+                const idx = toolCallMap.get(update.toolCallId);
+                if (idx !== undefined && currentMessage.toolCalls[idx]) {
+                    if (update.status) {
+                        currentMessage.toolCalls[idx].status =
+                            update.status;
                     }
+                    const block = currentMessage.contentBlocks.find((b) => b.type === "tool_call" && b.toolCall.id === update.toolCallId);
+                    if (block && update.status) {
+                        block.toolCall.status = update.status;
+                    }
+                    shouldEmit = true; // Emit when tool status changes
                 }
             }
-            catch (error) {
-                // Ignore AbortError - this is expected when we abort the SSE connection
-                if (error instanceof DOMException && error.name === "AbortError") {
-                    return;
+            // Handle sources (from ACP protocol)
+            if ("sources" in update && Array.isArray(update.sources)) {
+                const sources = update.sources;
+                for (const source of sources) {
+                    const citationSource = {
+                        id: source.id,
+                        url: source.url,
+                        title: source.title,
+                        toolCallId: source.toolCallId,
+                    };
+                    if (source.snippet)
+                        citationSource.snippet = source.snippet;
+                    if (source.favicon)
+                        citationSource.favicon = source.favicon;
+                    if (source.sourceName)
+                        citationSource.sourceName = source.sourceName;
+                    collectedSources.push(citationSource);
                 }
-                throw error;
-            }
-        })();
-        // Step 4: Send the prompt with timeout
-        const timeoutMs = 5 * 60 * 1000; // 5 minutes
-        const promptPromise = (async () => {
-            const promptResponse = await fetch(`${baseUrl}/rpc`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    jsonrpc: "2.0",
-                    id: "prompt-1",
-                    method: "session/prompt",
-                    params: {
-                        sessionId,
-                        prompt: [{ type: "text", text: query }],
-                    },
-                }),
-            });
-            if (!promptResponse.ok) {
-                throw new Error(`Prompt failed: HTTP ${promptResponse.status}`);
+                shouldEmit = true; // Emit when sources are added
             }
-            // Wait for prompt to complete (this blocks until agent finishes processing)
-            const promptResult = (await promptResponse.json());
-            if (promptResult.error) {
-                throw new Error(`Prompt error: ${promptResult.error.message || JSON.stringify(promptResult.error)}`);
+            // Emit incremental update to parent (for live streaming)
+            if (shouldEmit) {
+                emitSubagentMessages(queryHash, [{ ...currentMessage }]);
             }
-        })();
-        const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => {
-                reject(new Error(`Subagent query timed out after ${timeoutMs / 1000} seconds`));
-            }, timeoutMs);
-        });
-        // Create cancellation promise that rejects when parent aborts
-        const cancellationPromise = parentAbortSignal
-            ? new Promise((_, reject) => {
-                if (parentAbortSignal.aborted) {
-                    reject(new Error("Subagent query cancelled"));
-                }
-                parentAbortSignal.addEventListener("abort", () => reject(new Error("Subagent query cancelled")), { once: true });
-            })
-            : new Promise(() => { }); // Never resolves if no signal
-        // Wait for prompt to complete with timeout or cancellation
-        await Promise.race([
-            promptPromise,
-            timeoutPromise,
-            processErrorPromise,
-            cancellationPromise,
-        ]);
-        // Check if cancelled before processing results
-        if (parentAbortSignal?.aborted) {
-            throw new Error("Subagent query cancelled");
         }
-        // Give SSE a moment to flush remaining messages
-        await new Promise((r) => setTimeout(r, 100));
-        // Abort SSE connection
-        sseAbortController.abort();
-        // Wait for SSE to finish (with timeout)
-        await Promise.race([
-            ssePromise.catch(() => { }), // Ignore abort errors
-            new Promise((r) => setTimeout(r, 1000)),
-        ]);
-        // Emit accumulated messages for session storage
+        // Final emit to ensure everything is captured, with completion flag
         if (currentMessage.content || currentMessage.toolCalls.length > 0) {
-            emitSubagentMessages(queryHash, [currentMessage]);
+            emitSubagentMessages(queryHash, [currentMessage], true);
+        }
+        else {
+            // Even if no messages, emit completion sentinel
+            emitSubagentMessages(queryHash, [], true);
         }
         return {
             text: responseText,
             sources: collectedSources,
         };
     }
-    finally {
-        // Remove the abort listener to prevent memory leaks
-        if (parentAbortSignal) {
-            parentAbortSignal.removeEventListener("abort", cleanup);
-        }
-        // Cleanup: abort SSE and kill process
-        logger.info(`Shutting down subagent on port ${port}`);
-        if (sseAbortController) {
-            sseAbortController.abort();
-        }
-        if (agentProcess) {
-            agentProcess.kill();
+    catch (error) {
+        // Emit completion sentinel even on error to prevent parent from hanging
+        emitSubagentMessages(queryHash, [], true);
+        if (parentAbortSignal?.aborted) {
+            throw new Error("Subagent query cancelled");
         }
+        throw error;
     }
 }

package/dist/runner/session-context.d.ts

@@ -16,6 +16,14 @@ export interface SessionContext {
  * Tools can access this to emit events like sandbox file changes.
  */
 type EmitUpdateCallback = (update: SessionUpdateNotification) => void;
+/**
+ * Invocation context for scoping subagent events to a specific invocation.
+ * Each invoke() creates its own EventEmitter so subagents emit to the correct parent.
+ */
+export interface InvocationContext {
+    invocationId: string;
+    subagentEventEmitter: import("node:events").EventEmitter;
+}
 /**
  * Run a function with an abort signal available via AsyncLocalStorage.
  * Tools can access the signal using getAbortSignal().
@@ -74,4 +82,14 @@ export declare function hasSessionContext(): boolean;
  * @returns Absolute path to the tool's output directory
  */
 export declare function getToolOutputDir(toolName: string): string;
+/**
+ * Get the current invocation context.
+ * Returns undefined if called outside of an invocation context.
+ */
+export declare function getInvocationContext(): InvocationContext | undefined;
+/**
+ * Bind an async generator to an invocation context so that every iteration
+ * runs with the invocation context available.
+ */
+export declare function bindGeneratorToInvocationContext<T, R, N = unknown>(ctx: InvocationContext, generator: AsyncGenerator<T, R, N>): AsyncGenerator<T, R, N>;
 export {};

package/dist/runner/session-context.js

@@ -7,6 +7,7 @@ const sessionStorage = new AsyncLocalStorage();
  */
 const abortSignalStorage = new AsyncLocalStorage();
 const emitUpdateStorage = new AsyncLocalStorage();
+const invocationContextStorage = new AsyncLocalStorage();
 /**
  * Run a function with an abort signal available via AsyncLocalStorage.
  * Tools can access the signal using getAbortSignal().
@@ -156,3 +157,37 @@ export function getToolOutputDir(toolName) {
     const ctx = getSessionContext();
     return path.join(ctx.artifactsDir, `tool-${toolName}`);
 }
+/**
+ * Get the current invocation context.
+ * Returns undefined if called outside of an invocation context.
+ */
+export function getInvocationContext() {
+    return invocationContextStorage.getStore();
+}
+/**
+ * Bind an async generator to an invocation context so that every iteration
+ * runs with the invocation context available.
+ */
+export function bindGeneratorToInvocationContext(ctx, generator) {
+    const boundNext = (value) => invocationContextStorage.run(ctx, () => generator.next(value));
+    const boundReturn = generator.return
+        ? (value) => invocationContextStorage.run(ctx, () => generator.return?.(value))
+        : undefined;
+    const boundThrow = generator.throw
+        ? (e) => invocationContextStorage.run(ctx, () => generator.throw?.(e))
+        : undefined;
+    const boundGenerator = {
+        next: boundNext,
+        return: boundReturn,
+        throw: boundThrow,
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+        [Symbol.asyncDispose]: async () => {
+            if (Symbol.asyncDispose in generator) {
+                await generator[Symbol.asyncDispose]();
+            }
+        },
+    };
+    return boundGenerator;
+}