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

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

@@ -1045,6 +1045,151 @@ export type Mounts = {
       { messageId: string },
       null
     >;
+    getMessagesByIds: FunctionReference<
+      "query",
+      "public",
+      { messageIds: Array<string> },
+      Array<null | {
+        _creationTime: number;
+        _id: string;
+        agentName?: string;
+        embeddingId?: string;
+        error?: string;
+        files?: Array<{
+          data?: ArrayBuffer | string;
+          fileId?: string;
+          mimeType: string;
+          url?: 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;
+                        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;
+                        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" }
+        >;
+      }>
+    >;
     getThreadMessages: FunctionReference<
       "query",
       "public",
@@ -2068,6 +2213,7 @@ export type Mounts = {
             | 3072
             | 4096;
           vectors: Array<{
+            messageId?: string;
             model: string;
             table: string;
             threadId?: string;
@@ -2075,7 +2221,18 @@ export type Mounts = {
             vector: Array<number>;
           }>;
         },
-        null
+        Array<
+          | string
+          | string
+          | string
+          | string
+          | string
+          | string
+          | string
+          | string
+          | string
+          | string
+        >
       >;
       paginate: FunctionReference<
         "query",

package/src/component/messages.ts

@@ -443,6 +443,16 @@ export const listMessagesByThreadId = query({
   returns: vPaginationResult(vMessageDoc),
 });
 
+export const getMessagesByIds = query({
+  args: {
+    messageIds: v.array(v.id("messages")),
+  },
+  handler: async (ctx, args) => {
+    return await Promise.all(args.messageIds.map((id) => ctx.db.get(id)));
+  },
+  returns: v.array(v.union(v.null(), vMessageDoc)),
+});
+
 /** @deprecated Use listMessagesByThreadId instead. */
 export const getThreadMessages = query({
   args: { deprecated: v.literal("Use listMessagesByThreadId instead") },

package/src/component/vector/index.ts

@@ -97,12 +97,23 @@ export const deleteBatchForThread = mutation({
 export const insertBatch = mutation({
   args: {
     vectorDimension: vVectorDimension,
-    vectors: v.array(vEmbeddingsWithoutDenormalizedFields),
+    vectors: v.array(
+      v.object({
+        ...vEmbeddingsWithoutDenormalizedFields.fields,
+        messageId: v.optional(v.id("messages")),
+      })
+    ),
   },
-  returns: v.null(),
+  returns: v.array(vVectorId),
   handler: async (ctx, args) => {
-    await Promise.all(
-      args.vectors.map((v) => insertVector(ctx, args.vectorDimension, v))
+    return Promise.all(
+      args.vectors.map(async ({ messageId, ...v }) => {
+        const embeddingId = await insertVector(ctx, args.vectorDimension, v);
+        if (messageId) {
+          await ctx.db.patch(messageId, { embeddingId });
+        }
+        return embeddingId;
+      })
     );
   },
 });

package/src/mapping.ts

@@ -181,7 +181,7 @@ export function serializeContent(content: Content): SerializedContent {
         case "image":
           return { ...part, image: serializeDataOrUrl(part.image) };
         case "file":
-          return { ...part, file: serializeDataOrUrl(part.data) };
+          return { ...part, data: serializeDataOrUrl(part.data) };
         default:
           return part;
       }
@@ -199,7 +199,7 @@ export function deserializeContent(content: SerializedContent): Content {
       case "image":
         return { ...part, image: deserializeUrl(part.image) };
       case "file":
-        return { ...part, file: deserializeUrl(part.data) };
+        return { ...part, data: deserializeUrl(part.data) };
       default:
         return part;
     }