@webless/agent 0.6.7 → 0.6.9

package/dist/{chunk-U5IPERNA.js → chunk-U2SU2CGF.js}

@@ -1291,6 +1291,203 @@ function clearPersistedAgentSession(visitorSessionId, options) {
   sessionStorage.removeItem(runtimeLastMessageKey(visitorSessionId, prefix));
 }
 
+// src/runtime/subagent-child-stream.ts
+var INITIAL_RETRY_DELAY_MS = 100;
+var MAX_RETRY_DELAY_MS = 2e3;
+var MAX_CONSECUTIVE_RETRIES = 6;
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseError(value) {
+  if (!isRecord4(value)) return void 0;
+  const { code, message } = value;
+  if (typeof code !== "string" || typeof message !== "string") {
+    return void 0;
+  }
+  return { code, message };
+}
+function parseChildStreamEvent(value) {
+  if (!isRecord4(value) || typeof value.type !== "string") {
+    return { type: "other" };
+  }
+  if (value.type === "session.waiting" || value.type === "session.completed" || value.type === "session.failed") {
+    return { type: "session.boundary" };
+  }
+  if (value.type === "subagent.event" && isRecord4(value.data) && Object.hasOwn(value.data, "event")) {
+    return parseChildStreamEvent(value.data.event);
+  }
+  if (value.type === "subagent.called" && isRecord4(value.data)) {
+    const { childStreamPath } = value.data;
+    if (typeof childStreamPath === "string") {
+      return { childStreamPath, type: "subagent.called" };
+    }
+  }
+  if (value.type !== "action.result" || !isRecord4(value.data)) {
+    return { type: "other" };
+  }
+  const { data } = value;
+  if (data.status !== "completed" && data.status !== "failed" && data.status !== "rejected") {
+    return { type: "other" };
+  }
+  if (!isRecord4(data.result) || data.result.kind !== "tool-result") {
+    return { type: "other" };
+  }
+  const result = data.result;
+  if (typeof result.callId !== "string" || typeof result.toolName !== "string") {
+    return { type: "other" };
+  }
+  const error = parseError(data.error);
+  return {
+    type: "action.result",
+    hasOutput: Object.hasOwn(result, "output"),
+    result: {
+      callId: result.callId,
+      toolName: result.toolName,
+      status: data.status,
+      ...Object.hasOwn(result, "output") ? { output: result.output } : {},
+      ...error ? { error } : {}
+    }
+  };
+}
+async function* readNdjsonStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      buffer += decoder.decode(value, { stream: !done });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed2 = line.trim();
+        if (!trimmed2) continue;
+        try {
+          const parsed = JSON.parse(trimmed2);
+          yield parsed;
+        } catch {
+        }
+      }
+      if (done) break;
+    }
+    const trimmed = buffer.trim();
+    if (trimmed) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        yield parsed;
+      } catch {
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function streamPathAt(path, streamIndex) {
+  if (streamIndex === 0) return path;
+  return `${path}${path.includes("?") ? "&" : "?"}startIndex=${streamIndex}`;
+}
+function abortableDelay(delayMs, signal) {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const finish = () => {
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", finish);
+      resolve();
+    };
+    const timeout = setTimeout(finish, delayMs);
+    signal.addEventListener("abort", finish, { once: true });
+  });
+}
+var SubagentChildStreamCoordinator = class {
+  constructor(client, handlers, parentSignal) {
+    this.client = client;
+    this.handlers = handlers;
+    this.parentSignal = parentSignal;
+  }
+  client;
+  handlers;
+  parentSignal;
+  controllers = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  begin(event) {
+    this.beginPath(event.data.childStreamPath);
+  }
+  async waitForAll() {
+    let observedTaskCount = -1;
+    while (observedTaskCount !== this.tasks.size) {
+      observedTaskCount = this.tasks.size;
+      await Promise.all(this.tasks.values());
+    }
+  }
+  abortAll() {
+    for (const controller of this.controllers.values()) controller.abort();
+    this.controllers.clear();
+  }
+  beginPath(childStreamPath) {
+    if (this.tasks.has(childStreamPath)) return;
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    if (this.parentSignal.aborted) {
+      controller.abort();
+    } else {
+      this.parentSignal.addEventListener("abort", abort, { once: true });
+    }
+    this.controllers.set(childStreamPath, controller);
+    const task = this.consume(childStreamPath, controller.signal).finally(
+      () => {
+        this.parentSignal.removeEventListener("abort", abort);
+        if (this.controllers.get(childStreamPath) === controller) {
+          this.controllers.delete(childStreamPath);
+        }
+      }
+    );
+    this.tasks.set(childStreamPath, task);
+  }
+  async consume(path, signal) {
+    let streamIndex = 0;
+    let consecutiveRetries = 0;
+    let retryDelayMs = INITIAL_RETRY_DELAY_MS;
+    while (!signal.aborted && consecutiveRetries < MAX_CONSECUTIVE_RETRIES) {
+      let receivedEvent = false;
+      try {
+        const response = await this.client.fetch(
+          streamPathAt(path, streamIndex),
+          {
+            cache: "no-store",
+            signal
+          }
+        );
+        if (!response.ok || response.body === null) {
+          await response.body?.cancel().catch(() => {
+          });
+          throw new Error(`Child stream returned ${response.status}.`);
+        }
+        for await (const rawEvent of readNdjsonStream(response.body)) {
+          if (signal.aborted) return;
+          receivedEvent = true;
+          streamIndex += 1;
+          const event = parseChildStreamEvent(rawEvent);
+          if (event.type === "session.boundary") return;
+          if (event.type === "subagent.called") {
+            this.beginPath(event.childStreamPath);
+            continue;
+          }
+          if (event.type !== "action.result") continue;
+          this.handlers.onToolResult?.(event.result);
+          if (event.hasOutput) {
+            this.handlers.onActionResult?.(event.result.output);
+          }
+        }
+      } catch {
+        if (signal.aborted) return;
+      }
+      consecutiveRetries = receivedEvent ? 0 : consecutiveRetries + 1;
+      retryDelayMs = receivedEvent ? INITIAL_RETRY_DELAY_MS : Math.min(retryDelayMs * 2, MAX_RETRY_DELAY_MS);
+      await abortableDelay(retryDelayMs, signal);
+    }
+  }
+};
+
 // src/runtime/client.ts
 function isTurnBoundary(event) {
   return event.type === "session.waiting" || event.type === "session.completed" || event.type === "session.failed";
@@ -1303,8 +1500,7 @@ function applyMessageEvent(event, rendered, handlers, workItems) {
   if (event.type === "message.completed") {
     handlers.onComplete?.();
   }
-  if (event.type === "action.result") emitActionResult(event, handlers);
-  if (event.type === "input.requested") emitInputRequests(event, handlers);
+  emitVisitorInteractionEvent(event, handlers);
   if (event.type !== "message.appended") return rendered;
   const { messageDelta, messageSoFar } = event.data;
   let delta = messageDelta;
@@ -1354,6 +1550,13 @@ function emitInputRequests(event, handlers) {
     })
   );
 }
