@convex-dev/agent 0.1.4 → 0.1.5-alpha.1

package/src/component/messages.ts

@@ -1,6 +1,7 @@
 import { assert, omit } from "convex-helpers";
 import { mergedStream, stream } from "convex-helpers/server/stream";
-import { ObjectType } from "convex/values";
+import { paginationOptsValidator } from "convex/server";
+import type { ObjectType } from "convex/values";
 import {
   DEFAULT_MESSAGE_RANGE,
   DEFAULT_RECENT_MESSAGES,
@@ -8,38 +9,37 @@ import {
   isTool,
 } from "../shared.js";
 import {
-  vPaginationResult,
   vMessageEmbeddings,
   vMessageStatus,
   vMessageWithMetadata,
+  vPaginationResult,
   vSearchOptions,
   vStepWithMessages,
 } from "../validators.js";
 import { api, internal } from "./_generated/api.js";
-import { Doc, Id } from "./_generated/dataModel.js";
+import type { Doc, Id } from "./_generated/dataModel.js";
 import {
   action,
   internalQuery,
   mutation,
-  MutationCtx,
+  type MutationCtx,
   query,
-  QueryCtx,
+  type QueryCtx,
 } from "./_generated/server.js";
-import { schema, v } from "./schema.js";
+import type { MessageDoc } from "./schema.js";
+import { schema, v, vMessageDoc } from "./schema.js";
+import {
+  getThread as _getThread,
+  listThreadsByUserId as _listThreadsByUserId,
+  updateThread as _updateThread,
+} from "./threads.js";
 import { insertVector, searchVectors } from "./vector/index.js";
 import {
-  VectorDimension,
+  type VectorDimension,
   VectorDimensions,
-  VectorTableId,
+  type VectorTableId,
   vVectorId,
 } from "./vector/tables.js";
-import {
-  listThreadsByUserId as _listThreadsByUserId,
-  getThread as _getThread,
-  updateThread as _updateThread,
-} from "./threads.js";
-import { paginationOptsValidator } from "convex/server";
-import { MessageDoc, vMessageDoc } from "./schema.js";
 
 /** @deprecated Use *.threads.listMessagesByThreadId instead. */
 export const listThreadsByUserId = _listThreadsByUserId;
@@ -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/schema.ts

@@ -1,5 +1,5 @@
 import { defineSchema, defineTable } from "convex/server";
-import { Infer, v } from "convex/values";
+import { type Infer, v } from "convex/values";
 import {
   vThreadStatus,
   vMessage,

package/src/component/streams.ts

@@ -1,15 +1,15 @@
+import { omit, pick } from "convex-helpers";
 import { v } from "convex/values";
+import { type StreamDelta, vStreamDelta, vStreamMessage } from "../validators";
+import { internal } from "./_generated/api";
+import type { Id } from "./_generated/dataModel";
 import {
   internalMutation,
   mutation,
-  MutationCtx,
+  type MutationCtx,
   query,
 } from "./_generated/server";
-import { omit, pick } from "convex-helpers";
-import { StreamDelta, vStreamDelta, vStreamMessage } from "../validators";
 import schema from "./schema";
-import { internal } from "./_generated/api";
-import { Id } from "./_generated/dataModel";
 
 const MAX_DELTAS_PER_REQUEST = 1000;
 const MAX_DELTAS_PER_STREAM = 100;

package/src/component/threads.ts

@@ -1,21 +1,21 @@
 import { assert, omit, pick } from "convex-helpers";
 import { paginator } from "convex-helpers/server/pagination";
 import { partial } from "convex-helpers/validators";
-import { ObjectType } from "convex/values";
+import { paginationOptsValidator } from "convex/server";
+import type { ObjectType } from "convex/values";
+import { type ThreadDoc, vThreadDoc } from "../client/index.js";
 import { vPaginationResult } from "../validators.js";
 import { api, internal } from "./_generated/api.js";
-import { Doc } from "./_generated/dataModel.js";
+import type { Doc } from "./_generated/dataModel.js";
 import {
   action,
   internalMutation,
   mutation,
-  MutationCtx,
+  type MutationCtx,
   query,
 } from "./_generated/server.js";
-import { schema, v } from "./schema.js";
-import { paginationOptsValidator } from "convex/server";
 import { deleteMessage } from "./messages.js";
-import { ThreadDoc, vThreadDoc } from "../client/index.js";
+import { schema, v } from "./schema.js";
 
 function publicThreadOrNull(thread: Doc<"threads"> | null): ThreadDoc | null {
   if (thread === null) {

package/src/component/users.ts

@@ -1,21 +1,21 @@
 import { paginator } from "convex-helpers/server/pagination";
+import { stream } from "convex-helpers/server/stream";
 import { nullable } from "convex-helpers/validators";
-import { ObjectType } from "convex/values";
+import { paginationOptsValidator } from "convex/server";
+import type { ObjectType } from "convex/values";
+import { vPaginationResult } from "../validators.js";
 import { internal } from "./_generated/api.js";
+import type { Id } from "./_generated/dataModel.js";
 import {
   action,
   internalMutation,
   internalQuery,
   mutation,
-  MutationCtx,
+  type MutationCtx,
   query,
 } from "./_generated/server.js";
-import { schema, v } from "./schema.js";
 import { deleteMessage } from "./messages.js";
-import { paginationOptsValidator } from "convex/server";
-import { stream } from "convex-helpers/server/stream";
-import { vPaginationResult } from "../validators.js";
-import { Id } from "./_generated/dataModel.js";
+import { schema, v } from "./schema.js";
 
 // Note: it only searches for users with threads
 export const listUsersWithThreads = query({

package/src/component/vector/index.ts

@@ -1,18 +1,22 @@
 import { paginator } from "convex-helpers/server/pagination";
+import { mergedStream, stream } from "convex-helpers/server/stream";
 import { v } from "convex/values";
-import { ActionCtx, mutation, MutationCtx, query } from "../_generated/server";
+import type { Id } from "../_generated/dataModel.js";
 import {
-  EmbeddingsWithoutDenormalizedFields,
+  type ActionCtx,
+  mutation,
+  type MutationCtx,
+  query,
+} from "../_generated/server.js";
+import schema from "../schema.js";
+import {
+  type EmbeddingsWithoutDenormalizedFields,
   getVectorTableName,
-  VectorDimension,
+  type VectorDimension,
   vEmbeddingsWithoutDenormalizedFields,
   vVectorDimension,
   vVectorId,
-} from "./tables";
-import schema from "../schema";
-import { mergedStream } from "convex-helpers/server/stream";
-import { stream } from "convex-helpers/server/stream";
-import { Id } from "../_generated/dataModel";
+} from "./tables.js";
 
 export const paginate = query({
   args: {
@@ -93,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/component/vector/tables.ts

@@ -2,20 +2,20 @@ import { omit } from "convex-helpers";
 import { literals } from "convex-helpers/validators";
 import {
   defineTable,
-  GenericTableSearchIndexes,
-  SchemaDefinition,
-  TableDefinition,
+  type GenericTableSearchIndexes,
+  type SchemaDefinition,
+  type TableDefinition,
 } from "convex/server";
 import {
-  GenericId,
-  Infer,
-  ObjectType,
+  type GenericId,
+  type Infer,
+  type ObjectType,
   v,
-  VId,
-  VObject,
-  VUnion,
+  type VId,
+  type VObject,
+  type VUnion,
 } from "convex/values";
-import { QueryCtx } from "../_generated/server";
+import type { QueryCtx } from "../_generated/server";
 
 // We only generate embeddings for non-tool, non-system messages
 const embeddings = {

package/src/mapping.ts

@@ -1,19 +1,19 @@
+import type { FileUIPart } from "@ai-sdk/ui-utils";
 import {
   convertToCoreMessages,
   coreMessageSchema,
-  GenerateObjectResult,
+  type Message as AIMessage,
   type AssistantContent,
   type CoreMessage,
   type DataContent,
+  type GenerateObjectResult,
   type StepResult,
   type ToolContent,
   type ToolSet,
-  type Message as AIMessage,
   type UserContent,
 } from "ai";
-import type { FileUIPart } from "@ai-sdk/ui-utils";
 import { assert } from "convex-helpers";
-import {
+import type {
   MessageWithMetadata,
   Step,
   StepWithMessagesWithMetadata,

package/src/react/toUIMessages.ts

@@ -1,8 +1,8 @@
-import { UIMessage as AIUIMessage } from "ai";
 import type { ToolInvocationUIPart } from "@ai-sdk/ui-utils";
-import { MessageDoc } from "../client";
+import type { UIMessage as AIUIMessage } from "ai";
+import type { MessageDoc } from "../client";
 import { deserializeMessage, toUIFilePart } from "../mapping";
-import { MessageStatus } from "../validators";
+import type { MessageStatus } from "../validators";
 
 export type UIMessage = AIUIMessage & {
   key: string;

package/src/shared.ts

@@ -1,5 +1,5 @@
-import { CoreMessage } from "ai";
-import { Message } from "./validators";
+import type { CoreMessage } from "ai";
+import type { Message } from "./validators";
 
 export const DEFAULT_RECENT_MESSAGES = 100;
 

package/src/validators.test.ts

@@ -1,5 +1,24 @@
-import { Infer } from "convex/values";
+import type {
+  TextStreamPart as AITextStreamPart,
+  AssistantContent,
+  CoreAssistantMessage,
+  CoreMessage,
+  CoreSystemMessage,
+  CoreToolMessage,
+  CoreUserMessage,
+  FilePart,
+  ImagePart,
+  TextPart,
+  ToolCallPart,
+  ToolContent,
+  ToolSet,
+  UserContent,
+} from "ai";
+import type { Infer } from "convex/values";
 import { expectTypeOf, test } from "vitest";
+import type { ContextOptions, StorageOptions } from "./client";
+import type { SerializeUrlsAndUint8Arrays } from "./mapping";
+import type { TextStreamPart } from "./validators";
 import {
   vAssistantContent,
   vAssistantMessage,
@@ -15,28 +34,9 @@ import {
   vToolCallPart,
   vToolContent,
   vToolMessage,
+  vUserContent,
   vUserMessage,
 } from "./validators";
-import { vUserContent } from "./validators";
-import type { TextStreamPart } from "./validators";
-import {
-  AssistantContent,
-  CoreAssistantMessage,
-  CoreMessage,
-  CoreSystemMessage,
-  CoreToolMessage,
-  CoreUserMessage,
-  FilePart,
-  ImagePart,
-  TextPart,
-  TextStreamPart as AITextStreamPart,
-  ToolCallPart,
-  ToolContent,
-  ToolSet,
-  UserContent,
-} from "ai";
-import { SerializeUrlsAndUint8Arrays } from "./mapping";
-import { ContextOptions, StorageOptions } from "./client";
 
 // type assertion
 type OurUserContent = SerializeUrlsAndUint8Arrays<UserContent>;
@@ -125,4 +125,4 @@ type StreamPart = Extract<
 >;
 expectTypeOf<StreamPart>().toExtend<TextStreamPart>();
 
-test("noop", () => { });
+test("noop", () => {});

package/src/validators.ts

@@ -1,5 +1,11 @@
-import { Infer, ObjectType, v, Validator, Value } from "convex/values";
-import { vVectorDimension } from "./component/vector/tables";
+import {
+  v,
+  type Infer,
+  type ObjectType,
+  type Validator,
+  type Value,
+} from "convex/values";
+import { vVectorDimension } from "./component/vector/tables.js";
 
 // const deprecated = v.optional(v.any()) as unknown as VNull<unknown, "optional">;