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

package/src/client/index.ts

@@ -9,7 +9,6 @@ import type {
   StepResult,
   StreamObjectResult,
   StreamTextResult,
-  TextPart,
   ToolSet,
 } from "ai";
 import { generateObject, generateText, streamObject, streamText } from "ai";
@@ -544,6 +543,7 @@ export class Agent<AgentTools extends ToolSet> {
             providerOptions: aiArgs.providerOptions,
             order,
             stepOrder,
+            abortSignal: aiArgs.abortSignal,
           })
         : undefined;
 
@@ -552,6 +552,7 @@ export class Agent<AgentTools extends ToolSet> {
       maxSteps: this.options.maxSteps,
       ...aiArgs,
       tools,
+      abortSignal: streamer?.abortController.signal ?? aiArgs.abortSignal,
       experimental_transform: mergeTransforms(
         options?.saveStreamDeltas,
         args.experimental_transform
@@ -1050,8 +1051,7 @@ export class Agent<AgentTools extends ToolSet> {
         this.component.messages.listMessagesByThreadId,
         {
           threadId: args.threadId,
-          excludeToolMessages:
-            opts.includeToolCalls === true ? false : opts.excludeToolMessages,
+          excludeToolMessages: opts.excludeToolMessages,
           paginationOpts: {
             numItems: opts.recentMessages ?? DEFAULT_RECENT_MESSAGES,
             cursor: null,

package/src/client/streaming.ts

@@ -65,6 +65,7 @@ export class DeltaStreamer {
   #latestWrite: number = 0;
   #ongoingWrite: Promise<void> | undefined;
   #cursor: number = 0;
+  public abortController: AbortController;
 
   constructor(
     public readonly component: AgentComponent,
@@ -79,6 +80,7 @@ export class DeltaStreamer {
       userId: string | undefined;
       order: number | undefined;
       stepOrder: number | undefined;
+      abortSignal: AbortSignal | undefined;
     }
   ) {
     this.options =
@@ -92,8 +94,17 @@ export class DeltaStreamer {
     this.#nextParts = [];
     this.#nextOrder = metadata.order ?? 0;
     this.#nextStepOrder = (metadata.stepOrder ?? 0) + 1;
+    this.abortController = new AbortController();
+    if (metadata.abortSignal) {
+      metadata.abortSignal.addEventListener("abort", () => {
+        this.abortController.abort();
+      });
+    }
   }
   public async addParts(parts: TextStreamPart[]) {
+    if (this.abortController.signal.aborted) {
+      return;
+    }
     if (!this.streamId) {
       this.streamId = await this.ctx.runMutation(
         this.component.streams.create,
@@ -114,9 +125,23 @@ export class DeltaStreamer {
   }
 
   async #sendDelta() {
+    if (this.abortController.signal.aborted) {
+      return;
+    }
     const delta = this.#createDelta();
     this.#latestWrite = Date.now();
-    await this.ctx.runMutation(this.component.streams.addDelta, delta);
+    try {
+      const success = await this.ctx.runMutation(
+        this.component.streams.addDelta,
+        delta
+      );
+      if (!success) {
+        this.abortController.abort();
+      }
+    } catch (e) {
+      this.abortController.abort();
+      throw e;
+    }
     // Now that we've sent the delta, check if we need to send another one.
     if (
       this.#nextParts.length > 0 &&

package/src/client/types.ts

@@ -48,8 +48,6 @@ 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

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

package/src/component/streams.ts

@@ -17,20 +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 DELETE_STREAM_DELAY = 1000 * 60 * 5; // 5 minutes
+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;
   },
 });
 
@@ -138,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);
@@ -221,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({

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 {