@convex-dev/agent 0.1.7-alpha.2 → 0.1.7

package/src/client/index.test.ts

@@ -19,6 +19,7 @@ import { MockLanguageModelV1 } from "ai/test";
 import type { LanguageModelV1, LanguageModelV1StreamPart } from "ai";
 import { simulateReadableStream } from "ai";
 import { components, initConvexTest } from "./setup.test";
+import { z } from "zod";
 
 const schema = defineSchema({});
 type DataModel = DataModelFromSchemaDefinition<typeof schema>;
@@ -58,6 +59,16 @@ export const createThread = mutation({
   },
 });
 
+export const createThreadMutation = agent.createThreadMutation();
+export const generateObjectAction = agent.asObjectAction({
+  schema: z.object({
+    prompt: z.any().describe("The prompt passed in"),
+  }),
+});
+export const generateTextAction = agent.asTextAction({});
+export const streamTextAction = agent.asTextAction({ stream: true });
+export const saveMessageMutation = agent.asSaveMessagesMutation();
+
 export const createAndGenerate = action({
   args: {},
   handler: async (ctx) => {
@@ -71,11 +82,87 @@ export const createAndGenerate = action({
   },
 });
 
+export const continueThreadAction = action({
+  args: { threadId: v.string(), userId: v.optional(v.string()) },
+  handler: async (ctx, args) => {
+    const { thread } = await agent.continueThread(ctx, args);
+    return { threadId: thread.threadId };
+  },
+});
+
+export const generateTextWithThread = action({
+  args: {
+    threadId: v.string(),
+    userId: v.optional(v.string()),
+    messages: v.array(v.any()),
+    contextOptions: v.optional(v.any()),
+    storageOptions: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const { thread } = await agent.continueThread(ctx, {
+      threadId: args.threadId,
+      userId: args.userId,
+    });
+    const result = await thread.generateText(
+      { messages: args.messages },
+      {
+        contextOptions: args.contextOptions,
+        storageOptions: args.storageOptions,
+      }
+    );
+    return { text: result.text };
+  },
+});
+
+export const generateObjectWithThread = action({
+  args: {
+    threadId: v.string(),
+    userId: v.optional(v.string()),
+    prompt: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const { thread } = await agent.continueThread(ctx, {
+      threadId: args.threadId,
+      userId: args.userId,
+    });
+    const result = await thread.generateObject({
+      prompt: args.prompt,
+      schema: z.object({ prompt: z.any() }),
+    });
+    return { object: result.object };
+  },
+});
+
+export const fetchContextAction = action({
+  args: {
+    userId: v.optional(v.string()),
+    threadId: v.optional(v.string()),
+    messages: v.array(v.any()),
+    contextOptions: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const context = await agent.fetchContextMessages(ctx, {
+      userId: args.userId,
+      threadId: args.threadId,
+      messages: args.messages,
+      contextOptions: args.contextOptions,
+    });
+    return context;
+  },
+});
+
 const testApi: ApiFromModules<{
   fns: {
     createAndGenerate: typeof createAndGenerate;
     createThread: typeof createThread;
     testQuery: typeof testQuery;
+    continueThreadAction: typeof continueThreadAction;
+    generateTextWithThread: typeof generateTextWithThread;
+    generateObjectWithThread: typeof generateObjectWithThread;
+    fetchContextAction: typeof fetchContextAction;
+    generateTextAction: typeof generateTextAction;
+    generateObjectAction: typeof generateObjectAction;
+    saveMessageMutation: typeof saveMessageMutation;
   };
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
 }>["fns"] = anyApi["index.test"] as any;
@@ -90,7 +177,7 @@ describe("Agent thick client", () => {
     const t = initConvexTest(schema);
     const result = await t.action(testApi.createAndGenerate, {});
     expect(result).toBeDefined();
-    expect(result).toMatch("This is a sample response");
+    expect(result).toMatch("Hello");
   });
 });
 
