@convex-dev/agent 0.3.0 → 0.3.2

package/src/client/utils.ts

@@ -0,0 +1,27 @@
+import type { StepResult, StopCondition } from "ai";
+
+export async function willContinue(
+  steps: StepResult<any>[],
+
+  stopWhen: StopCondition<any> | Array<StopCondition<any>> | undefined,
+): Promise<boolean> {
+  const step = steps.at(-1)!;
+  // we aren't doing another round after a tool result
+  // TODO: whether to handle continuing after too much context used..
+  if (step.finishReason !== "tool-calls") return false;
+  // we don't have a tool result, so we'll wait for more
+  if (step.toolCalls.length > step.toolResults.length) return false;
+  if (Array.isArray(stopWhen)) {
+    return (await Promise.all(stopWhen.map(async (s) => s({ steps })))).every(
+      (stop) => !stop,
+    );
+  }
+  return !!stopWhen && !(await stopWhen({ steps }));
+}
+
+export function errorToString(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}

package/src/component/messages.test.ts

@@ -536,21 +536,23 @@ describe("agent", () => {
     const result = await t.mutation(api.messages.deleteByOrder, {
       threadId: thread._id as Id<"threads">,
       startOrder: 0,
-      endOrder: 1,
+      endOrder: 2,
     });
 
     expect(result.isDone).toBe(true);
-    expect(result.lastOrder).toBe(0);
+    expect(result.lastOrder).toBe(1);
     expect(result.lastStepOrder).toBe(1);
 
-    // Verify only messages from order 0 were deleted
+    // Verify only messages from order 0 & 1 were deleted
     const remainingMessages = await t.query(
       api.messages.listMessagesByThreadId,
       { threadId: thread._id as Id<"threads">, order: "asc" },
     );
 
-    expect(remainingMessages.page).toHaveLength(3); // Should have messages from order 1 and 2
-    expect(remainingMessages.page.map((m) => m.order)).toEqual([1, 1, 2]);
+    expect(remainingMessages.page).toHaveLength(1); // Should have messages from order 2
+    expect(remainingMessages.page[0].message!.content).toBe(
+      "message order 2, step 0",
+    );
   });
 
   test("deleteByOrder handles step order boundaries correctly", async () => {

package/src/component/messages.ts

@@ -102,12 +102,12 @@ export const deleteByOrder = mutation({
     lastOrder?: number;
     lastStepOrder?: number;
   }> => {
-    const messages = await orderedMessagesStream(
-      ctx,
-      args.threadId,
-      "asc",
-      args.startOrder,
-    )
+    const messages = await orderedMessagesStream(ctx, {
+      threadId: args.threadId,
+      sortOrder: "asc",
+      startOrder: args.startOrder,
+      startOrderBound: "gte",
+    })
       .narrow({
         lowerBound: args.startStepOrder
           ? [args.startOrder, args.startStepOrder]
@@ -312,14 +312,22 @@ export async function getMaxMessage(
   threadId: Id<"threads">,
   order?: number,
 ) {
-  return orderedMessagesStream(ctx, threadId, "desc", order).first();
+  return orderedMessagesStream(ctx, {
+    threadId,
+    sortOrder: "desc",
+    startOrder: order,
+    startOrderBound: "eq",
+  }).first();
 }
 
 function orderedMessagesStream(
   ctx: QueryCtx,
-  threadId: Id<"threads">,
-  sortOrder: "asc" | "desc",
-  order?: number,
+  args: {
+    threadId: Id<"threads">;
+    sortOrder: "asc" | "desc";
+    startOrder?: number;
+    startOrderBound?: "gte" | "eq";
+  },
 ) {
   return mergedStream(
     [true, false].flatMap((tool) =>
@@ -328,15 +336,19 @@ function orderedMessagesStream(
           .query("messages")
           .withIndex("threadId_status_tool_order_stepOrder", (q) => {
             const qq = q
-              .eq("threadId", threadId)
+              .eq("threadId", args.threadId)
               .eq("status", status)
               .eq("tool", tool);
-            if (order !== undefined) {
-              return qq.eq("order", order);
+            if (args.startOrder !== undefined) {
+              if (args.startOrderBound === "gte") {
+                return qq.gte("order", args.startOrder);
+              } else {
+                return qq.eq("order", args.startOrder);
+              }
             }
             return qq;
           })
-          .order(sortOrder),
+          .order(args.sortOrder),
       ),
     ),
     ["order", "stepOrder"],

package/src/deltas.ts

@@ -79,7 +79,7 @@ export async function updateFromUIMessageChunks(
   for await (const messagePart of messageStream) {
     assert(
       messagePart.id === message.id,
-      `Expecting to only make one UIMessage in a stream, but have ${JSON.stringify(message)} and created ${JSON.stringify(messagePart)}`,
+      `Expecting to only make one UIMessage in a stream`,
     );
     message = messagePart;
   }