@convex-dev/agent 0.1.9-alpha.0 → 0.1.9-alpha.10

package/src/component/streams.ts

@@ -17,19 +17,30 @@ import {
 import schema from "./schema.js";
 import { stream } from "convex-helpers/server/stream";
 import { mergedStream } from "convex-helpers/server/stream";
+import { paginator } from "convex-helpers/server/pagination";
+
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
 
 const MAX_DELTAS_PER_REQUEST = 1000;
 const MAX_DELTAS_PER_STREAM = 100;
-const TIMEOUT_INTERVAL = 1000 * 60; // 1 minute
+const TIMEOUT_INTERVAL = 10 * MINUTE;
+const DELETE_STREAM_DELAY = MINUTE * 5; // 5 minutes
 
 const deltaValidator = schema.tables.streamDeltas.validator;
 
 export const addDelta = mutation({
   args: deltaValidator,
-  returns: v.null(),
+  returns: v.boolean(),
   handler: async (ctx, args) => {
     await ctx.db.insert("streamDeltas", args);
     await heartbeatStream(ctx, { streamId: args.streamId });
+    const stream = await ctx.db.get(args.streamId);
+    if (stream?.state.kind !== "streaming") {
+      console.warn(`Stream is not streaming: ${args.streamId}`);
+      return false;
+    }
+    return true;
   },
 });
 
@@ -137,7 +148,10 @@ export const finish = mutation({
       throw new Error(`Stream not found: ${args.streamId}`);
     }
     if (stream.state.kind !== "streaming") {
-      throw new Error(`Stream is not streaming: ${args.streamId}`);
+      console.warn(
+        `Stream trying to finish but not currently streaming: ${args.streamId}`
+      );
+      return;
     }
     if (stream.state.timeoutFnId) {
       const timeoutFn = await ctx.db.system.get(stream.state.timeoutFnId);
@@ -148,6 +162,11 @@ export const finish = mutation({
     await ctx.db.patch(args.streamId, {
       state: { kind: "finished", endedAt: Date.now() },
     });
+    await ctx.scheduler.runAfter(
+      DELETE_STREAM_DELAY,
+      api.streams.deleteStreamAsync,
+      { streamId: args.streamId }
+    );
   },
 });
 
@@ -215,7 +234,7 @@ async function deletePageForStreamId(
   ctx: MutationCtx,
   args: { streamId: Id<"streamingMessages">; cursor?: string }
 ) {
-  const deltas = await ctx.db
+  const deltas = await paginator(ctx.db, schema)
     .query("streamDeltas")
     .withIndex("streamId_start_end", (q) => q.eq("streamId", args.streamId))
     .paginate({
@@ -331,6 +350,20 @@ export const deleteStreamSync = mutation({
   },
 });
 
+export const deleteStreamAsync = mutation({
+  args: { streamId: v.id("streamingMessages"), cursor: v.optional(v.string()) },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    const result = await deletePageForStreamId(ctx, args);
+    if (!result.isDone) {
+      await ctx.scheduler.runAfter(0, api.streams.deleteStreamAsync, {
+        streamId: args.streamId,
+        cursor: result.continueCursor,
+      });
+    }
+  },
+});
+
 export const deleteAllStreamsForThreadIdSync = action({
   args: { threadId: v.id("threads") },
   returns: v.null(),

package/src/component/threads.ts

@@ -16,6 +16,7 @@ import {
 } from "./_generated/server.js";
 import { deleteMessage } from "./messages.js";
 import { schema, v } from "./schema.js";
+import { deleteStreamsPageForThreadId } from "./streams.js";
 
 function publicThreadOrNull(thread: Doc<"threads"> | null): ThreadDoc | null {
   if (thread === null) {
@@ -100,29 +101,17 @@ export const updateThread = mutation({
 
 // TODO: delete thread
 
-const deleteThreadArgs = {
-  threadId: v.id("threads"),
-  cursor: v.optional(v.string()),
-  limit: v.optional(v.number()),
-};
-type DeleteThreadArgs = ObjectType<typeof deleteThreadArgs>;
-const deleteThreadReturns = {
-  cursor: v.string(),
-  isDone: v.boolean(),
-};
-type DeleteThreadReturns = ObjectType<typeof deleteThreadReturns>;
-
 /**
  * Use this to delete a thread and everything it contains.
  * It will try to delete all pages synchronously.
  * If it times out or fails, you'll have to run it again.
  */
 export const deleteAllForThreadIdSync = action({
-  args: deleteThreadArgs,
+  args: { threadId: v.id("threads"), limit: v.optional(v.number()) },
   handler: async (ctx, args) => {
-    let cursor = args.cursor;
+    let cursor: string | undefined = undefined;
     while (true) {
-      const result = await ctx.runMutation(
+      const result: DeleteThreadReturns = await ctx.runMutation(
         internal.threads._deletePageForThreadId,
         { threadId: args.threadId, cursor, limit: args.limit }
       );
@@ -138,6 +127,22 @@ export const deleteAllForThreadIdSync = action({
   returns: v.null(),
 });
 
+const deleteThreadArgs = {
+  threadId: v.id("threads"),
+  cursor: v.optional(v.string()),
+  messagesDone: v.optional(v.boolean()),
+  streamsDone: v.optional(v.boolean()),
+  streamOrder: v.optional(v.number()),
+  deltaCursor: v.optional(v.string()),
+  limit: v.optional(v.number()),
+};
+type DeleteThreadArgs = ObjectType<typeof deleteThreadArgs>;
+const deleteThreadReturns = {
+  cursor: v.string(),
+  isDone: v.boolean(),
+};
+type DeleteThreadReturns = ObjectType<typeof deleteThreadReturns>;
+
 export const _deletePageForThreadId = internalMutation({
   args: deleteThreadArgs,
   handler: deletePageForThreadIdHandler,
@@ -151,22 +156,39 @@ export const _deletePageForThreadId = internalMutation({
 export const deleteAllForThreadIdAsync = mutation({
   args: deleteThreadArgs,
   handler: async (ctx, args) => {
-    const result = await deletePageForThreadIdHandler(ctx, args);
-    if (!result.isDone) {
+    let messagesResult = {
+      isDone: args.messagesDone ?? false,
+      cursor: args.cursor,
+    };
+    if (!args.messagesDone) {
+      messagesResult = await deletePageForThreadIdHandler(ctx, args);
+    }
+    let streamResult = {
+      isDone: args.streamsDone ?? false,
+      streamOrder: args.streamOrder,
+      deltaCursor: args.deltaCursor,
+    };
+    if (!args.streamsDone) {
+      streamResult = await deleteStreamsPageForThreadId(ctx, {
+        threadId: args.threadId,
+        streamOrder: args.streamOrder,
+        deltaCursor: args.deltaCursor,
+      });
+    }
+    const isDone = messagesResult.isDone && streamResult.isDone;
+    if (!isDone) {
       await ctx.scheduler.runAfter(0, api.threads.deleteAllForThreadIdAsync, {
         threadId: args.threadId,
-        cursor: result.cursor,
+        cursor: messagesResult.cursor,
+        messagesDone: messagesResult.isDone,
+        streamsDone: streamResult.isDone,
+        streamOrder: streamResult.streamOrder,
+        deltaCursor: streamResult.deltaCursor,
       });
     }
-    // Kick off the streams deletion
-    await ctx.scheduler.runAfter(
-      0,
-      api.streams.deleteAllStreamsForThreadIdSync,
-      { threadId: args.threadId }
-    );
-    return result;
+    return { isDone };
   },
-  returns: deleteThreadReturns,
+  returns: v.object({ isDone: v.boolean() }),
 });
 
 async function deletePageForThreadIdHandler(

package/src/react/deltas.ts

@@ -189,6 +189,7 @@ export function applyDeltasToStreamMessage(
         contentToAdd = part;
         break;
       case "reasoning":
+        currentMessage.reasoning += part.textDelta;
         if (lastContent?.type === "reasoning") {
           lastContent.text += part.textDelta;
         } else {