+function emitVisitorInteractionEvent(event, handlers) {
+  if (event.type === "action.result") emitActionResult(event, handlers);
+  if (event.type === "input.requested") emitInputRequests(event, handlers);
+  if (event.type === "subagent.event") {
+    emitVisitorInteractionEvent(event.data.event, handlers);
+  }
+}
 function isResumeTurnMessage(received, candidate) {
   if (received === candidate) return true;
   return Boolean(candidate) && received.endsWith(`
@@ -1526,11 +1729,14 @@ var AgentSession = class {
   clientHost;
   session;
   activeResponse;
+  childStreams;
   capability;
   getActiveSessionId() {
     return this.session?.state.sessionId ?? loadPersistedAgentSession(this.visitorSessionId, this.storeOptions)?.sessionId;
   }
   reset() {
+    this.childStreams?.abortAll();
+    this.childStreams = void 0;
     if (this.activeResponse) {
       void this.activeResponse.cancel().catch(() => {
       });
@@ -1626,6 +1832,12 @@ var AgentSession = class {
       this.persistSessionCursor(session);
     }
     this.activeResponse = response;
+    const childStreams = new SubagentChildStreamCoordinator(
+      client,
+      handlers,
+      signal
+    );
+    this.childStreams = childStreams;
     let streamIndex = session?.state.streamIndex ?? 0;
     let rendered = "";
     const workItems = /* @__PURE__ */ new Map();
@@ -1633,6 +1845,7 @@ var AgentSession = class {
     try {
       for await (const event of response) {
         if (signal.aborted) break;
+        if (event.type === "subagent.called") childStreams.begin(event);
         if (event.type === "input.requested") requestedInput = true;
         rendered = applyMessageEvent(event, rendered, handlers, workItems);
         streamIndex += 1;
@@ -1645,8 +1858,11 @@ var AgentSession = class {
           );
         }
       }
+      await childStreams.waitForAll();
     } finally {
+      childStreams.abortAll();
       this.activeResponse = void 0;
+      if (this.childStreams === childStreams) this.childStreams = void 0;
       if (session) {
         this.persistSessionCursor(session);
       }
@@ -1682,64 +1898,80 @@ var AgentSession = class {
     }
     let rendered = renderTurn(turnEvents);
     const workItems = /* @__PURE__ */ new Map();
-    for (const event of turnEvents) {
-      applyWorkEvent(event, handlers, workItems);
-      if (event.type === "input.requested") emitInputRequests(event, handlers);
-      if (event.type === "action.result") emitActionResult(event, handlers);
-    }
-    if (rendered.startsWith(initialText)) {
-      const missedText = rendered.slice(initialText.length);
-      if (missedText) handlers.onDelta(missedText);
-    } else if (initialText.startsWith(rendered)) {
-      rendered = initialText;
-    } else if (!initialText.startsWith(rendered)) {
-      rendered = initialText + rendered;
-    }
-    let session = client.sessions.attach(snapshot.session.sessionId, {
-      streamIndex: snapshot.session.streamIndex
-    });
-    this.session = session;
-    this.persistSessionCursor(session);
-    let snapshotBoundary;
-    for (let index = turnEvents.length - 1; index >= 0; index -= 1) {
-      const event = turnEvents[index];
-      if (event && isTurnBoundary(event)) {
-        snapshotBoundary = event;
-        break;
+    const childStreams = new SubagentChildStreamCoordinator(
+      client,
+      handlers,
+      signal
+    );
+    this.childStreams = childStreams;
+    try {
+      for (const event of turnEvents) {
+        if (event.type === "subagent.called") childStreams.begin(event);
+        applyWorkEvent(event, handlers, workItems);
+        emitVisitorInteractionEvent(event, handlers);
       }
-    }
-    if (snapshotBoundary) {
-      if (snapshotBoundary.type === "session.failed") {
-        throw new Error(
-          snapshotBoundary.data.message || snapshotBoundary.data.code
+      if (rendered.startsWith(initialText)) {
+        const missedText = rendered.slice(initialText.length);
+        if (missedText) handlers.onDelta(missedText);
+      } else if (initialText.startsWith(rendered)) {
+        rendered = initialText;
+      } else if (!initialText.startsWith(rendered)) {
+        rendered = initialText + rendered;
+      }
+      let session = client.sessions.attach(snapshot.session.sessionId, {
+        streamIndex: snapshot.session.streamIndex
+      });
+      this.session = session;
+      this.persistSessionCursor(session);
+      let snapshotBoundary;
+      for (let index = turnEvents.length - 1; index >= 0; index -= 1) {
+        const event = turnEvents[index];
+        if (event && isTurnBoundary(event)) {
+          snapshotBoundary = event;
+          break;
+        }
+      }
+      if (snapshotBoundary) {
+        if (snapshotBoundary.type === "session.failed") {
+          throw new Error(
+            snapshotBoundary.data.message || snapshotBoundary.data.code
+          );
+        }
+        handlers.onComplete?.();
+        await childStreams.waitForAll();
+        if (!rendered.trim() && !hasInputRequest) {
+          throw new Error("Empty response from runtime");
+        }
+        return rendered.trim();
+      }
+      let streamIndex = snapshot.session.streamIndex;
+      for await (const event of session.stream({ signal })) {
+        if (signal.aborted) break;
+        if (event.type === "subagent.called") childStreams.begin(event);
+        rendered = applyMessageEvent(event, rendered, handlers, workItems);
+        streamIndex += 1;
+        savePersistedAgentSession(
+          this.visitorSessionId,
+          session.state.sessionId,
+          streamIndex,
+          this.storeOptions
         );
+        if (isTurnBoundary(event)) break;
       }
-      handlers.onComplete?.();
-      if (!rendered.trim() && !hasInputRequest) {
+      await childStreams.waitForAll();
+      session = client.sessions.attach(session.state.sessionId, {
+        streamIndex
+      });
+      this.session = session;
+      this.persistSessionCursor(session);
+      if (!rendered.trim() && !signal.aborted && !hasInputRequest) {
         throw new Error("Empty response from runtime");
       }
       return rendered.trim();
+    } finally {
+      childStreams.abortAll();
+      if (this.childStreams === childStreams) this.childStreams = void 0;
     }
-    let streamIndex = snapshot.session.streamIndex;
-    for await (const event of session.stream({ signal })) {
-      if (signal.aborted) break;
-      rendered = applyMessageEvent(event, rendered, handlers, workItems);
-      streamIndex += 1;
-      savePersistedAgentSession(
-        this.visitorSessionId,
-        session.state.sessionId,
-        streamIndex,
-        this.storeOptions
-      );
-      if (isTurnBoundary(event)) break;
-    }
-    session = client.sessions.attach(session.state.sessionId, { streamIndex });
-    this.session = session;
-    this.persistSessionCursor(session);
-    if (!rendered.trim() && !signal.aborted && !hasInputRequest) {
-      throw new Error("Empty response from runtime");
-    }
-    return rendered.trim();
   }
   async respondTurn(responses, signal, handlers) {
     const client = this.ensureClient();
@@ -1760,6 +1992,12 @@ var AgentSession = class {
       () => session.respond(inputResponses, { signal })
     );
     this.activeResponse = response;
+    const childStreams = new SubagentChildStreamCoordinator(
+      client,
+      handlers,
+      signal
+    );
+    this.childStreams = childStreams;
     let streamIndex = session.state.streamIndex;
     let rendered = "";
     let requestedInput = false;
@@ -1767,6 +2005,7 @@ var AgentSession = class {
     try {
       for await (const event of response) {
         if (signal.aborted) break;
+        if (event.type === "subagent.called") childStreams.begin(event);
         if (event.type === "input.requested") requestedInput = true;
         rendered = applyMessageEvent(event, rendered, handlers, workItems);
         streamIndex += 1;
@@ -1777,8 +2016,11 @@ var AgentSession = class {
           this.storeOptions
         );
       }
+      await childStreams.waitForAll();
     } finally {
+      childStreams.abortAll();
       this.activeResponse = void 0;
+      if (this.childStreams === childStreams) this.childStreams = void 0;
       this.session = client.sessions.attach(session.state.sessionId, {
         streamIndex
       });
@@ -1790,6 +2032,7 @@ var AgentSession = class {
     return rendered.trim();
   }
   cancelActive() {
+    this.childStreams?.abortAll();
     if (this.activeResponse) {
       this.activeResponse.cancel().catch(() => {
       });
@@ -3864,7 +4107,7 @@ function ConfirmationCard({
 // src/react/components/ToolInputCard/ToolInputCard.tsx
 import { useState as useState6 } from "react";
 import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
-function isRecord4(value) {
+function isRecord5(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function pathSegments(path) {
@@ -3878,7 +4121,7 @@ function valueAtPath(root, path) {
       current = Number.isInteger(index) ? current[index] : void 0;
       continue;
     }
-    current = isRecord4(current) ? current[segment] : void 0;
+    current = isRecord5(current) ? current[segment] : void 0;
   }
   return current;
 }
@@ -3901,7 +4144,7 @@ function initialValues(surface) {
 }
 function cloneJsonValue(value) {
   if (Array.isArray(value)) return value.map(cloneJsonValue);
-  if (isRecord4(value)) {
+  if (isRecord5(value)) {
     return Object.fromEntries(
       Object.entries(value).map(([key, item]) => [key, cloneJsonValue(item)])
     );
@@ -3917,7 +4160,7 @@ function assignPath(target, path, value) {
       return;
     }
     const existing = current[segment];
-    if (!isRecord4(existing)) current[segment] = {};
+    if (!isRecord5(existing)) current[segment] = {};
     current = current[segment];
   });
 }
@@ -4213,7 +4456,7 @@ function ToolInputCard({
       (field) => validateField(field, values[field.path] ?? "")
     );
     if (nextErrors.some(Boolean)) return;
-    const result = isRecord4(surface.values) ? cloneJsonValue(surface.values) : {};
+    const result = isRecord5(surface.values) ? cloneJsonValue(surface.values) : {};
     for (const field of surface.fields) {
       const parsed = parsedFieldValue(field, values[field.path] ?? "");
       if (parsed !== void 0) assignPath(result, field.path, parsed);
@@ -5414,4 +5657,4 @@ export {
   AssistEdgeTab,
   AgentWidget
 };
-//# sourceMappingURL=chunk-U5IPERNA.js.map
+//# sourceMappingURL=chunk-U2SU2CGF.js.map