@convex-dev/agent 0.1.8-alpha.0 → 0.1.8-alpha.2

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

@@ -1177,6 +1177,241 @@ export type Mounts = {
         >;
       }>
     >;
+    updateMessage: FunctionReference<
+      "mutation",
+      "public",
+      {
+        messageId: string;
+        patch: {
+          error?: string;
+          message?:
+            | {
+                content:
+                  | string
+                  | Array<
+                      | {
+                          providerOptions?: Record<string, Record<string, any>>;
+                          text: string;
+                          type: "text";
+                        }
+                      | {
+                          image: string | ArrayBuffer;
+                          mimeType?: string;
+                          providerOptions?: Record<string, Record<string, any>>;
+                          type: "image";
+                        }
+                      | {
+                          data: string | ArrayBuffer;
+                          filename?: string;
+                          mimeType: string;
+                          providerOptions?: Record<string, Record<string, any>>;
+                          type: "file";
+                        }
+                    >;
+                providerOptions?: Record<string, Record<string, any>>;
+                role: "user";
+              }
+            | {
+                content:
+                  | string
+                  | Array<
+                      | {
+                          providerOptions?: Record<string, Record<string, any>>;
+                          text: string;
+                          type: "text";
+                        }
+                      | {
+                          data: string | ArrayBuffer;
+                          filename?: string;
+                          mimeType: string;
+                          providerOptions?: Record<string, Record<string, any>>;
+                          type: "file";
+                        }
+                      | {
+                          providerOptions?: Record<string, Record<string, any>>;
+                          signature?: string;
+                          text: string;
+                          type: "reasoning";
+                        }
+                      | {
+                          data: string;
+                          providerOptions?: Record<string, Record<string, any>>;
+                          type: "redacted-reasoning";
+                        }
+                      | {
+                          args: any;
+                          providerOptions?: Record<string, Record<string, any>>;
+                          toolCallId: string;
+                          toolName: string;
+                          type: "tool-call";
+                        }
+                    >;
+                providerOptions?: Record<string, Record<string, any>>;
+                role: "assistant";
+              }
+            | {
+                content: Array<{
+                  args?: any;
+                  experimental_content?: Array<
+                    | { text: string; type: "text" }
+                    | { data: string; mimeType?: string; type: "image" }
+                  >;
+                  isError?: boolean;
+                  providerOptions?: Record<string, Record<string, any>>;
+                  result: any;
+                  toolCallId: string;
+                  toolName: string;
+                  type: "tool-result";
+                }>;
+                providerOptions?: Record<string, Record<string, any>>;
+                role: "tool";
+              }
+            | {
+                content: string;
+                providerOptions?: Record<string, Record<string, any>>;
+                role: "system";
+              };
+          status?: "pending" | "success" | "failed";
+        };
+      },
+      {
+        _creationTime: number;
+        _id: string;
+        agentName?: string;
+        embeddingId?: string;
+        error?: string;
+        fileIds?: Array<string>;
+        finishReason?:
+          | "stop"
+          | "length"
+          | "content-filter"
+          | "tool-calls"
+          | "error"
+          | "other"
+          | "unknown";
+        id?: string;
+        message?:
+          | {
+              content:
+                | string
+                | Array<
+                    | {
+                        providerOptions?: Record<string, Record<string, any>>;
+                        text: string;
+                        type: "text";
+                      }
+                    | {
+                        image: string | ArrayBuffer;
+                        mimeType?: string;
+                        providerOptions?: Record<string, Record<string, any>>;
+                        type: "image";
+                      }
+                    | {
+                        data: string | ArrayBuffer;
+                        filename?: string;
+                        mimeType: string;
+                        providerOptions?: Record<string, Record<string, any>>;
+                        type: "file";
+                      }
+                  >;
+              providerOptions?: Record<string, Record<string, any>>;
+              role: "user";
+            }
+          | {
+              content:
+                | string
+                | Array<
+                    | {
+                        providerOptions?: Record<string, Record<string, any>>;
+                        text: string;
+                        type: "text";
+                      }
+                    | {
+                        data: string | ArrayBuffer;
+                        filename?: string;
+                        mimeType: string;
+                        providerOptions?: Record<string, Record<string, any>>;
+                        type: "file";
+                      }
+                    | {
+                        providerOptions?: Record<string, Record<string, any>>;
+                        signature?: string;
+                        text: string;
+                        type: "reasoning";
+                      }
+                    | {
+                        data: string;
+                        providerOptions?: Record<string, Record<string, any>>;
+                        type: "redacted-reasoning";
+                      }
+                    | {
+                        args: any;
+                        providerOptions?: Record<string, Record<string, any>>;
+                        toolCallId: string;
+                        toolName: string;
+                        type: "tool-call";
+                      }
+                  >;
+              providerOptions?: Record<string, Record<string, any>>;
+              role: "assistant";
+            }
+          | {
+              content: Array<{
+                args?: any;
+                experimental_content?: Array<
+                  | { text: string; type: "text" }
+                  | { data: string; mimeType?: string; type: "image" }
+                >;
+                isError?: boolean;
+                providerOptions?: Record<string, Record<string, any>>;
+                result: any;
+                toolCallId: string;
+                toolName: string;
+                type: "tool-result";
+              }>;
+              providerOptions?: Record<string, Record<string, any>>;
+              role: "tool";
+            }
+          | {
+              content: string;
+              providerOptions?: Record<string, Record<string, any>>;
+              role: "system";
+            };
+        model?: string;
+        order: number;
+        provider?: string;
+        providerMetadata?: Record<string, Record<string, any>>;
+        providerOptions?: Record<string, Record<string, any>>;
+        reasoning?: string;
+        reasoningDetails?: Array<
+          | { signature?: string; text: string; type: "text" }
+          | { data: string; type: "redacted" }
+        >;
+        sources?: Array<{
+          id: string;
+          providerOptions?: Record<string, Record<string, any>>;
+          sourceType: "url";
+          title?: string;
+          url: string;
+        }>;
+        status: "pending" | "success" | "failed";
+        stepOrder: number;
+        text?: string;
+        threadId: string;
+        tool: boolean;
+        usage?: {
+          completionTokens: number;
+          promptTokens: number;
+          totalTokens: number;
+        };
+        userId?: string;
+        warnings?: Array<
+          | { details?: string; setting: string; type: "unsupported-setting" }
+          | { details?: string; tool: any; type: "unsupported-tool" }
+          | { message: string; type: "other" }
+        >;
+      }
+    >;
   };
   streams: {
     addDelta: FunctionReference<

package/src/component/messages.test.ts

@@ -141,4 +141,144 @@ describe("agent", () => {
       stepOrder: 1,
     });
   });
