convex-durable-agents 0.2.0 → 0.2.2

package/src/client/handler.ts

@@ -178,7 +178,7 @@ export function streamHandlerAction(
       });
       if (stream == null) {
         logger.debug("Stream lock acquisition failed, exiting handler");
-        return;
+        return null;
       }
       logger.debug(`Stream lock acquired (seq=${stream.seq})`);
       streamer.startHeartbeat();
@@ -212,178 +212,178 @@ export function streamHandlerAction(
           });
         }
 
-        try {
-          const uiMessages = messages.map((m) => messageDocToUIMessage(m));
-          logger.debug(`Converted ${uiMessages.length} UI messages, transforming to model messages...`);
-          const modelMessages = transformMessages(
-            await convertToModelMessages(uiMessages, { tools: handlerlessTools }),
-          );
-          logger.debug(`Model messages ready (${modelMessages.length} messages), starting streamText...`);
-          const result = streamText({
-            ...streamTextArgs,
-            prompt: undefined,
-            messages: modelMessages,
-            tools: handlerlessTools,
-          });
+        const uiMessages = messages.map((m) => messageDocToUIMessage(m));
+        logger.debug(`Converted ${uiMessages.length} UI messages, transforming to model messages...`);
+        const modelMessages = transformMessages(await convertToModelMessages(uiMessages, { tools: handlerlessTools }));
+        logger.debug(`Model messages ready (${modelMessages.length} messages), starting streamText...`);
+        const result = streamText({
+          ...streamTextArgs,
+          prompt: undefined,
+          messages: modelMessages,
+          tools: handlerlessTools,
+        });
 
-          let finishReason: string | undefined;
-          let responseMessage: UIMessage | undefined;
+        let finishReason: string | undefined;
+        let responseMessage: UIMessage | undefined;
 
-          const uiMessageStream = result.toUIMessageStream({
-            generateMessageId: generateId,
-            originalMessages: uiMessages,
-            onFinish: ({ responseMessage: finalResponseMessage }) => {
-              responseMessage = finalResponseMessage;
-            },
-          });
+        const uiMessageStream = result.toUIMessageStream({
+          generateMessageId: generateId,
+          originalMessages: uiMessages,
+          onFinish: ({ responseMessage: finalResponseMessage }) => {
+            responseMessage = finalResponseMessage;
+          },
+        });
 
-          let msgId: string | undefined;
-          if (messages.length > 0) {
-            msgId = messages[messages.length - 1]!.id;
-            logger.debug(`Setting initial message ID from last message: ${msgId}`);
-            await streamer.setMessageId(msgId, true);
+        let msgId: string | undefined;
+        if (messages.length > 0) {
+          msgId = messages[messages.length - 1]!.id;
+          logger.debug(`Setting initial message ID from last message: ${msgId}`);
+          await streamer.setMessageId(msgId, true);
+        }
+        let toolCallCount = 0;
+        logger.debug("Processing UI message stream parts...");
+        for await (const part of uiMessageStream) {
+          if (part.type === "start") {
+            msgId = part.messageId;
+            logger.debug(`Stream part: start (messageId=${msgId})`);
+            await streamer.setMessageId(
+              msgId,
+              messages?.some((m) => m.id === msgId),
+            );
           }
-          let toolCallCount = 0;
-          logger.debug("Processing UI message stream parts...");
-          for await (const part of uiMessageStream) {
-            if (part.type === "start") {
-              msgId = part.messageId;
-              logger.debug(`Stream part: start (messageId=${msgId})`);
-              await streamer.setMessageId(
-                msgId,
-                messages?.some((m) => m.id === msgId),
-              );
-            }
-            await streamer.process(part);
+          await streamer.process(part);
 
-            switch (part.type) {
-              case "tool-input-available":
-                toolCallCount++;
-                logger.debug(
-                  `Stream part: tool-input-available (tool=${part.toolName}, callId=${part.toolCallId}, count=${toolCallCount})`,
-                );
-                await scheduleToolCall(
-                  ctx,
-                  {
-                    toolCallId: part.toolCallId,
-                    toolName: part.toolName,
-                    args: part.input,
-                    msgId: msgId,
-                    threadId: args.threadId,
-                    saveDelta: !!saveStreamDeltas,
-                  },
-                  toolDefinitions,
-                  logger,
-                );
-                break;
-              case "finish":
-                finishReason = part.finishReason;
-                logger.debug(`Stream part: finish (reason=${finishReason})`);
-                break;
-              case "error":
-                logger.error("Stream error:", part.errorText);
-                throw new Error(`Stream error: ${part.errorText}`);
-              default:
-                // Ignore other part types
-                break;
-            }
+          switch (part.type) {
+            case "tool-input-available":
+              toolCallCount++;
+              logger.debug(
+                `Stream part: tool-input-available (tool=${part.toolName}, callId=${part.toolCallId}, count=${toolCallCount})`,
+              );
+              await scheduleToolCall(
+                ctx,
+                {
+                  toolCallId: part.toolCallId,
+                  toolName: part.toolName,
+                  args: part.input,
+                  msgId: msgId,
+                  threadId: args.threadId,
+                  saveDelta: !!saveStreamDeltas,
+                },
+                toolDefinitions,
+                logger,
+              );
+              break;
+            case "finish":
+              finishReason = part.finishReason;
+              logger.debug(`Stream part: finish (reason=${finishReason})`);
+              break;
+            case "error":
+              logger.error("Stream error:", part.errorText);
+              throw new Error(`Stream error: ${part.errorText}`);
+            default:
+              // Ignore other part types
+              break;
           }
-          logger.debug(`Stream iteration complete (toolCallCount=${toolCallCount}, finishReason=${finishReason})`);
+        }
+        logger.debug(`Stream iteration complete (toolCallCount=${toolCallCount}, finishReason=${finishReason})`);
 
-          // Finish the delta stream
-          logger.debug("Finishing delta stream...");
-          await streamer.finish();
+        // Finish the delta stream
+        logger.debug("Finishing delta stream...");
+        await streamer.finish();
 
-          if (!responseMessage) {
-            throw new Error("No response message");
+        if (!responseMessage) {
+          throw new Error("No response message");
+        }
+        logger.debug(`Response message received (role=${responseMessage.role}, parts=${responseMessage.parts.length})`);
+
+        const providerMetadata = await getStreamTextProviderMetadata(result);
+        const usage = await getStreamTextUsage(result, providerMetadata);
+        logger.debug(`Usage info: ${usage ? JSON.stringify(usage) : "none"}`);
+        if (usage && usageHandlerCallback) {
+          logger.debug("Invoking onMessageComplete callback...");
+          try {
+            await usageHandlerCallback(ctx as ActionCtx, {
+              threadId: args.threadId,
+              streamId: args.streamId,
+              message: responseMessage,
+              usage,
+              providerMetadata: serializeForConvex(providerMetadata),
+            });
+            logger.debug("onMessageComplete callback succeeded");
+          } catch (e) {
+            console.error("endOfTurnCallback callback failed:", e);
           }
+        }
+
+        // Save the assistant response if we have one
+        if (responseMessage.role === "assistant" && responseMessage.parts.length > 0) {
           logger.debug(
-            `Response message received (role=${responseMessage.role}, parts=${responseMessage.parts.length})`,
+            `Saving assistant response (id=${responseMessage.id}, parts=${responseMessage.parts.length}, seq=${stream.seq})`,
           );
+          await ctx.runMutation(component.messages.add, {
+            threadId: args.threadId,
+            msg: responseMessage,
+            overwrite: true,
+            committedSeq: stream.seq,
+          });
+          logger.debug("Applying tool outcomes after saving response...");
+          await ctx.runMutation(component.messages.applyToolOutcomes, {
+            threadId: args.threadId,
+          });
+        }
 
-          const providerMetadata = await getStreamTextProviderMetadata(result);
-          const usage = await getStreamTextUsage(result, providerMetadata);
-          logger.debug(`Usage info: ${usage ? JSON.stringify(usage) : "none"}`);
-          if (usage && usageHandlerCallback) {
-            logger.debug("Invoking onMessageComplete callback...");
+        // Handle tool calls
+        if (toolCallCount > 0) {
+          logger.debug(`Setting thread status to awaiting_tool_results (${toolCallCount} tool calls)`);
+          finalStatus = "awaiting_tool_results";
+        } else if (finishReason && finishReason !== "tool-calls") {
+          logger.debug(`No tool calls, setting thread status to completed (finishReason=${finishReason})`);
+          finalStatus = "completed";
+          if (turnCompleteHandlerCallback) {
+            logger.debug("Invoking onTurnComplete callback...");
             try {
-              await usageHandlerCallback(ctx as ActionCtx, {
+              await turnCompleteHandlerCallback(ctx as ActionCtx, {
                 threadId: args.threadId,
                 streamId: args.streamId,
-                message: responseMessage,
-                usage,
                 providerMetadata: serializeForConvex(providerMetadata),
+                finishReason,
               });
-              logger.debug("onMessageComplete callback succeeded");
+              logger.debug("onTurnComplete callback succeeded");
             } catch (e) {
-              console.error("endOfTurnCallback callback failed:", e);
+              console.error("turnCompleteHandler callback failed:", e);
             }
           }
+        } else {
+          logger.debug(`Unhandled end state: toolCallCount=${toolCallCount}, finishReason=${finishReason}`);
+        }
 
-          // Save the assistant response if we have one
-          if (responseMessage && responseMessage.role === "assistant" && responseMessage.parts.length > 0) {
-            logger.debug(
-              `Saving assistant response (id=${responseMessage.id}, parts=${responseMessage.parts.length}, seq=${stream.seq})`,
-            );
-            await ctx.runMutation(component.messages.add, {
-              threadId: args.threadId,
-              msg: responseMessage,
-              overwrite: true,
-              committedSeq: stream.seq,
-            });
-            logger.debug("Applying tool outcomes after saving response...");
-            await ctx.runMutation(component.messages.applyToolOutcomes, {
+        logger.debug("Stream handler completed successfully");
+        return null;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const normalizedError = errorMessage || "Unknown error";
+        logger.error("Error in stream handler:", normalizedError);
+        try {
+          await streamer.fail(normalizedError);
+        } catch (streamAbortError) {
+          logger.error(
+            `Failed to abort stream after handler error: ${streamAbortError instanceof Error ? streamAbortError.message : String(streamAbortError)}`,
+          );
+        }
+        finalStatus = "failed";
+        if (errorHandlerCallback) {
+          logger.debug("Invoking onError callback...");
+          try {
+            await errorHandlerCallback(ctx as ActionCtx, {
               threadId: args.threadId,
+              streamId: args.streamId,
+              error: normalizedError,
             });
+          } catch (e) {
+            console.error("errorHandler callback failed:", e);
           }
-
-          // Handle tool calls
-          if (toolCallCount > 0) {
-            logger.debug(`Setting thread status to awaiting_tool_results (${toolCallCount} tool calls)`);
-            finalStatus = "awaiting_tool_results";
-          } else if (finishReason && finishReason !== "tool-calls") {
-            logger.debug(`No tool calls, setting thread status to completed (finishReason=${finishReason})`);
-            finalStatus = "completed";
-            if (turnCompleteHandlerCallback) {
-              logger.debug("Invoking onTurnComplete callback...");
-              try {
-                await turnCompleteHandlerCallback(ctx as ActionCtx, {
-                  threadId: args.threadId,
-                  streamId: args.streamId,
-                  providerMetadata: serializeForConvex(providerMetadata),
-                  finishReason,
-                });
-                logger.debug("onTurnComplete callback succeeded");
-              } catch (e) {
-                console.error("turnCompleteHandler callback failed:", e);
-              }
-            }
-          } else {
-            logger.debug(`Unhandled end state: toolCallCount=${toolCallCount}, finishReason=${finishReason}`);
-          }
-        } catch (error) {
-          logger.error("Error in stream handler:", error instanceof Error ? error.message : String(error));
-          if (streamer) {
-            await streamer.fail(error instanceof Error ? error.message : "Unknown error");
-          }
-          finalStatus = "failed";
-          if (errorHandlerCallback) {
-            logger.debug("Invoking onError callback...");
-            try {
-              await errorHandlerCallback(ctx as ActionCtx, {
-                threadId: args.threadId,
-                streamId: args.streamId,
-                error: error instanceof Error ? error.message : "Unknown error",
-              });
-            } catch (e) {
-              console.error("errorHandler callback failed:", e);
-            }
-          }
-          throw error;
         }
-
-        logger.debug("Stream handler completed successfully");
-        return null;
+        throw error;
       } finally {
         logger.debug("Finalizing stream turn and checking for continuation...");
         const finalizeArgs: {

package/src/component/_generated/component.ts

@@ -424,14 +424,14 @@ export type ComponentApi<Name extends string | undefined = string | undefined> =
         "mutation",
         "internal",
         { error: string; id: string },
-        null,
+        boolean,
         Name
       >;
       setResult: FunctionReference<
         "mutation",
         "internal",
         { id: string; result: any },
-        null,
+        boolean,
         Name
       >;
       setToolCallTimeout: FunctionReference<

package/src/component/agent.ts

@@ -60,11 +60,30 @@ export const continueStream = mutation({
 
     // Check stop signal
     if (thread.stopSignal) {
-      logger.debug("Stop signal detected, setting status to stopped");
-      await ctx.runMutation(api.threads.setStatus, {
-        threadId: args.threadId,
+      const previousStatus = thread.status;
+      const activeStreamId = thread.activeStream ?? null;
+      logger.debug(
+        `Stop signal detected, transitioning thread to stopped and clearing active stream=${activeStreamId ?? "none"}`,
+      );
+      await ctx.db.patch(thread._id, {
         status: "stopped",
+        activeStream: null,
+        continue: false,
       });
+      if (thread.onStatusChangeHandle && previousStatus !== "stopped") {
+        await ctx.runMutation(thread.onStatusChangeHandle as FunctionHandle<"mutation">, {
+          threadId: args.threadId,
+          status: "stopped",
+          previousStatus,
+        });
+      }
+      if (activeStreamId) {
+        const activeStream = await ctx.db.get(activeStreamId);
+        if (activeStream) {
+          logger.debug(`Cancelling active stream=${activeStreamId} due to stop signal`);
+          await cancelStream(ctx, activeStream, "stopSignal");
+        }
+      }
       return null;
     }
 
@@ -141,6 +160,8 @@ export const tryContinueAllThreads = action({
   args: {},
   returns: v.null(),
   handler: async (ctx) => {
+    // Manual/admin recovery entrypoint: intentionally unscheduled by default.
+    // Invoke this action after outages/deploy interruptions to re-drive incomplete threads.
     const threads = await ctx.runQuery(api.threads.listIncomplete);
     for (const threadId of threads) {
       await ctx.runMutation(api.agent.continueStream, {

package/src/component/messages.ts

@@ -19,6 +19,20 @@ const vUIMessage = vUIMessageBase.extend({
   id: v.string(),
 });
 
+type ToolInputAvailablePart = {
+  toolCallId: string;
+  state: "input-available";
+  callProviderMetadata?: unknown;
+};
+
+function isObjectLike(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+export function isToolInputAvailablePart(part: unknown): part is ToolInputAvailablePart {
+  return isObjectLike(part) && typeof part.toolCallId === "string" && part.state === "input-available";
+}
+
 // Message doc validator for return types
 export const vMessageDoc = vUIMessage.extend({
   _id: v.string(),
@@ -102,8 +116,8 @@ export const applyToolOutcomes = mutation({
       .order("asc")) {
       let modified = false;
       const parts: UIMessagePart<any, any>[] = [];
-      for (const part of message.parts as UIMessagePart<any, any>[]) {
-        if ("toolCallId" in part && part.state === "input-available") {
+      for (const part of message.parts as unknown[]) {
+        if (isToolInputAvailablePart(part)) {
           const toolCall = await ctx.db
             .query("tool_calls")
             .withIndex("by_thread_tool_call_id", (q) =>
@@ -119,7 +133,7 @@ export const applyToolOutcomes = mutation({
             }
           }
         }
-        parts.push(part);
+        parts.push(part as UIMessagePart<any, any>);
       }
       if (modified) {
         await ctx.db.patch(message._id, { parts });

package/src/component/threads.ts

@@ -397,6 +397,12 @@ export const remove = mutation({
       .withIndex("by_thread", (q) => q.eq("threadId", args.threadId))
       .collect();
     for (const toolCall of toolCalls) {
+      if (toolCall.timeoutFnId) {
+        const timeoutFn = await ctx.db.system.get(toolCall.timeoutFnId);
+        if (timeoutFn?.state.kind === "pending") {
+          await ctx.scheduler.cancel(toolCall.timeoutFnId);
+        }
+      }
       await ctx.db.delete(toolCall._id);
     }
     // Delete the thread

package/src/component/tool_calls.ts

@@ -176,16 +176,20 @@ export const setResult = mutation({
     id: v.id("tool_calls"),
     result: v.any(),
   },
-  returns: v.null(),
+  returns: v.boolean(),
   handler: async (ctx, args) => {
     const toolCall = await ctx.db.get(args.id);
     if (!toolCall) {
       throw new Error(`Tool call ${args.id} not found`);
     }
+    if (toolCall.status !== "pending") {
+      logger.warn(`setResult: skipping overwrite for callId=${toolCall.toolCallId}, currentStatus=${toolCall.status}`);
+      return false;
+    }
     logger.debug(`setResult: callId=${toolCall.toolCallId}, tool=${toolCall.toolName}`);
     await cleanupTimeoutFn(ctx, toolCall);
     await ctx.db.patch(args.id, { result: args.result, status: "completed" });
-    return null;
+    return true;
   },
 });
 
@@ -194,16 +198,20 @@ export const setError = mutation({
     id: v.id("tool_calls"),
     error: v.string(),
   },
-  returns: v.null(),
+  returns: v.boolean(),
   handler: async (ctx, args) => {
     const toolCall = await ctx.db.get(args.id);
     if (!toolCall) {
       throw new Error(`Tool call ${args.id} not found`);
     }
+    if (toolCall.status !== "pending") {
+      logger.warn(`setError: skipping overwrite for callId=${toolCall.toolCallId}, currentStatus=${toolCall.status}`);
+      return false;
+    }
     logger.debug(`setError: callId=${toolCall.toolCallId}, tool=${toolCall.toolName}, error=${args.error}`);
     await cleanupTimeoutFn(ctx, toolCall);
     await ctx.db.patch(args.id, { error: args.error, status: "failed", callbackLastError: args.error });
-    return null;
+    return true;
   },
 });
 
@@ -605,11 +613,32 @@ export const onToolComplete = internalMutation({
 
     // Check stop signal
     if (thread.stopSignal) {
-      logger.debug("onToolComplete: stop signal detected, setting status to stopped");
-      await ctx.runMutation(api.threads.setStatus, {
-        threadId: args.threadId,
+      const previousStatus = thread.status;
+      const activeStreamId = thread.activeStream ?? null;
+      logger.debug(
+        `onToolComplete: stop signal detected, transitioning thread to stopped and clearing active stream=${activeStreamId ?? "none"}`,
+      );
+      await ctx.db.patch(args.threadId, {
         status: "stopped",
+        activeStream: null,
+        continue: false,
       });
+      if (thread.onStatusChangeHandle && previousStatus !== "stopped") {
+        await ctx.runMutation(thread.onStatusChangeHandle as FunctionHandle<"mutation">, {
+          threadId: args.threadId,
+          status: "stopped",
+          previousStatus,
+        });
+      }
+      if (activeStreamId) {
+        const activeStream = await ctx.db.get(activeStreamId);
+        if (activeStream && (activeStream.state.kind === "pending" || activeStream.state.kind === "streaming")) {
+          await ctx.runMutation(api.streams.abort, {
+            streamId: activeStreamId,
+            reason: "stopSignal",
+          });
+        }
+      }
       return null;
     }
 
@@ -686,18 +715,22 @@ export const addToolResult = mutation({
     }
 
     const threadId = toolCall.threadId;
-    // Check if already completed
     if (toolCall.status !== "pending") {
-      throw new Error(`Tool call ${args.toolCallId} has already been completed`);
+      logger.warn(`addToolResult: ignoring duplicate completion for callId=${args.toolCallId}`);
+      return null;
     }
 
     logger.debug(`addToolResult: callId=${args.toolCallId}, tool=${toolCall.toolName}, thread=${threadId}`);
 
     // Update the tool call record with the result
-    await ctx.runMutation(api.tool_calls.setResult, {
+    const transitioned = await ctx.runMutation(api.tool_calls.setResult, {
       id: toolCall._id,
       result: args.result,
     });
+    if (!transitioned) {
+      logger.warn(`addToolResult: skipped duplicate completion race for callId=${args.toolCallId}`);
+      return null;
+    }
 
     if (toolCall.saveDelta) {
       logger.debug(`addToolResult: inserting tool outcome delta for callId=${args.toolCallId}`);
@@ -745,9 +778,9 @@ export const addToolError = mutation({
 
     const threadId = toolCall.threadId;
 
-    // Check if already completed
     if (toolCall.status !== "pending") {
-      throw new Error(`Tool call ${args.toolCallId} has already been completed`);
+      logger.warn(`addToolError: ignoring duplicate completion for callId=${args.toolCallId}`);
+      return null;
     }
 
     logger.debug(
@@ -755,10 +788,14 @@ export const addToolError = mutation({
     );
 
     // Update the tool call record with the error
-    await ctx.runMutation(api.tool_calls.setError, {
+    const transitioned = await ctx.runMutation(api.tool_calls.setError, {
       id: toolCall._id,
       error: args.error,
     });
+    if (!transitioned) {
+      logger.warn(`addToolError: skipped duplicate completion race for callId=${args.toolCallId}`);
+      return null;
+    }
 
     if (toolCall.saveDelta) {
       logger.debug(`addToolError: inserting tool outcome delta for callId=${args.toolCallId}`);

package/src/react/agent-chat.ts

@@ -1,6 +1,7 @@
 import { useMutation } from "convex/react";
 import type { FunctionReference } from "convex/server";
 import { useCallback } from "react";
+import type { MessageDoc } from "./types";
 import {
   type MessagesQuery,
   type StreamingMessageUpdatesQuery,
@@ -15,6 +16,20 @@ type StopThreadMutation = FunctionReference<"mutation", "public", { threadId: st
 
 type ResumeThreadMutation = FunctionReference<"mutation", "public", { threadId: string; prompt?: string }, null>;
 
+function createOptimisticMessageDoc({ prompt, threadId }: { threadId: string; prompt: string }): MessageDoc {
+  const now = Date.now();
+  const suffix = globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  const id = `optimistic-${suffix}`;
+  return {
+    _id: id,
+    _creationTime: now,
+    threadId,
+    id,
+    role: "user",
+    parts: [{ type: "text", text: prompt }],
+  };
+}
+
 export type UseAgentChatOptions = {
   /** Query to get thread status */
   getThread: ThreadQuery;
@@ -96,7 +111,13 @@ export function useAgentChat(options: UseAgentChatOptions): UseAgentChatReturn {
   });
 
   // Create mutation functions
-  const sendMessageMutation = useMutation(sendMessageRef);
+  const sendMessageMutation = useMutation(sendMessageRef).withOptimisticUpdate((localStore, args) => {
+    const currentMessages = localStore.getQuery(listMessages, { threadId: args.threadId }) ?? [];
+    localStore.setQuery(listMessages, { threadId: args.threadId }, [
+      ...currentMessages,
+      createOptimisticMessageDoc(args),
+    ]);
+  });
   const stopThreadMutation = useMutation(stopThreadRef);
   const resumeThreadMutation = useMutation(resumeThreadRef);
 

package/dist/shared/stream_seq.d.ts

@@ -1,2 +0,0 @@
-export declare function nextDeltaSequence(lastSequence: number | undefined): number;
-//# sourceMappingURL=stream_seq.d.ts.map

package/dist/shared/stream_seq.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream_seq.d.ts","sourceRoot":"","sources":["../../src/shared/stream_seq.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAE1E"}

package/dist/shared/stream_seq.js

@@ -1,4 +0,0 @@
-export function nextDeltaSequence(lastSequence) {
-    return lastSequence === undefined ? 0 : lastSequence + 1;
-}
-//# sourceMappingURL=stream_seq.js.map

package/dist/shared/stream_seq.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream_seq.js","sourceRoot":"","sources":["../../src/shared/stream_seq.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,iBAAiB,CAAC,YAAgC;IAChE,OAAO,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,GAAG,CAAC,CAAC;AAC3D,CAAC"}