@convex-dev/agent 0.0.16 → 0.0.17-alpha.0

package/src/component/apiKeys.ts

@@ -0,0 +1,74 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+export const issue = mutation({
+  args: {
+    name: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    if (args.name) {
+      const existingApiKey = await ctx.db
+        .query("apiKeys")
+        .withIndex("name", (q) => q.eq("name", args.name))
+        .first();
+      if (existingApiKey) {
+        console.warn(`API key ${args.name} already exists, deleting...`);
+        await ctx.db.delete(existingApiKey._id);
+      }
+    }
+    const apiKey = await ctx.db.insert("apiKeys", args);
+    return apiKey;
+  },
+  returns: v.id("apiKeys"),
+});
+
+export const validate = query({
+  args: {
+    apiKey: v.id("apiKeys"),
+  },
+  handler: async (ctx, args) => {
+    const apiKey = await ctx.db.get(args.apiKey);
+    if (!apiKey) {
+      throw new Error("Invalid API key");
+    }
+    return true;
+  },
+  returns: v.boolean(),
+});
+
+export const destroy = mutation({
+  args: v.object({
+    apiKey: v.optional(v.id("apiKeys")),
+    name: v.optional(v.string()),
+  }),
+  handler: async (ctx, args) => {
+    if (args.apiKey) {
+      const apiKey = await ctx.db.get(args.apiKey);
+      if (!apiKey) {
+        return "missing";
+      }
+      if (apiKey.name !== args.name) {
+        return "name mismatch";
+      }
+      await ctx.db.delete(args.apiKey);
+    } else if (args.name) {
+      const apiKey = await ctx.db
+        .query("apiKeys")
+        .withIndex("name", (q) => q.eq("name", args.name))
+        .first();
+      if (!apiKey) {
+        return "missing";
+      }
+      await ctx.db.delete(apiKey._id);
+    } else {
+      return "must provide either apiKey or name";
+    }
+    return "deleted";
+  },
+  returns: v.union(
+    v.literal("missing"),
+    v.literal("deleted"),
+    v.literal("name mismatch"),
+    v.literal("must provide either apiKey or name")
+  ),
+});

package/src/component/files.ts

@@ -0,0 +1,72 @@
+import { paginator } from "convex-helpers/server/pagination";
+import { mutation, MutationCtx, query } from "./_generated/server.js";
+import { schema, v } from "./schema.js";
+import { Id } from "./_generated/dataModel.js";
+
+export const addFile = mutation({
+  args: {
+    storageId: v.string(),
+    hash: v.string(),
+  },
+  handler: addFileHandler,
+  returns: v.id("files"),
+});
+
+export async function addFileHandler(
+  ctx: MutationCtx,
+  args: { storageId: string; hash: string }
+) {
+  const fileId = await ctx.db.insert("files", {
+    storageId: args.storageId,
+    hash: args.hash,
+    refcount: 1,
+  });
+  return fileId;
+}
+
+export const resuseFile = mutation({
+  args: {
+    fileId: v.id("files"),
+  },
+  handler: reuseFileHandler,
+  returns: v.null(),
+});
+
+export async function reuseFileHandler(
+  ctx: MutationCtx,
+  args: { fileId: Id<"files"> }
+) {
+  const file = await ctx.db.get(args.fileId);
+  if (!file) {
+    throw new Error("File not found");
+  }
+  await ctx.db.patch(args.fileId, {
+    refcount: file.refcount + 1,
+  });
+}
+
+export const getFilesToDelete = query({
+  args: {
+    cursor: v.optional(v.string()),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const files = await paginator(ctx.db, schema)
+      .query("files")
+      .withIndex("refcount", (q) => q.eq("refcount", 0))
+      .paginate({
+        numItems: args.limit ?? 100,
+        cursor: args.cursor ?? null,
+      });
+    return {
+      files: files.page,
+      continueCursor: files.continueCursor,
+      isDone: files.isDone,
+    };
+  },
+  returns: v.object({
+    files: v.array(v.doc("files")),
+    continueCursor: v.string(),
+    isDone: v.boolean(),
+  }),
+});

package/src/component/messages.test.ts

@@ -5,9 +5,32 @@ import { convexTest } from "convex-test";
 import schema from "./schema.js";
 import { api } from "./_generated/api.js";
 import { modules } from "./setup.test.js";
+import { Id } from "./_generated/dataModel.js";
+import { getMaxMessage } from "./messages.js";
 
 describe("agent", () => {
   test("add and subtract", async () => {
     const t = convexTest(schema, modules);
   });
+  test("getMaxMessage works for threads", 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: "world" } },
+      ],
+    });
+    const maxMessage = await t.run(async (ctx) => {
+      return await getMaxMessage(ctx, thread._id as Id<"threads">, "test");
+    });
+    expect(maxMessage).toMatchObject({
+      _id: messages.at(-1)!._id,
+      order: 1,
+      stepOrder: 0,
+    });
+  });
 });