+
+  test("updateMessage updates message content", async () => {
+    const t = convexTest(schema, modules);
+    const thread = await t.mutation(api.threads.createThread, {
+      userId: "test",
+    });
+    const { messages } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [{ message: { role: "user", content: "hello" } }],
+    });
+    const messageId = messages[0]._id as Id<"messages">;
+    
+    const updatedMessage = await t.mutation(api.messages.updateMessage, {
+      messageId,
+      patch: {
+        message: { role: "user", content: "updated content" },
+      },
+    });
+    
+    expect(updatedMessage.message).toEqual({
+      role: "user",
+      content: "updated content",
+    });
+  });
+
+  test("updateMessage updates message status", async () => {
+    const t = convexTest(schema, modules);
+    const thread = await t.mutation(api.threads.createThread, {
+      userId: "test",
+    });
+    const { messages } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [{ message: { role: "assistant", content: "hello" } }],
+      pending: true,
+    });
+    const messageId = messages[0]._id as Id<"messages">;
+    
+    // Initial status should be pending
+    expect(messages[0].status).toBe("pending");
+    
+    // Update to success
+    const updatedMessage = await t.mutation(api.messages.updateMessage, {
+      messageId,
+      patch: {
+        status: "success",
+      },
+    });
+    
+    expect(updatedMessage.status).toBe("success");
+  });
+
+  test("updateMessage updates error field", async () => {
+    const t = convexTest(schema, modules);
+    const thread = await t.mutation(api.threads.createThread, {
+      userId: "test",
+    });
+    const { messages } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [{ message: { role: "assistant", content: "hello" } }],
+      pending: true,
+    });
+    const messageId = messages[0]._id as Id<"messages">;
+    
+    const updatedMessage = await t.mutation(api.messages.updateMessage, {
+      messageId,
+      patch: {
+        status: "failed",
+        error: "Something went wrong",
+      },
+    });
+    
+    expect(updatedMessage.status).toBe("failed");
+    expect(updatedMessage.error).toBe("Something went wrong");
+  });
+
+  test("updateMessage correctly updates tool messages", async () => {
+    const t = convexTest(schema, modules);
+    const thread = await t.mutation(api.threads.createThread, {
+      userId: "test",
+    });
+    const { messages } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [{
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              args: { a: 1 },
+              toolCallId: "1",
+              toolName: "tool",
+            },
+          ],
+        },
+      }],
+    });
+    const messageId = messages[0]._id as Id<"messages">;
+    
+    const updatedMessage = await t.mutation(api.messages.updateMessage, {
+      messageId,
+      patch: {
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "tool-call",
+              args: { a: 2, b: 3 },
+              toolCallId: "1",
+              toolName: "tool",
+            },
+          ],
+        },
+      },
+    });
+    
+    expect(updatedMessage.message).toEqual({
+      role: "assistant",
+      content: [
+        {
+          type: "tool-call",
+          args: { a: 2, b: 3 },
+          toolCallId: "1",
+          toolName: "tool",
+        },
+      ],
+    });
+  });
+
+  test("updateMessage throws error for non-existent message", async () => {
+    const t = convexTest(schema, modules);
+    
+    await expect(
+      t.mutation(api.messages.updateMessage, {
+        messageId: "invalidId" as Id<"messages">,
+        patch: {
+          message: { role: "user", content: "test" },
+        },
+      })
+    ).rejects.toThrow();
+  });
 });

