@convex-dev/agent 0.1.9-alpha.12 → 0.1.9-alpha.2

package/src/client/types.ts

@@ -48,6 +48,8 @@ import type { StreamingOptions } from "./streaming.js";
  * automatically with thread.generateText, or directly via search.
  */
 export type ContextOptions = {
+  /** @deprecated Use excludeToolMessages instead. */
+  includeToolCalls?: boolean;
   /**
    * Whether to include tool messages in the context.
    * By default, tool calls and results are not included.

package/src/component/_generated/api.d.ts

@@ -1663,21 +1663,13 @@ export type Mounts = {
     deleteAllForThreadIdAsync: FunctionReference<
       "mutation",
       "public",
-      {
-        cursor?: string;
-        deltaCursor?: string;
-        limit?: number;
-        messagesDone?: boolean;
-        streamOrder?: number;
-        streamsDone?: boolean;
-        threadId: string;
-      },
-      { isDone: boolean }
+      { cursor?: string; limit?: number; threadId: string },
+      { cursor: string; isDone: boolean }
     >;
     deleteAllForThreadIdSync: FunctionReference<
       "action",
       "public",
-      { limit?: number; threadId: string },
+      { cursor?: string; limit?: number; threadId: string },
       null
     >;
     getThread: FunctionReference<

package/src/component/streams.ts

@@ -17,15 +17,11 @@ 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 = 10 * MINUTE;
-const DELETE_STREAM_DELAY = MINUTE * 5; // 5 minutes
+const TIMEOUT_INTERVAL = 1000 * 60; // 1 minute
+const DELETE_STREAM_DELAY = 1000 * 60 * 5; // 5 minutes
 
 const deltaValidator = schema.tables.streamDeltas.validator;
 
@@ -234,7 +230,7 @@ async function deletePageForStreamId(
   ctx: MutationCtx,
   args: { streamId: Id<"streamingMessages">; cursor?: string }
 ) {
-  const deltas = await paginator(ctx.db, schema)
+  const deltas = await ctx.db
     .query("streamDeltas")
     .withIndex("streamId_start_end", (q) => q.eq("streamId", args.streamId))
     .paginate({
@@ -242,9 +238,6 @@ async function deletePageForStreamId(
       cursor: args.cursor ?? null,
     });
   await Promise.all(deltas.page.map((d) => ctx.db.delete(d._id)));
-  if (deltas.isDone) {
-    await ctx.db.delete(args.streamId);
-  }
   return deltas;
 }
 
@@ -284,12 +277,13 @@ export async function deleteStreamsPageForThreadId(
     cursor: deltaCursor,
   });
   if (result.isDone) {
+    await ctx.db.delete(streamMessage._id);
     deltaCursor = undefined;
   }
   return {
     isDone: false,
     streamOrder: streamMessage.order,
-    deltaCursor,
+    deltaCursor: result.continueCursor,
   };
 }
 
@@ -348,6 +342,7 @@ export const deleteStreamSync = mutation({
         cursor: deltas.continueCursor,
       });
     }
+    await ctx.db.delete(args.streamId);
   },
 });
 

package/src/component/threads.ts

@@ -16,7 +16,6 @@ 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) {
@@ -101,17 +100,29 @@ 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: { threadId: v.id("threads"), limit: v.optional(v.number()) },
+  args: deleteThreadArgs,
   handler: async (ctx, args) => {
-    let cursor: string | undefined = undefined;
+    let cursor = args.cursor;
     while (true) {
-      const result: DeleteThreadReturns = await ctx.runMutation(
+      const result = await ctx.runMutation(
         internal.threads._deletePageForThreadId,
         { threadId: args.threadId, cursor, limit: args.limit }
       );
@@ -127,22 +138,6 @@ 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,
@@ -156,39 +151,22 @@ export const _deletePageForThreadId = internalMutation({
 export const deleteAllForThreadIdAsync = mutation({
   args: deleteThreadArgs,
   handler: async (ctx, args) => {
-    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) {
+    const result = await deletePageForThreadIdHandler(ctx, args);
+    if (!result.isDone) {
       await ctx.scheduler.runAfter(0, api.threads.deleteAllForThreadIdAsync, {
         threadId: args.threadId,
-        cursor: messagesResult.cursor,
-        messagesDone: messagesResult.isDone,
-        streamsDone: streamResult.isDone,
-        streamOrder: streamResult.streamOrder,
-        deltaCursor: streamResult.deltaCursor,
+        cursor: result.cursor,
       });
     }
-    return { isDone };
+    // Kick off the streams deletion
+    await ctx.scheduler.runAfter(
+      0,
+      api.streams.deleteAllStreamsForThreadIdSync,
+      { threadId: args.threadId }
+    );
+    return result;
   },
-  returns: v.object({ isDone: v.boolean() }),
+  returns: deleteThreadReturns,
 });
 
 async function deletePageForThreadIdHandler(

package/src/react/deltas.ts

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