@@ -164,12 +251,14 @@ function mockModel(): LanguageModelV1 {
   return new MockLanguageModelV1({
     provider: "mock",
     modelId: "mock",
+    defaultObjectGenerationMode: "json",
+    // supportsStructuredOutputs: true,
     doGenerate: async ({ prompt }) => ({
       finishReason: "stop",
       usage: { completionTokens: 10, promptTokens: 3 },
       logprobs: undefined,
       rawCall: { rawPrompt: null, rawSettings: {} },
-      text: `This is a sample response to ${JSON.stringify(prompt)}`,
+      text: JSON.stringify({ prompt }),
     }),
     doStream: async ({ prompt }) => ({
       stream: simulateReadableStream({
@@ -192,3 +281,177 @@ function mockModel(): LanguageModelV1 {
     }),
   });
 }
+
+describe("Agent option variations and normal behavior", () => {
+  test("Agent can be constructed with minimal options", () => {
+    const a = new Agent(components.agent, { chat: mockModel() });
+    expect(a).toBeInstanceOf(Agent);
+  });
+
+  test("Agent can be constructed with all options", () => {
+    const a = new Agent(components.agent, {
+      name: "full",
+      chat: mockModel(),
+      instructions: "Test instructions",
+      contextOptions: { recentMessages: 5 },
+      storageOptions: { saveMessages: "all" },
+      maxSteps: 2,
+      maxRetries: 1,
+      usageHandler: async () => {},
+      rawRequestResponseHandler: async () => {},
+    });
+    expect(a.options.name).toBe("full");
+  });
+});
+
+describe("Agent thread management", () => {
+  test("createThread returns threadId (mutation context)", async () => {
+    const t = initConvexTest(schema);
+    const { threadId } = await t.run(async (ctx) =>
+      agent.createThread(ctx, { userId: "2" })
+    );
+    expect(threadId).toBeTypeOf("string");
+  });
+
+  test("continueThread returns thread object", async () => {
+    const t = initConvexTest(schema);
+    const { threadId } = await t.run(async (ctx) =>
+      agent.createThread(ctx, { userId: "3" })
+    );
+    const result = await t.action(testApi.continueThreadAction, {
+      threadId,
+      userId: "3",
+    });
+    expect(result.threadId).toBe(threadId);
+  });
+});
+
+describe("Agent message operations", () => {
+  test("saveMessage and saveMessages store messages", async () => {
+    const t = initConvexTest(schema);
+    const { threadId } = await t.run(async (ctx) =>
+      agent.createThread(ctx, { userId: "4" })
+    );
+    const { messageId } = await t.run(async (ctx) =>
+      agent.saveMessage(ctx, {
+        threadId,
+        userId: "4",
+        message: { role: "user", content: "Hello" },
+      })
+    );
+    expect(messageId).toBeTypeOf("string");
+
+    const { lastMessageId, messages } = await t.run(async (ctx) =>
+      agent.saveMessages(ctx, {
+        threadId,
+        userId: "4",
+        messages: [
+          { role: "user", content: "Hi" },
+          { role: "assistant", content: "Hello!" },
+        ],
+      })
+    );
+    expect(messages.length).toBe(2);
+    expect(lastMessageId).toBe(messages[1]._id);
+  });
+});
+
+describe("Agent text/object generation", () => {
+  test("generateText with custom context and storage options", async () => {
+    const t = initConvexTest(schema);
+    const { threadId } = await t.run(async (ctx) =>
+      agent.createThread(ctx, { userId: "5" })
+    );
+    const result = await t.action(testApi.generateTextWithThread, {
+      threadId,
+      userId: "5",
+      messages: [{ role: "user", content: "Test" }],
+      contextOptions: { recentMessages: 1 },
+      storageOptions: { saveMessages: "all" },
+    });
+    expect(result.text).toMatch(/Test/);
+  });
+
+  test("generateObject returns object", async () => {
+    const t = initConvexTest(schema);
+    const { threadId } = await t.run(async (ctx) =>
+      agent.createThread(ctx, { userId: "6" })
+    );
+    const result = await t.action(testApi.generateObjectWithThread, {
+      threadId,
+      userId: "6",
+      prompt: "Object please",
+    });
+    expect(result.object).toBeDefined();
+  });
+});
+
+describe("Agent-generated mutations/actions/queries", () => {
+  test("createThreadMutation works via t.mutation", async () => {
+    const t = initConvexTest(schema);
+    // This test is for the registered mutation, not the agent method
+    const result = await t.mutation(testApi.createThread, {});
+    expect(result.threadId).toBeTypeOf("string");
+  });
+
+  test("asTextAction and asObjectAction work via t.action", async () => {
+    const t = initConvexTest(schema);
+    const { threadId } = await t.run(async (ctx) =>
+      agent.createThread(ctx, { userId: "8" })
+    );
+    const textResult = await t.action(testApi.generateTextAction, {
+      userId: "8",
+      threadId,
+      messages: [{ role: "user", content: "Say hi" }],
+    });
+    expect(textResult.text).toMatch(/Say hi/);
+
+    const objResult = await t.action(testApi.generateObjectAction, {
+      userId: "8",
+      threadId,
+      messages: [{ role: "user", content: "Give object" }],
+    });
+    expect(objResult.object).toBeDefined();
+  });
+
+  test("asSaveMessagesMutation works via t.mutation", async () => {
+    const t = initConvexTest(schema);
+    const { threadId } = await t.run(async (ctx) =>
+      agent.createThread(ctx, { userId: "9" })
+    );
+    const result = await t.mutation(testApi.saveMessageMutation, {
+      threadId,
+      messages: [
+        {
+          message: { role: "user", content: "Saved via mutation" },
+          // add more metadata fields as needed
+        },
+      ],
+    });
+    expect(result.lastMessageId).toBeDefined();
+    expect(result.messageIds.length).toBe(1);
+  });
+});
+
+describe("Agent context and search options", () => {
+  test("fetchContextMessages returns context messages", async () => {
+    const t = initConvexTest(schema);
+    const { threadId } = await t.run(async (ctx) =>
+      agent.createThread(ctx, { userId: "10" })
+    );
+    await t.run(async (ctx) =>
+      agent.saveMessage(ctx, {
+        threadId,
+        userId: "10",
+        message: { role: "user", content: "Context test" },
+      })
+    );
+    const context = await t.action(testApi.fetchContextAction, {
+      userId: "10",
+      threadId,
+      messages: [{ role: "user", content: "Context test" }],
+      contextOptions: { recentMessages: 1 },
+    });
+    expect(context.length).toBeGreaterThan(0);
+  });
+});

package/src/react/deltas.test.ts

@@ -287,7 +287,17 @@ describe("mergeDeltas", () => {
     expect(messages1.map((m) => omit(m, ["_creationTime"]))).toEqual(
       messages2.map((m) => omit(m, ["_creationTime"]))
     );
-    expect(streams1).toEqual(streams2);
+    expect(
+      streams1.map((s) => ({
+        ...s,
+        messages: s.messages.map((m) => omit(m, ["_creationTime"])),
+      }))
+    ).toEqual(
+      streams2.map((s) => ({
+        ...s,
+        messages: s.messages.map((m) => omit(m, ["_creationTime"])),
+      }))
+    );
     expect(changed1).toBe(changed2);
     // Inputs should remain unchanged
     expect(streamMessages).toEqual([makeStreamMessage(streamId, 8, 0)]);

package/src/react/usePaginatedQuery.ts

@@ -279,7 +279,6 @@ export function usePaginatedQuery<Query extends PaginatedQueryReference>(
       allItems.push(...currResult.page);
     }
     return [allItems, currResult];
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [
     resultsObject,
     currState.pageKeys,