package/src/component/messages.ts

@@ -265,6 +265,36 @@ export const commitMessage = mutation({
   returns: v.null(),
   handler: commitMessageHandler,
 });
+
+export const updateMessage = mutation({
+  args: {
+    messageId: v.id("messages"),
+    patch: v.object({
+      message: v.optional(vMessageDoc.fields.message),
+      status: v.optional(vMessageStatus),
+      error: v.optional(v.string()),
+    }),
+  },
+  returns: vMessageDoc,
+  handler: async (ctx, args) => {
+    const message = await ctx.db.get(args.messageId);
+    assert(message, `Message ${args.messageId} not found`);
+
+    const patch: Partial<Doc<"messages">> = {
+      ...args.patch,
+    };
+
+    if (args.patch.message !== undefined) {
+      patch.message = args.patch.message;
+      patch.tool = isTool(args.patch.message);
+      patch.text = extractText(args.patch.message);
+    }
+
+    await ctx.db.patch(args.messageId, patch);
+    return publicMessage((await ctx.db.get(args.messageId))!);
+  },
+});
+
 async function commitMessageHandler(
   ctx: MutationCtx,
   { messageId }: { messageId: Id<"messages"> }

package/src/component/streams.ts

@@ -5,15 +5,20 @@ import {
   vStreamDelta,
   vStreamMessage,
 } from "../validators.js";
-import { internal } from "./_generated/api.js";
-import type { Id } from "./_generated/dataModel.js";
+import { api, internal } from "./_generated/api.js";
+import type { Doc, Id } from "./_generated/dataModel.js";
 import {
   internalMutation,
   mutation,
   type MutationCtx,
   query,
+  action,
 } from "./_generated/server.js";
 import schema from "./schema.js";
+import type { PaginationResult } from "convex/server";
+import { paginator } from "convex-helpers/server/pagination";
+import { stream } from "convex-helpers/server/stream";
+import { mergedStream } from "convex-helpers/server/stream";
 
 const MAX_DELTAS_PER_REQUEST = 1000;
 const MAX_DELTAS_PER_STREAM = 100;
@@ -207,3 +212,144 @@ export const timeoutStream = internalMutation({
     });
   },
 });
