@convex-dev/agent 0.5.0-alpha.1 → 0.6.0-alpha.1

package/src/component/_generated/{server.d.ts → server.ts}

@@ -8,9 +8,8 @@
  * @module
  */
 
-import {
+import type {
   ActionBuilder,
-  AnyComponents,
   HttpActionBuilder,
   MutationBuilder,
   QueryBuilder,
@@ -19,15 +18,18 @@ import {
   GenericQueryCtx,
   GenericDatabaseReader,
   GenericDatabaseWriter,
-  FunctionReference,
+} from "convex/server";
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
 } from "convex/server";
 import type { DataModel } from "./dataModel.js";
 
-type GenericCtx =
-  | GenericActionCtx<DataModel>
-  | GenericMutationCtx<DataModel>
-  | GenericQueryCtx<DataModel>;
-
 /**
  * Define a query in this Convex app's public API.
  *
@@ -36,7 +38,7 @@ type GenericCtx =
  * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
  * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
  */
-export declare const query: QueryBuilder<DataModel, "public">;
+export const query: QueryBuilder<DataModel, "public"> = queryGeneric;
 
 /**
  * Define a query that is only accessible from other Convex functions (but not from the client).
@@ -46,7 +48,8 @@ export declare const query: QueryBuilder<DataModel, "public">;
  * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
  * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
  */
-export declare const internalQuery: QueryBuilder<DataModel, "internal">;
+export const internalQuery: QueryBuilder<DataModel, "internal"> =
+  internalQueryGeneric;
 
 /**
  * Define a mutation in this Convex app's public API.
@@ -56,7 +59,7 @@ export declare const internalQuery: QueryBuilder<DataModel, "internal">;
  * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
  * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
  */
-export declare const mutation: MutationBuilder<DataModel, "public">;
+export const mutation: MutationBuilder<DataModel, "public"> = mutationGeneric;
 
 /**
  * Define a mutation that is only accessible from other Convex functions (but not from the client).
@@ -66,7 +69,8 @@ export declare const mutation: MutationBuilder<DataModel, "public">;
  * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
  * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
  */
-export declare const internalMutation: MutationBuilder<DataModel, "internal">;
+export const internalMutation: MutationBuilder<DataModel, "internal"> =
+  internalMutationGeneric;
 
 /**
  * Define an action in this Convex app's public API.
@@ -79,7 +83,7 @@ export declare const internalMutation: MutationBuilder<DataModel, "internal">;
  * @param func - The action. It receives an {@link ActionCtx} as its first argument.
  * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
  */
-export declare const action: ActionBuilder<DataModel, "public">;
+export const action: ActionBuilder<DataModel, "public"> = actionGeneric;
 
 /**
  * Define an action that is only accessible from other Convex functions (but not from the client).
@@ -87,19 +91,26 @@ export declare const action: ActionBuilder<DataModel, "public">;
  * @param func - The function. It receives an {@link ActionCtx} as its first argument.
  * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
  */
-export declare const internalAction: ActionBuilder<DataModel, "internal">;
+export const internalAction: ActionBuilder<DataModel, "internal"> =
+  internalActionGeneric;
 
 /**
  * Define an HTTP action.
  *
- * This function will be used to respond to HTTP requests received by a Convex
- * deployment if the requests matches the path and method where this action
- * is routed. Be sure to route your action in `convex/http.js`.
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
  *
- * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
  * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
  */
-export declare const httpAction: HttpActionBuilder;
+export const httpAction: HttpActionBuilder = httpActionGeneric;
+
+type GenericCtx =
+  | GenericActionCtx<DataModel>
+  | GenericMutationCtx<DataModel>
+  | GenericQueryCtx<DataModel>;
 
 /**
  * A set of services for use within Convex query functions.
@@ -107,8 +118,7 @@ export declare const httpAction: HttpActionBuilder;
  * The query context is passed as the first argument to any Convex query
  * function run on the server.
  *
- * This differs from the {@link MutationCtx} because all of the services are
- * read-only.
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
  */
 export type QueryCtx = GenericQueryCtx<DataModel>;
 
@@ -117,6 +127,8 @@ export type QueryCtx = GenericQueryCtx<DataModel>;
  *
  * The mutation context is passed as the first argument to any Convex mutation
  * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
  */
 export type MutationCtx = GenericMutationCtx<DataModel>;
 

package/src/component/files.ts

@@ -9,7 +9,9 @@ const addFileArgs = v.object({
   storageId: v.string(),
   hash: v.string(),
   filename: v.optional(v.string()),
-  mimeType: v.string(),
+  mediaType: v.optional(v.string()),
+  /** @deprecated Use `mediaType` instead. */
+  mimeType: v.optional(v.string()),
 });
 
 export const addFile = mutation({
@@ -25,6 +27,9 @@ export async function addFileHandler(
   ctx: MutationCtx,
   args: Infer<typeof addFileArgs>,
 ) {
+  // Support both mediaType (preferred) and mimeType (deprecated)
+  const mediaType = args.mediaType ?? args.mimeType;
+  
   const existingFile = await ctx.db
     .query("files")
     .withIndex("hash", (q) => q.eq("hash", args.hash))
@@ -42,7 +47,11 @@ export async function addFileHandler(
     };
   }
   const fileId = await ctx.db.insert("files", {
-    ...args,
+    storageId: args.storageId,
+    hash: args.hash,
+    filename: args.filename,
+    mediaType,
+    mimeType: args.mimeType, // Keep for backwards compatibility
     // We start out with it unused - when it's saved in a message we increment.
     refcount: 0,
     lastTouchedAt: Date.now(),

package/src/component/messages.test.ts

@@ -6,11 +6,11 @@ import { api } from "./_generated/api.js";
 import type { Id } from "./_generated/dataModel.js";
 import { getMaxMessage } from "./messages.js";
 import schema from "./schema.js";
-import { modules } from "./setup.test.js";
+import { initConvexTest, modules } from "./setup.test.js";
 
 describe("agent", () => {
   test("getMaxMessage works for threads", async () => {
-    const t = convexTest(schema, modules);
+    const t = initConvexTest();
     const thread = await t.mutation(api.threads.createThread, {
       userId: "test",
     });
@@ -30,6 +30,29 @@ describe("agent", () => {
       stepOrder: 1,
     });
   });
+  test("getMaxMessage works for a specific order", 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" } },
+        { message: { role: "assistant", content: "step 1" } },
+        { message: { role: "user", content: "hello2" } },
+      ],
+    });
+    const maxMessage = await t.run(async (ctx) => {
+      return await getMaxMessage(ctx, thread._id as Id<"threads">, 0);
+    });
+    expect(maxMessage).toMatchObject({
+      _id: messages.at(1)!._id,
+      order: 0,
+      stepOrder: 1,
+    });
+  });
+
   test("getMaxMessages works when there are tools involved", async () => {
     const t = convexTest(schema, modules);
     const thread = await t.mutation(api.threads.createThread, {
@@ -45,7 +68,7 @@ describe("agent", () => {
             content: [
               {
                 type: "tool-call",
-                args: { a: 1 },
+                input: { a: 1 },
                 toolCallId: "1",
                 toolName: "tool",
               },
@@ -78,7 +101,7 @@ describe("agent", () => {
     });
   });
 
-  test("ordering is incremented on subsequent calls to addMessages", async () => {
+  test("ordering is incremented on subsequent calls to addMessages for user messages", async () => {
     const t = convexTest(schema, modules);
     const thread = await t.mutation(api.threads.createThread, {
       userId: "test",
@@ -109,7 +132,38 @@ describe("agent", () => {
     });
   });
 
-  test("sub order is incremented on subsequent calls to addMessages for the same promptMessageId", async () => {
+  test("ordering is incremented on subsequent calls to addMessages for assistant 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: "user", content: "hello" } }],
+    });
+    const maxMessage = await t.run(async (ctx) => {
+      return await getMaxMessage(ctx, thread._id as Id<"threads">);
+    });
+    expect(maxMessage).toMatchObject({
+      _id: messages.at(-1)!._id,
+      order: 0,
+      stepOrder: 0,
+    });
+    const { messages: messages2 } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [{ message: { role: "assistant", content: "hello" } }],
+    });
+    const maxMessage2 = await t.run(async (ctx) => {
+      return await getMaxMessage(ctx, thread._id as Id<"threads">);
+    });
+    expect(maxMessage2).toMatchObject({
+      _id: messages2.at(-1)!._id,
+      order: 0,
+      stepOrder: 1,
+    });
+  });
+
+  test("order is incremented for user messages on to addMessages for the same promptMessageId", async () => {
     const t = convexTest(schema, modules);
     const thread = await t.mutation(api.threads.createThread, {
       userId: "test",
@@ -135,6 +189,39 @@ describe("agent", () => {
     const maxMessage2 = await t.run(async (ctx) => {
       return await getMaxMessage(ctx, thread._id as Id<"threads">);
     });
+    expect(maxMessage2).toMatchObject({
+      _id: messages2.at(-1)!._id,
+      order: 1,
+      stepOrder: 0,
+    });
+  });
+
+  test("sub order is incremented on subsequent calls to addMessages for the same promptMessageId", 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 maxMessage = await t.run(async (ctx) => {
+      return await getMaxMessage(ctx, thread._id as Id<"threads">);
+    });
+    expect(maxMessage).toMatchObject({
+      _id: messages.at(-1)!._id,
+      order: 0,
+      stepOrder: 0,
+    });
+    const { messages: messages2 } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [{ message: { role: "assistant", content: "hello" } }],
+      agentName: "test",
+      promptMessageId: messages.at(-1)!._id as Id<"messages">,
+    });
+    const maxMessage2 = await t.run(async (ctx) => {
+      return await getMaxMessage(ctx, thread._id as Id<"threads">);
+    });
     expect(maxMessage2).toMatchObject({
       _id: messages2.at(-1)!._id,
       order: 0,
@@ -142,6 +229,83 @@ describe("agent", () => {
     });
   });
 
+  test("adding multiple messages at a promptMessageId skips later 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: "user", content: "hello" } }],
+    });
+
+    const { messages: messages2 } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [
+        { message: { role: "user", content: "hello2" } },
+        { message: { role: "assistant", content: "hello" } },
+      ],
+      agentName: "test",
+    });
+    expect(messages2.length).toBe(2);
+
+    const { messages: messages3 } = await t.mutation(api.messages.addMessages, {
+      threadId: thread._id as Id<"threads">,
+      messages: [
+        {
+          message: {
+            role: "assistant",
+            content: [
+              {
+                type: "tool-call",
+                input: { a: 1 },
+                toolCallId: "1",
+                toolName: "tool",
+              },
+            ],
+          },
+        },
+        {
+          message: {
+            role: "tool",
+            content: [
+              {
+                type: "tool-result",
+                toolName: "tool",
+                result: "foo",
+                toolCallId: "1",
+              },
+            ],
+          },
+        },
+        { message: { role: "user", content: "bye" } },
+      ],
+      agentName: "test",
+      promptMessageId: messages.at(-1)!._id as Id<"messages">,
+    });
+
+    expect(messages3.length).toBe(3);
+
+    const allMessages = await t.query(api.messages.listMessagesByThreadId, {
+      threadId: thread._id as Id<"threads">,
+      order: "asc",
+    });
+    expect(allMessages.page).toHaveLength(6);
+    expect(allMessages.page.map((m) => m.order)).toEqual([0, 0, 0, 1, 1, 2]);
+    expect(allMessages.page.map((m) => m.stepOrder)).toEqual([
+      0, 1, 2, 0, 1, 0,
+    ]);
+    expect(allMessages.page[0]!.message!.role).toBe("user");
+    expect(allMessages.page[0]!.message!.content).toBe("hello");
+    expect(allMessages.page[1]!.message!.role).toBe("assistant");
+    expect(allMessages.page[2]!.message!.role).toBe("tool");
+    expect(allMessages.page[3]!.message!.role).toBe("user");
+    expect(allMessages.page[3]!.message!.content).toBe("hello2");
+    expect(allMessages.page[4]!.message!.role).toBe("assistant");
+    expect(allMessages.page[5]!.message!.role).toBe("user");
+    expect(allMessages.page[5]!.message!.content).toBe("bye");
+  });
+
   test("updateMessage updates message content", async () => {
     const t = convexTest(schema, modules);
     const thread = await t.mutation(api.threads.createThread, {
@@ -155,9 +319,7 @@ describe("agent", () => {
 
     const updatedMessage = await t.mutation(api.messages.updateMessage, {
       messageId,
-      patch: {
-        message: { role: "user", content: "updated content" },
-      },
+      patch: { message: { role: "user", content: "updated content" } },
     });
 
     expect(updatedMessage.message).toEqual({
@@ -173,8 +335,9 @@ describe("agent", () => {
     });
     const { messages } = await t.mutation(api.messages.addMessages, {
       threadId: thread._id as Id<"threads">,
-      messages: [{ message: { role: "assistant", content: "hello" } }],
-      pending: true,
+      messages: [
+        { message: { role: "assistant", content: "hello" }, status: "pending" },
+      ],
     });
     const messageId = messages[0]._id as Id<"messages">;
 
@@ -184,9 +347,7 @@ describe("agent", () => {
     // Update to success
     const updatedMessage = await t.mutation(api.messages.updateMessage, {
       messageId,
-      patch: {
-        status: "success",
-      },
+      patch: { status: "success" },
     });
 
     expect(updatedMessage.status).toBe("success");
@@ -199,17 +360,15 @@ describe("agent", () => {
     });
     const { messages } = await t.mutation(api.messages.addMessages, {
       threadId: thread._id as Id<"threads">,
-      messages: [{ message: { role: "assistant", content: "hello" } }],
-      pending: true,
+      messages: [
+        { message: { role: "assistant", content: "hello" }, status: "pending" },
+      ],
     });
     const messageId = messages[0]._id as Id<"messages">;
 
     const updatedMessage = await t.mutation(api.messages.updateMessage, {
       messageId,
-      patch: {
-        status: "failed",
-        error: "Something went wrong",
-      },
+      patch: { status: "failed", error: "Something went wrong" },
     });
 
     expect(updatedMessage.status).toBe("failed");
@@ -230,7 +389,7 @@ describe("agent", () => {
             content: [
               {
                 type: "tool-call",
-                args: { a: 1 },
+                input: { a: 1 },
                 toolCallId: "1",
                 toolName: "tool",
               },
@@ -249,7 +408,7 @@ describe("agent", () => {
           content: [
             {
               type: "tool-call",
-              args: { a: 2, b: 3 },
+              input: { a: 2, b: 3 },
               toolCallId: "1",
               toolName: "tool",
             },
@@ -263,7 +422,7 @@ describe("agent", () => {
       content: [
         {
           type: "tool-call",
-          args: { a: 2, b: 3 },
+          input: { a: 2, b: 3 },
           toolCallId: "1",
           toolName: "tool",
         },
@@ -277,9 +436,7 @@ describe("agent", () => {
     await expect(
       t.mutation(api.messages.updateMessage, {
         messageId: "invalidId" as Id<"messages">,
-        patch: {
-          message: { role: "user", content: "test" },
-        },
+        patch: { message: { role: "user", content: "test" } },
       }),
     ).rejects.toThrow();
   });
@@ -308,10 +465,7 @@ describe("agent", () => {
     // Verify messages are actually deleted
     const remainingMessages = await t.query(
       api.messages.listMessagesByThreadId,
-      {
-        threadId: thread._id as Id<"threads">,
-        order: "asc",
-      },
+      { threadId: thread._id as Id<"threads">, order: "asc" },
     );
     expect(remainingMessages.page).toHaveLength(1);
     expect(remainingMessages.page[0]._id).toBe(messageIds[1]);
@@ -343,10 +497,7 @@ describe("agent", () => {
     // Verify the valid message was deleted
     const remainingMessages = await t.query(
       api.messages.listMessagesByThreadId,
-      {
-        threadId: thread._id as Id<"threads">,
-        order: "asc",
-      },
+      { threadId: thread._id as Id<"threads">, order: "asc" },
     );
     expect(remainingMessages.page).toHaveLength(0);
   });
@@ -385,24 +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",
-      },
+      { 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 () => {
@@ -417,7 +567,7 @@ describe("agent", () => {
       messages: [
         { message: { role: "user", content: "step 0" } },
         { message: { role: "assistant", content: "step 1" } },
-        { message: { role: "user", content: "step 2" } },
+        { message: { role: "assistant", content: "step 2" } },
         { message: { role: "assistant", content: "step 3" } },
       ],
     });
@@ -438,10 +588,7 @@ describe("agent", () => {
     // Verify only step 1 and 2 were deleted (step 3 is excluded by upperBoundInclusive: false)
     const remainingMessages = await t.query(
       api.messages.listMessagesByThreadId,
-      {
-        threadId: thread._id as Id<"threads">,
-        order: "asc",
-      },
+      { threadId: thread._id as Id<"threads">, order: "asc" },
     );
 
     expect(remainingMessages.page).toHaveLength(2);
@@ -501,10 +648,7 @@ describe("agent", () => {
     // Verify original message is still there
     const remainingMessages = await t.query(
       api.messages.listMessagesByThreadId,
-      {
-        threadId: thread._id as Id<"threads">,
-        order: "asc",
-      },
+      { threadId: thread._id as Id<"threads">, order: "asc" },
     );
     expect(remainingMessages.page).toHaveLength(1);
   });