@convex-dev/agent 0.2.6-alpha.0 → 0.2.6

package/src/component/messages.ts

@@ -13,10 +13,12 @@ import {
   sorted,
 } from "../shared.js";
 import {
+  vMessageDoc,
   vMessageEmbeddingsWithDimension,
   vMessageStatus,
   vMessageWithMetadataInternal,
   vPaginationResult,
+  type MessageDoc,
 } from "../validators.js";
 import { api, internal } from "./_generated/api.js";
 import type { Doc, Id } from "./_generated/dataModel.js";
@@ -28,12 +30,10 @@ import {
   query,
   type QueryCtx,
 } from "./_generated/server.js";
-import type { MessageDoc } from "./schema.js";
-import { schema, v, vMessageDoc } from "./schema.js";
+import { schema, v } from "./schema.js";
 import { insertVector, searchVectors } from "./vector/index.js";
 import {
-  type VectorDimension,
-  VectorDimensions,
+  validateVectorDimension,
   type VectorTableId,
   vVectorId,
 } from "./vector/tables.js";
@@ -504,10 +504,12 @@ export const searchMessages = action({
   args: {
     threadId: v.optional(v.id("threads")),
     searchAllMessagesForUserId: v.optional(v.string()),
-    beforeMessageId: v.optional(v.id("messages")),
+    targetMessageId: v.optional(v.id("messages")),
     embedding: v.optional(v.array(v.number())),
     embeddingModel: v.optional(v.string()),
     text: v.optional(v.string()),
+    textSearch: v.optional(v.boolean()),
+    vectorSearch: v.optional(v.boolean()),
     limit: v.number(),
     vectorScoreThreshold: v.optional(v.number()),
     messageRange: v.optional(
@@ -522,24 +524,38 @@ export const searchMessages = action({
     );
     const limit = args.limit;
     let textSearchMessages: MessageDoc[] | undefined;
-    if (args.text) {
+    if (args.textSearch) {
       textSearchMessages = await ctx.runQuery(api.messages.textSearch, {
         searchAllMessagesForUserId: args.searchAllMessagesForUserId,
         threadId: args.threadId,
+        targetMessageId: args.targetMessageId,
         text: args.text,
         limit,
-        beforeMessageId: args.beforeMessageId,
       });
     }
-    if (args.embedding) {
-      const dimension = args.embedding.length as VectorDimension;
-      if (!VectorDimensions.includes(dimension)) {
-        throw new Error(`Unsupported embedding dimension: ${dimension}`);
+    if (args.vectorSearch) {
+      let embedding = args.embedding;
+      let model = args.embeddingModel;
+      if (!embedding) {
+        if (args.targetMessageId) {
+          const target = await ctx.runQuery(
+            api.messages.getMessageSearchFields,
+            {
+              messageId: args.targetMessageId,
+            },
+          );
+          assert(target, "Target message embedding not found.");
+          embedding = target.embedding;
+          model = target.embeddingModel;
+        }
       }
+      assert(embedding && model, "Embedding missing");
+      const dimension = embedding.length;
+      validateVectorDimension(dimension);
       const vectors = (
-        await searchVectors(ctx, args.embedding, {
+        await searchVectors(ctx, embedding, {
           dimension,
-          model: args.embeddingModel ?? "unknown",
+          model,
           table: "messages",
           searchAllMessagesForUserId: args.searchAllMessagesForUserId,
           threadId: args.threadId,
@@ -568,7 +584,7 @@ export const searchMessages = action({
             (m) => !embeddingIds.includes(m.embeddingId! as VectorTableId),
           ),
           messageRange: args.messageRange ?? DEFAULT_MESSAGE_RANGE,
-          beforeMessageId: args.beforeMessageId,
+          beforeMessageId: args.targetMessageId,
           limit,
         },
       );
@@ -699,26 +715,29 @@ export const textSearch = query({
   args: {
     threadId: v.optional(v.id("threads")),
     searchAllMessagesForUserId: v.optional(v.string()),
-    text: v.string(),
+    text: v.optional(v.string()),
+    targetMessageId: v.optional(v.id("messages")),
     limit: v.number(),
-    beforeMessageId: v.optional(v.id("messages")),
   },
   handler: async (ctx, args) => {
     assert(
       args.searchAllMessagesForUserId || args.threadId,
       "Specify userId or threadId",
     );
-    const beforeMessage =
-      args.beforeMessageId && (await ctx.db.get(args.beforeMessageId));
-    const order = beforeMessage?.order;
+    const targetMessage =
+      args.targetMessageId && (await ctx.db.get(args.targetMessageId));
+    const order = targetMessage?.order;
+    const text = args.text || targetMessage?.text;
+    if (!text) {
+      console.warn("No text to search", targetMessage, args.text);
+      return [];
+    }
     const messages = await ctx.db
       .query("messages")
       .withSearchIndex("text_search", (q) =>
         args.searchAllMessagesForUserId
-          ? q
-              .search("text", args.text)
-              .eq("userId", args.searchAllMessagesForUserId)
-          : q.search("text", args.text).eq("threadId", args.threadId!),
+          ? q.search("text", text).eq("userId", args.searchAllMessagesForUserId)
+          : q.search("text", text).eq("threadId", args.threadId!),
       )
       // Just in case tool messages slip through
       .filter((q) => {
@@ -732,12 +751,39 @@ export const textSearch = query({
     return messages
       .filter(
         (m) =>
-          !beforeMessage ||
-          m.order < beforeMessage.order ||
-          (m.order === beforeMessage.order &&
-            m.stepOrder < beforeMessage.stepOrder),
+          !targetMessage ||
+          m.order < targetMessage.order ||
+          (m.order === targetMessage.order &&
+            m.stepOrder < targetMessage.stepOrder),
       )
       .map(publicMessage);
   },
   returns: v.array(vMessageDoc),
 });
+
+export const getMessageSearchFields = query({
+  args: {
+    messageId: v.id("messages"),
+  },
+  returns: v.object({
+    text: v.optional(v.string()),
+    embedding: v.optional(v.array(v.number())),
+    embeddingModel: v.optional(v.string()),
+  }),
+  handler: async (ctx, args) => {
+    const message = await ctx.db.get(args.messageId);
+    const text = message?.text;
+    let embedding = undefined;
+    let embeddingModel = undefined;
+    if (message?.embeddingId) {
+      const target = await ctx.db.get(message.embeddingId);
+      embedding = target?.vector;
+      embeddingModel = target?.model;
+    }
+    return {
+      text,
+      embedding,
+      embeddingModel,
+    };
+  },
+});

package/src/component/schema.ts

@@ -1,5 +1,5 @@
 import { defineSchema, defineTable } from "convex/server";
-import { type Infer, v } from "convex/values";
+import { v } from "convex/values";
 import {
   vThreadStatus,
   vMessage,
@@ -14,7 +14,6 @@ import {
 } from "../validators.js";
 import { typedV } from "convex-helpers/validators";
 import vectorTables, { vVectorId } from "./vector/tables.js";
-import { omit } from "convex-helpers";
 
 export const schema = defineSchema({
   threads: defineTable({
@@ -164,31 +163,4 @@ export const schema = defineSchema({
 export const vv = typedV(schema);
 export { vv as v };
 
-// Public
-export const vThreadDoc = v.object({
-  _id: v.string(),
-  _creationTime: v.number(),
-  userId: v.optional(v.string()), // Unset for anonymous
-  title: v.optional(v.string()),
-  summary: v.optional(v.string()),
-  status: vThreadStatus,
-});
-export type ThreadDoc = Infer<typeof vThreadDoc>;
-
-export const vMessageDoc = v.object({
-  _id: v.string(),
-  _creationTime: v.number(),
-  ...omit(schema.tables.messages.validator.fields, [
-    "parentMessageId",
-    "stepId",
-    "files",
-  ]),
-  // Overwrite all the types that have a v.id validator
-  // Outside of the component, they are strings
-  threadId: v.string(),
-  embeddingId: v.optional(v.string()),
-  fileIds: v.optional(v.array(v.string())),
-});
-export type MessageDoc = Infer<typeof vMessageDoc>;
-
 export default schema;

package/src/mapping.ts

@@ -46,6 +46,11 @@ import {
   type ReasoningPart,
 } from "@ai-sdk/provider-utils";
 import { parse, validate } from "convex-helpers/validators";
+import {
+  getModelName,
+  getProviderName,
+  type ModelOrMetadata,
+} from "./shared.js";
 export type AIMessageWithoutId = Omit<AIMessage, "id">;
 
 export type SerializeUrlsAndUint8Arrays<T> = T extends URL
@@ -86,6 +91,21 @@ export async function serializeMessage(
   };
 }
 
+// Similar to serializeMessage, but doesn't save any files and is looser
+// For use on the frontend / in synchronous environments.
+export function fromModelMessage(
+  message: ModelMessage,
+): Message {
+  const content = fromModelMessageContent(message.content);
+  return {
+    role: message.role,
+    content,
+    ...(message.providerOptions
+      ? { providerOptions: message.providerOptions }
+      : {}),
+  } as SerializedMessage;
+}
+
 export async function serializeOrThrow(
   message: ModelMessage | Message,
 ): Promise<SerializedMessage> {
@@ -159,13 +179,13 @@ export async function serializeNewMessagesInStep<TOOLS extends ToolSet>(
   ctx: ActionCtx,
   component: AgentComponent,
   step: StepResult<TOOLS>,
-  metadata: { model: string; provider: string },
+  model: ModelOrMetadata | undefined,
 ): Promise<{ messages: MessageWithMetadata[] }> {
   // If there are tool results, there's another message with the tool results
   // ref: https://github.com/vercel/ai/blob/main/packages/ai/core/generate-text/to-response-messages.ts
   const assistantFields = {
-    model: metadata.model,
-    provider: metadata.provider,
+    model: model ? getModelName(model) : undefined,
+    provider: model ? getProviderName(model) : undefined,
     providerMetadata: step.providerMetadata,
     reasoning: step.reasoningText,
     reasoningDetails: step.reasoning,
@@ -198,7 +218,7 @@ export async function serializeObjectResult(
   ctx: ActionCtx,
   component: AgentComponent,
   result: GenerateObjectResult<unknown>,
-  metadata: { model: string; provider: string },
+  model: ModelOrMetadata | undefined,
 ): Promise<{ messages: MessageWithMetadata[] }> {
   const text = JSON.stringify(result.object);
 
@@ -210,8 +230,8 @@ export async function serializeObjectResult(
     messages: [
       {
         message,
-        model: metadata.model,
-        provider: metadata.provider,
+        model: model ? getModelName(model) : undefined,
+        provider: model ? getProviderName(model) : undefined,
         providerMetadata: result.providerMetadata,
         finishReason: result.finishReason,
         text,
@@ -347,6 +367,63 @@ export async function serializeContent(
   };
 }
 
+export function fromModelMessageContent(content: Content): Message["content"] {
+  if (typeof content === "string") {
+    return content;
+  }
+  const metadata: {
+    providerOptions?: ProviderOptions;
+    providerMetadata?: ProviderMetadata;
+  } = {};
+  if ("providerOptions" in content) {
+    metadata.providerOptions = content.providerOptions as ProviderOptions;
+  }
+  if ("providerMetadata" in content) {
+    metadata.providerMetadata = content.providerMetadata as ProviderMetadata;
+  }
+  return content.map((part) => {
+    switch (part.type) {
+      case "text":
+        return part satisfies Infer<typeof vTextPart>;
+      case "image":
+        return {
+          type: part.type,
+          mimeType: getMimeOrMediaType(part),
+          ...metadata,
+          image: serializeDataOrUrl(part.image),
+        } satisfies Infer<typeof vImagePart>;
+      case "file":
+        return {
+          type: part.type,
+          data: serializeDataOrUrl(part.data),
+          filename: part.filename,
+          mimeType: getMimeOrMediaType(part)!,
+          ...metadata,
+        } satisfies Infer<typeof vFilePart>;
+      case "tool-call":
+        return {
+          type: part.type,
+          args: part.input ?? null,
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          providerExecuted: part.providerExecuted,
+          ...metadata,
+        } satisfies Infer<typeof vToolCallPart>;
+      case "tool-result":
+        return normalizeToolResult(part, metadata);
+      case "reasoning":
+        return {
+          type: part.type,
+          text: part.text,
+          ...metadata,
+        } satisfies Infer<typeof vReasoningPart>;
+      // Not in current generation output, but could be in historical messages
+      default:
+        return part satisfies Infer<typeof vContent>;
+    }
+  }) as Message["content"];
+}
+
 export function deserializeContent(
   content: SerializedContent | ModelMessage["content"],
 ): Content {
@@ -433,7 +510,7 @@ export function deserializeContent(
   }) as Content;
 }
 
-function normalizeToolOutput(
+export function normalizeToolOutput(
   result: string | JSONValue | undefined,
 ): ToolResultPart["output"] {
   if (typeof result === "string") {

package/src/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"3.2.4","results":[[":client/index.test.ts",{"duration":129.9694999999997,"failed":false}],[":component/messages.test.ts",{"duration":191.73391600000014,"failed":false}],[":component/users.test.ts",{"duration":545.7272500000001,"failed":false}],[":mapping.test.ts",{"duration":9.238791999999876,"failed":false}],[":react/deltas.test.ts",{"duration":5.8497500000000855,"failed":false}],[":react/toUIMessages.test.ts",{"duration":6.495208000000048,"failed":false}],[":validators.test.ts",{"duration":1.0037499999999682,"failed":false}],[":deltas.test.ts",{"duration":0,"failed":false}]]}

package/src/react/deltas.ts

@@ -1,4 +1,5 @@
 import type {
+  JSONValue,
   ProviderMetadata,
   TextStreamPart,
   ToolSet,
@@ -18,7 +19,7 @@ import {
   type vToolResultPart,
 } from "../validators.js";
 import type { Infer } from "convex/values";
-import { serializeWarnings } from "../mapping.js";
+import { normalizeToolOutput, serializeWarnings } from "../mapping.js";
 import { parse } from "convex-helpers/validators";
 import { sorted } from "../shared.js";
 
@@ -267,7 +268,9 @@ export function applyDeltasToStreamMessage(
           lastContent?.type === "tool-result" &&
           lastContent.toolCallId === part.toolCallId
         ) {
-          lastContent.result = part.output;
+          lastContent.output = normalizeToolOutput(
+            part.output as string | JSONValue | undefined,
+          );
           lastContent.providerExecuted = part.providerExecuted;
         } else {
           console.warn(
@@ -376,7 +379,10 @@ export function applyDeltasToStreamMessage(
           lastContent.toolCallId === part.toolCallId
         ) {
           lastContent.isError = true;
-          lastContent.result = part.errorText;
+          lastContent.output = {
+            type: "error-text",
+            value: part.errorText,
+          };
           lastContent.providerExecuted = part.providerExecuted;
         } else if (
           lastContent?.type === "tool-call" &&
@@ -391,7 +397,10 @@ export function applyDeltasToStreamMessage(
             toolCallId: part.toolCallId,
             toolName: lastContent.toolName,
             args: lastContent.args,
-            result: part.errorText,
+            output: {
+              type: "error-text",
+              value: part.errorText,
+            },
             providerExecuted: part.providerExecuted,
             isError: true,
           } satisfies Infer<typeof vToolResultPart>;
@@ -408,7 +417,10 @@ export function applyDeltasToStreamMessage(
           lastContent.toolCallId === part.toolCallId
         ) {
           lastContent.isError = true;
-          lastContent.result = part.error;
+          lastContent.output = {
+            type: "error-json",
+            value: part.error,
+          };
           lastContent.providerExecuted = part.providerExecuted;
         } else {
           if (
@@ -571,6 +583,7 @@ export function createStreamingMessage(
     _id: `${streamId}-${index}`,
     _creationTime: Date.now(),
     status: statusFromStreamStatus(message.status),
+    stepOrder: message.stepOrder + index,
     threadId,
     tool: false,
   };