+
+async function deletePageForStreamId(
+  ctx: MutationCtx,
+  args: { streamId: Id<"streamingMessages">; cursor?: string }
+) {
+  const deltas = await ctx.db
+    .query("streamDeltas")
+    .withIndex("streamId_start_end", (q) => q.eq("streamId", args.streamId))
+    .paginate({
+      numItems: MAX_DELTAS_PER_REQUEST,
+      cursor: args.cursor ?? null,
+    });
+  await Promise.all(deltas.page.map((d) => ctx.db.delete(d._id)));
+  return deltas;
+}
+
+export async function deleteStreamsPageForThreadId(
+  ctx: MutationCtx,
+  args: { threadId: Id<"threads">; streamOrder?: number; deltaCursor?: string }
+) {
+  const allStreamMessages =
+    schema.tables.streamingMessages.validator.fields.state.members
+      .flatMap((state) => state.fields.kind.value)
+      .map((stateKind) =>
+        stream(ctx.db, schema)
+          .query("streamingMessages")
+          .withIndex("threadId_state_order_stepOrder", (q) =>
+            q
+              .eq("threadId", args.threadId)
+              .eq("state.kind", stateKind)
+              .gte("order", args.streamOrder ?? 0)
+          )
+      );
+  let deltaCursor = args.deltaCursor;
+  const streamMessage = await mergedStream(allStreamMessages, [
+    "threadId",
+    "state.kind",
+    "order",
+    "stepOrder",
+  ]).first();
+  if (!streamMessage) {
+    return {
+      isDone: true,
+      streamOrder: undefined,
+      deltaCursor: undefined,
+    };
+  }
+  const result = await deletePageForStreamId(ctx, {
+    streamId: streamMessage._id,
+    cursor: deltaCursor,
+  });
+  if (result.isDone) {
+    await ctx.db.delete(streamMessage._id);
+    deltaCursor = undefined;
+  }
+  return {
+    isDone: false,
+    streamOrder: streamMessage.order,
+    deltaCursor: result.continueCursor,
+  };
+}
+
+export const deleteStreamsPageForThreadIdMutation = internalMutation({
+  args: {
+    threadId: v.id("threads"),
+    streamOrder: v.optional(v.number()),
+    deltaCursor: v.optional(v.string()),
+  },
+  returns: v.object({
+    isDone: v.boolean(),
+    streamOrder: v.optional(v.number()),
+    deltaCursor: v.optional(v.string()),
+  }),
+  handler: deleteStreamsPageForThreadId,
+});
+
+export const deleteAllStreamsForThreadIdAsync = mutation({
+  args: {
+    threadId: v.id("threads"),
+    streamOrder: v.optional(v.number()),
+    deltaCursor: v.optional(v.string()),
+  },
+  returns: v.object({
+    isDone: v.boolean(),
+    streamOrder: v.optional(v.number()),
+    deltaCursor: v.optional(v.string()),
+  }),
+  handler: async (ctx, args) => {
+    const result = await deleteStreamsPageForThreadId(ctx, args);
+    if (!result.isDone) {
+      await ctx.scheduler.runAfter(
+        0,
+        api.streams.deleteAllStreamsForThreadIdAsync,
+        {
+          threadId: args.threadId,
+          streamOrder: result.streamOrder,
+          deltaCursor: result.deltaCursor,
+        }
+      );
+    } else {
+      await ctx.db.delete(args.threadId);
+    }
+    return result;
+  },
+});
+
+export const deleteStreamSync = mutation({
+  args: { streamId: v.id("streamingMessages") },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    let deltas = await deletePageForStreamId(ctx, args);
+    while (!deltas.isDone) {
+      deltas = await deletePageForStreamId(ctx, {
+        ...args,
+        cursor: deltas.continueCursor,
+      });
+    }
+    await ctx.db.delete(args.streamId);
+  },
+});
+
+export const deleteAllStreamsForThreadIdSync = action({
+  args: { threadId: v.id("threads") },
+  returns: v.null(),
+  handler: async (ctx, args) => {
+    let result = await ctx.runMutation(
+      internal.streams.deleteStreamsPageForThreadIdMutation,
+      args
+    );
+    while (!result.isDone) {
+      result = await ctx.runMutation(
+        internal.streams.deleteStreamsPageForThreadIdMutation,
+        {
+          ...args,
+          streamOrder: result.streamOrder,
+          deltaCursor: result.deltaCursor,
+        }
+      );
+    }
+  },
+});

package/src/component/threads.ts

@@ -131,6 +131,9 @@ export const deleteAllForThreadIdSync = action({
       }
       cursor = result.cursor;
     }
+    await ctx.runAction(api.streams.deleteAllStreamsForThreadIdSync, {
+      threadId: args.threadId,
+    });
   },
   returns: v.null(),
 });
@@ -154,6 +157,11 @@ export const deleteAllForThreadIdAsync = mutation({
         threadId: args.threadId,
         cursor: result.cursor,
       });
+    } else {
+      // Kick off the streams deletion
+      await ctx.scheduler.runAfter(0, api.threads.deleteAllForThreadIdSync, {
+        threadId: args.threadId,
+      });
     }
     return result;
   },

package/src/component/users.ts

@@ -156,6 +156,7 @@ async function deletePageForUserId(
     });
   await Promise.all(messages.page.map((m) => deleteMessage(ctx, m)));
   if (messages.isDone) {
+    // TODO: delete streams - maybe use workpool?
     await ctx.db.delete(threadInProgress);
     threadInProgress = null;
     messagesCursor = null;

package/src/component/vector/index.ts

@@ -172,6 +172,10 @@ export const updateBatch = mutation({
         model: v.string(),
         id: vVectorId,
         vector: v.array(v.number()),
+        // TODO: support changing the vector length by
+        // deleting from one table and inserting into another.
+        // However this requires updating all the messages that reference
+        // the vector.
       })
     ),
   },

package/src/react/index.ts

@@ -2,11 +2,10 @@
 import type { ErrorMessage } from "convex-helpers";
 import {
   type PaginatedQueryArgs,
-  // usePaginatedQuery,
   type UsePaginatedQueryResult,
   useQuery,
 } from "convex/react";
-import { usePaginatedQuery } from "./usePaginatedQuery.js";
+import { usePaginatedQuery } from "convex-helpers/react";
 import type { FunctionArgs } from "convex/server";
 import { useMemo, useState } from "react";
 import type { MessageDoc } from "../client/index.js";