@convex-dev/agent 0.0.15-alpha.1 → 0.0.16-alpha.0

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

@@ -8,7 +8,11 @@
  * @module
  */
 
+import type * as apiKeys from "../apiKeys.js";
+import type * as files from "../files.js";
 import type * as messages from "../messages.js";
+import type * as threads from "../threads.js";
+import type * as users from "../users.js";
 import type * as vector_index from "../vector/index.js";
 import type * as vector_tables from "../vector/tables.js";
 
@@ -27,11 +31,58 @@ import type {
  * ```
  */
 declare const fullApi: ApiFromModules<{
+  apiKeys: typeof apiKeys;
+  files: typeof files;
   messages: typeof messages;
+  threads: typeof threads;
+  users: typeof users;
   "vector/index": typeof vector_index;
   "vector/tables": typeof vector_tables;
 }>;
 export type Mounts = {
+  apiKeys: {
+    destroy: FunctionReference<
+      "mutation",
+      "public",
+      { apiKey?: string; name?: string },
+      | "missing"
+      | "deleted"
+      | "name mismatch"
+      | "must provide either apiKey or name"
+    >;
+    issue: FunctionReference<"mutation", "public", { name?: string }, string>;
+    validate: FunctionReference<"query", "public", { apiKey: string }, boolean>;
+  };
+  files: {
+    addFile: FunctionReference<
+      "mutation",
+      "public",
+      { hash: string; storageId: string },
+      string
+    >;
+    getFilesToDelete: FunctionReference<
+      "query",
+      "public",
+      { cursor?: string; limit?: number },
+      {
+        continueCursor: string;
+        files: Array<{
+          _creationTime: number;
+          _id: string;
+          hash: string;
+          refcount: number;
+          storageId: string;
+        }>;
+        isDone: boolean;
+      }
+    >;
+    resuseFile: FunctionReference<
+      "mutation",
+      "public",
+      { fileId: string },
+      null
+    >;
+  };
   messages: {
     addMessages: FunctionReference<
       "mutation",
@@ -496,7 +547,7 @@ export type Mounts = {
       "public",
       {
         failPendingSteps?: boolean;
-        messageId: string;
+        parentMessageId: string;
         step: {
           messages: Array<{
             embedding?: {
@@ -1066,102 +1117,10 @@ export type Mounts = {
       { messageId: string },
       null
     >;
-    createThread: FunctionReference<
-      "mutation",
-      "public",
-      {
-        defaultSystemPrompt?: string;
-        parentThreadIds?: Array<string>;
-        summary?: string;
-        title?: string;
-        userId?: string;
-      },
-      {
-        _creationTime: number;
-        _id: string;
-        defaultSystemPrompt?: string;
-        order?: number;
-        parentThreadIds?: Array<string>;
-        status: "active" | "archived";
-        summary?: string;
-        title?: string;
-        userId?: string;
-      }
-    >;
-    deleteAllForThreadIdAsync: FunctionReference<
-      "mutation",
-      "public",
-      { cursor?: string; limit?: number; threadId: string },
-      { cursor: string; isDone: boolean }
-    >;
-    deleteAllForThreadIdSync: FunctionReference<
-      "action",
-      "public",
-      { cursor?: string; limit?: number; threadId: string },
-      { cursor: string; isDone: boolean }
-    >;
-    deleteAllForUserId: FunctionReference<
-      "action",
-      "public",
-      { userId: string },
-      null
-    >;
-    deleteAllForUserIdAsync: FunctionReference<
-      "mutation",
-      "public",
-      { userId: string },
-      boolean
-    >;
-    getFilesToDelete: FunctionReference<
-      "query",
-      "public",
-      { cursor?: string; limit?: number },
-      {
-        continueCursor: string;
-        files: Array<{
-          _creationTime: number;
-          _id: string;
-          hash: string;
-          refcount: number;
-          storageId: string;
-        }>;
-        isDone: boolean;
-      }
-    >;
-    getThread: FunctionReference<
-      "query",
-      "public",
-      { threadId: string },
-      {
-        _creationTime: number;
-        _id: string;
-        defaultSystemPrompt?: string;
-        order?: number;
-        parentThreadIds?: Array<string>;
-        status: "active" | "archived";
-        summary?: string;
-        title?: string;
-        userId?: string;
-      } | null
-    >;
     getThreadMessages: FunctionReference<
       "query",
       "public",
-      {
-        isTool?: boolean;
-        order?: "asc" | "desc";
-        paginationOpts?: {
-          cursor: string | null;
-          endCursor?: string | null;
-          id?: number;
-          maximumBytesRead?: number;
-          maximumRowsRead?: number;
-          numItems: number;
-        };
-        parentMessageId?: string;
-        statuses?: Array<"pending" | "success" | "failed">;
-        threadId: string;
-      },
+      { deprecated: "Use listMessagesByThreadId instead" },
       {
         continueCursor: string;
         isDone: boolean;
@@ -1322,10 +1281,13 @@ export type Mounts = {
         splitCursor?: string | null;
       }
     >;
-    getThreadsByUserId: FunctionReference<
+    listMessagesByThreadId: FunctionReference<
       "query",
       "public",
       {
+        beforeMessageId?: string;
+        excludeToolMessages?: boolean;
+        isTool?: "use excludeToolMessages instead of this";
         order?: "asc" | "desc";
         paginationOpts?: {
           cursor: string | null;
@@ -1335,7 +1297,8 @@ export type Mounts = {
           maximumRowsRead?: number;
           numItems: number;
         };
-        userId: string;
+        statuses?: Array<"pending" | "success" | "failed">;
+        threadId: string;
       },
       {
         continueCursor: string;
@@ -1343,13 +1306,155 @@ export type Mounts = {
         page: Array<{
           _creationTime: number;
           _id: string;
-          defaultSystemPrompt?: string;
-          order?: number;
-          parentThreadIds?: Array<string>;
-          status: "active" | "archived";
-          summary?: string;
-          title?: string;
+          agentName?: string;
+          embeddingId?:
+            | string
+            | string
+            | string
+            | string
+            | string
+            | string
+            | string
+            | string
+            | string;
+          error?: string;
+          fileId?: string;
+          finishReason?:
+            | "stop"
+            | "length"
+            | "content-filter"
+            | "tool-calls"
+            | "error"
+            | "other"
+            | "unknown";
+          id?: string;
+          message?:
+            | {
+                content:
+                  | string
+                  | Array<
+                      | {
+                          experimental_providerMetadata?: Record<string, any>;
+                          providerOptions?: Record<string, any>;
+                          text: string;
+                          type: "text";
+                        }
+                      | {
+                          experimental_providerMetadata?: Record<string, any>;
+                          image: string | ArrayBuffer;
+                          mimeType?: string;
+                          providerOptions?: Record<string, any>;
+                          type: "image";
+                        }
+                      | {
+                          data: string | ArrayBuffer;
+                          experimental_providerMetadata?: Record<string, any>;
+                          mimeType: string;
+                          providerOptions?: Record<string, any>;
+                          type: "file";
+                        }
+                    >;
+                experimental_providerMetadata?: Record<string, any>;
+                providerOptions?: Record<string, any>;
+                role: "user";
+              }
+            | {
+                content:
+                  | string
+                  | Array<
+                      | {
+                          experimental_providerMetadata?: Record<string, any>;
+                          providerOptions?: Record<string, any>;
+                          text: string;
+                          type: "text";
+                        }
+                      | {
+                          data: string | ArrayBuffer;
+                          experimental_providerMetadata?: Record<string, any>;
+                          mimeType: string;
+                          providerOptions?: Record<string, any>;
+                          type: "file";
+                        }
+                      | {
+                          experimental_providerMetadata?: Record<string, any>;
+                          providerOptions?: Record<string, any>;
+                          text: string;
+                          type: "reasoning";
+                        }
+                      | {
+                          data: string;
+                          experimental_providerMetadata?: Record<string, any>;
+                          providerOptions?: Record<string, any>;
+                          type: "redacted-reasoning";
+                        }
+                      | {
+                          args: any;
+                          experimental_providerMetadata?: Record<string, any>;
+                          providerOptions?: Record<string, any>;
+                          toolCallId: string;
+                          toolName: string;
+                          type: "tool-call";
+                        }
+                    >;
+                experimental_providerMetadata?: Record<string, any>;
+                providerOptions?: Record<string, any>;
+                role: "assistant";
+              }
+            | {
+                content: Array<{
+                  args?: any;
+                  experimental_content?: Array<
+                    | { text: string; type: "text" }
+                    | { data: string; mimeType?: string; type: "image" }
+                  >;
+                  experimental_providerMetadata?: Record<string, any>;
+                  isError?: boolean;
+                  providerOptions?: Record<string, any>;
+                  result: any;
+                  toolCallId: string;
+                  toolName: string;
+                  type: "tool-result";
+                }>;
+                experimental_providerMetadata?: Record<string, any>;
+                providerOptions?: Record<string, any>;
+                role: "tool";
+              }
+            | {
+                content: string;
+                experimental_providerMetadata?: Record<string, any>;
+                providerOptions?: Record<string, any>;
+                role: "system";
+              };
+          model?: string;
+          order: number;
+          parentMessageId?: string;
+          provider?: string;
+          providerMetadata?: Record<string, any>;
+          reasoning?: string;
+          sources?: Array<{
+            id: string;
+            providerMetadata?: Record<string, Record<string, any>>;
+            sourceType: "url";
+            title?: string;
+            url: string;
+          }>;
+          status: "pending" | "success" | "failed";
+          stepId?: string;
+          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" }
+          >;
         }>;
         pageStatus?: "SplitRecommended" | "SplitRequired" | null;
         splitCursor?: string | null;
@@ -1365,9 +1470,9 @@ export type Mounts = {
       "action",
       "public",
       {
+        beforeMessageId?: string;
         limit: number;
         messageRange?: { after: number; before: number };
-        parentMessageId?: string;
         text?: string;
         threadId?: string;
         userId?: string;
@@ -1687,12 +1792,87 @@ export type Mounts = {
         >;
       }>
     >;
+  };
+  threads: {
+    createThread: FunctionReference<
+      "mutation",
+      "public",
+      {
+        defaultSystemPrompt?: string;
+        parentThreadIds?: Array<string>;
+        summary?: string;
+        title?: string;
+        userId?: string;
+      },
+      {
+        _creationTime: number;
+        _id: string;
+        status: "active" | "archived";
+        summary?: string;
+        title?: string;
+        userId?: string;
+      }
+    >;
+    deleteAllForThreadIdAsync: FunctionReference<
+      "mutation",
+      "public",
+      { cursor?: string; limit?: number; threadId: string },
+      { cursor: string; isDone: boolean }
+    >;
+    deleteAllForThreadIdSync: FunctionReference<
+      "action",
+      "public",
+      { cursor?: string; limit?: number; threadId: string },
+      null
+    >;
+    getThread: FunctionReference<
+      "query",
+      "public",
+      { threadId: string },
+      {
+        _creationTime: number;
+        _id: string;
+        status: "active" | "archived";
+        summary?: string;
+        title?: string;
+        userId?: string;
+      } | null
+    >;
+    listThreadsByUserId: FunctionReference<
+      "query",
+      "public",
+      {
+        order?: "asc" | "desc";
+        paginationOpts?: {
+          cursor: string | null;
+          endCursor?: string | null;
+          id?: number;
+          maximumBytesRead?: number;
+          maximumRowsRead?: number;
+          numItems: number;
+        };
+        userId: string;
+      },
+      {
+        continueCursor: string;
+        isDone: boolean;
+        page: Array<{
+          _creationTime: number;
+          _id: string;
+          status: "active" | "archived";
+          summary?: string;
+          title?: string;
+          userId?: string;
+        }>;
+        pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+        splitCursor?: string | null;
+      }
+    >;
     updateThread: FunctionReference<
       "mutation",
       "public",
       {
         patch: {
-          defaultSystemPrompt?: string;
           status?: "active" | "archived";
           summary?: string;
           title?: string;
@@ -1702,9 +1882,6 @@ export type Mounts = {
       {
         _creationTime: number;
         _id: string;
-        defaultSystemPrompt?: string;
-        order?: number;
-        parentThreadIds?: Array<string>;
         status: "active" | "archived";
         summary?: string;
         title?: string;
@@ -1712,6 +1889,41 @@ export type Mounts = {
       }
     >;
   };
+  users: {
+    deleteAllForUserId: FunctionReference<
+      "action",
+      "public",
+      { userId: string },
+      null
+    >;
+    deleteAllForUserIdAsync: FunctionReference<
+      "mutation",
+      "public",
+      { userId: string },
+      boolean
+    >;
+    listUsersWithThreads: FunctionReference<
+      "query",
+      "public",
+      {
+        paginationOpts: {
+          cursor: string | null;
+          endCursor?: string | null;
+          id?: number;
+          maximumBytesRead?: number;
+          maximumRowsRead?: number;
+          numItems: number;
+        };
+      },
+      {
+        continueCursor: string;
+        isDone: boolean;
+        page: Array<string>;
+        pageStatus?: "SplitRecommended" | "SplitRequired" | null;
+        splitCursor?: string | null;
+      }
+    >;
+  };
   vector: {
     index: {
       deleteBatch: FunctionReference<

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(),
+  }),
+});