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

package/dist/commonjs/component/files.js

@@ -1,22 +1,27 @@
-import { paginator } from "convex-helpers/server/pagination";
-import { mutation, query } from "./_generated/server.js";
-import { schema, v } from "./schema.js";
-import { paginationOptsValidator } from "convex/server";
-const addFileArgs = v.object({
-    storageId: v.string(),
-    hash: v.string(),
-    filename: v.optional(v.string()),
-    mimeType: v.string(),
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteFiles = exports.getFilesToDelete = exports.copyFile = exports.useExistingFile = exports.get = exports.addFile = void 0;
+exports.addFileHandler = addFileHandler;
+exports.copyFileHandler = copyFileHandler;
+const pagination_1 = require("convex-helpers/server/pagination");
+const server_js_1 = require("./_generated/server.js");
+const schema_js_1 = require("./schema.js");
+const server_1 = require("convex/server");
+const addFileArgs = schema_js_1.v.object({
+    storageId: schema_js_1.v.string(),
+    hash: schema_js_1.v.string(),
+    filename: schema_js_1.v.optional(schema_js_1.v.string()),
+    mimeType: schema_js_1.v.string(),
 });
-export const addFile = mutation({
+exports.addFile = (0, server_js_1.mutation)({
     args: addFileArgs,
     handler: addFileHandler,
     returns: {
-        fileId: v.id("files"),
-        storageId: v.string(),
+        fileId: schema_js_1.v.id("files"),
+        storageId: schema_js_1.v.string(),
     },
 });
-export async function addFileHandler(ctx, args) {
+async function addFileHandler(ctx, args) {
     const existingFile = await ctx.db
         .query("files")
         .withIndex("hash", (q) => q.eq("hash", args.hash))
@@ -44,11 +49,11 @@ export async function addFileHandler(ctx, args) {
         storageId: args.storageId,
     };
 }
-export const get = query({
+exports.get = (0, server_js_1.query)({
     args: {
-        fileId: v.id("files"),
+        fileId: schema_js_1.v.id("files"),
     },
-    returns: v.union(v.null(), v.doc("files")),
+    returns: schema_js_1.v.union(schema_js_1.v.null(), schema_js_1.v.doc("files")),
     handler: async (ctx, args) => {
         return ctx.db.get(args.fileId);
     },
@@ -59,10 +64,10 @@ export const get = query({
  * Note: this will not increment the refcount. only saving messages does that.
  * It will only match if the filename is the same (or both are undefined).
  */
-export const useExistingFile = mutation({
+exports.useExistingFile = (0, server_js_1.mutation)({
     args: {
-        hash: v.string(),
-        filename: v.optional(v.string()),
+        hash: schema_js_1.v.string(),
+        filename: schema_js_1.v.optional(schema_js_1.v.string()),
     },
     handler: async (ctx, args) => {
         const file = await ctx.db
@@ -78,19 +83,19 @@ export const useExistingFile = mutation({
         });
         return { fileId: file._id, storageId: file.storageId };
     },
-    returns: v.union(v.null(), v.object({
-        fileId: v.id("files"),
-        storageId: v.string(),
+    returns: schema_js_1.v.union(schema_js_1.v.null(), schema_js_1.v.object({
+        fileId: schema_js_1.v.id("files"),
+        storageId: schema_js_1.v.string(),
     })),
 });
-export const copyFile = mutation({
+exports.copyFile = (0, server_js_1.mutation)({
     args: {
-        fileId: v.id("files"),
+        fileId: schema_js_1.v.id("files"),
     },
     handler: copyFileHandler,
-    returns: v.null(),
+    returns: schema_js_1.v.null(),
 });
-export async function copyFileHandler(ctx, args) {
+async function copyFileHandler(ctx, args) {
     const file = await ctx.db.get(args.fileId);
     if (!file) {
         throw new Error("File not found");
@@ -107,44 +112,46 @@ export async function copyFileHandler(ctx, args) {
  * You can inspect the `lastTouchedAt` field to see how recently it was used.
  * I'd recommend not deleting anything touched in the last 24 hours.
  */
-export const getFilesToDelete = query({
+exports.getFilesToDelete = (0, server_js_1.query)({
     args: {
-        paginationOpts: paginationOptsValidator,
+        paginationOpts: server_1.paginationOptsValidator,
     },
     handler: async (ctx, args) => {
-        const files = await paginator(ctx.db, schema)
+        const files = await (0, pagination_1.paginator)(ctx.db, schema_js_1.schema)
             .query("files")
             .withIndex("refcount", (q) => q.eq("refcount", 0))
             .paginate(args.paginationOpts);
         return files;
     },
-    returns: v.object({
-        page: v.array(v.doc("files")),
-        continueCursor: v.string(),
-        isDone: v.boolean(),
+    returns: schema_js_1.v.object({
+        page: schema_js_1.v.array(schema_js_1.v.doc("files")),
+        continueCursor: schema_js_1.v.string(),
+        isDone: schema_js_1.v.boolean(),
     }),
 });
-export const deleteFiles = mutation({
+exports.deleteFiles = (0, server_js_1.mutation)({
     args: {
-        fileIds: v.array(v.id("files")),
-        force: v.optional(v.boolean()),
+        fileIds: schema_js_1.v.array(schema_js_1.v.id("files")),
+        force: schema_js_1.v.optional(schema_js_1.v.boolean()),
     },
+    returns: schema_js_1.v.array(schema_js_1.v.id("files")),
     handler: async (ctx, args) => {
-        await Promise.all(args.fileIds.map(async (fileId) => {
+        const deletedFileIds = await Promise.all(args.fileIds.map(async (fileId) => {
             const file = await ctx.db.get(fileId);
             if (!file) {
                 console.error(`File ${fileId} not found when deleting, skipping...`);
-                return;
+                return null;
             }
             if (file.refcount && file.refcount > 0) {
                 if (!args.force) {
                     console.error(`File ${fileId} has refcount ${file.refcount} > 0, skipping...`);
-                    return;
+                    return null;
                 }
             }
             await ctx.db.delete(fileId);
+            return fileId;
         }));
+        return deletedFileIds.filter((fileId) => fileId !== null);
     },
-    returns: v.null(),
 });
 //# sourceMappingURL=files.js.map

package/dist/commonjs/component/files.js.map

@@ -1 +1 @@
-{"version":3,"file":"files.js","sourceRoot":"","sources":["../../../src/component/files.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"files.js","sourceRoot":"","sources":["../../../src/component/files.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/component/messages.d.ts

@@ -441,7 +441,7 @@ export declare function getMaxMessage(ctx: QueryCtx, threadId: Id<"threads">, or
     threadId: import("convex/values").GenericId<"threads">;
     stepOrder: number;
     tool: boolean;
-} | null>;
+}>;
 export declare const rollbackMessage: import("convex/server").RegisteredMutation<"public", {
     error?: string | undefined;
     messageId: import("convex/values").GenericId<"messages">;

package/dist/commonjs/component/messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/component/messages.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/component/messages.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/component/messages.js

@@ -1,24 +1,29 @@
-import { assert, omit } from "convex-helpers";
-import { mergedStream, stream } from "convex-helpers/server/stream";
-import { paginationOptsValidator } from "convex/server";
-import { DEFAULT_MESSAGE_RANGE, DEFAULT_RECENT_MESSAGES, extractText, isTool, } from "../shared.js";
-import { vMessageEmbeddings, vMessageStatus, vMessageWithMetadataInternal, vPaginationResult, vSearchOptions, } from "../validators.js";
-import { api, internal } from "./_generated/api.js";
-import { action, internalQuery, mutation, query, } from "./_generated/server.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 { VectorDimensions, vVectorId, } from "./vector/tables.js";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textSearch = exports._fetchSearchMessages = exports.searchMessages = exports.getThreadMessages = exports.getMessagesByIds = exports.listMessagesByThreadId = exports.updateMessage = exports.commitMessage = exports.rollbackMessage = exports.addMessages = exports.messageStatuses = exports.updateThread = exports.getThread = exports.listThreadsByUserId = void 0;
+exports.deleteMessage = deleteMessage;
+exports.getMaxMessage = getMaxMessage;
+const convex_helpers_1 = require("convex-helpers");
+const stream_1 = require("convex-helpers/server/stream");
+const server_1 = require("convex/server");
+const shared_js_1 = require("../shared.js");
+const validators_js_1 = require("../validators.js");
+const api_js_1 = require("./_generated/api.js");
+const server_js_1 = require("./_generated/server.js");
+const schema_js_1 = require("./schema.js");
+const threads_js_1 = require("./threads.js");
+const index_js_1 = require("./vector/index.js");
+const tables_js_1 = require("./vector/tables.js");
 /** @deprecated Use *.threads.listMessagesByThreadId instead. */
-export const listThreadsByUserId = _listThreadsByUserId;
+exports.listThreadsByUserId = threads_js_1.listThreadsByUserId;
 /** @deprecated Use *.threads.getThread */
-export const getThread = _getThread;
+exports.getThread = threads_js_1.getThread;
 /** @deprecated Use *.threads.updateThread instead */
-export const updateThread = _updateThread;
+exports.updateThread = threads_js_1.updateThread;
 function publicMessage(message) {
-    return omit(message, ["parentMessageId", "stepId", "files"]);
+    return (0, convex_helpers_1.omit)(message, ["parentMessageId", "stepId", "files"]);
 }
-export async function deleteMessage(ctx, messageDoc) {
+async function deleteMessage(ctx, messageDoc) {
     await ctx.db.delete(messageDoc._id);
     if (messageDoc.embeddingId) {
         await ctx.db.delete(messageDoc.embeddingId);
@@ -32,22 +37,22 @@ export async function deleteMessage(ctx, messageDoc) {
         }
     }
 }
-export const messageStatuses = vMessageDoc.fields.status.members.map((m) => m.value);
+exports.messageStatuses = schema_js_1.vMessageDoc.fields.status.members.map((m) => m.value);
 const addMessagesArgs = {
-    userId: v.optional(v.string()),
-    threadId: v.id("threads"),
-    promptMessageId: v.optional(v.id("messages")),
-    agentName: v.optional(v.string()),
-    messages: v.array(vMessageWithMetadataInternal),
-    embeddings: v.optional(vMessageEmbeddings),
-    pending: v.optional(v.boolean()),
-    failPendingSteps: v.optional(v.boolean()),
+    userId: schema_js_1.v.optional(schema_js_1.v.string()),
+    threadId: schema_js_1.v.id("threads"),
+    promptMessageId: schema_js_1.v.optional(schema_js_1.v.id("messages")),
+    agentName: schema_js_1.v.optional(schema_js_1.v.string()),
+    messages: schema_js_1.v.array(validators_js_1.vMessageWithMetadataInternal),
+    embeddings: schema_js_1.v.optional(validators_js_1.vMessageEmbeddings),
+    pending: schema_js_1.v.optional(schema_js_1.v.boolean()),
+    failPendingSteps: schema_js_1.v.optional(schema_js_1.v.boolean()),
 };
-export const addMessages = mutation({
+exports.addMessages = (0, server_js_1.mutation)({
     args: addMessagesArgs,
     handler: addMessagesHandler,
-    returns: v.object({
-        messages: v.array(vMessageDoc),
+    returns: schema_js_1.v.object({
+        messages: schema_js_1.v.array(schema_js_1.vMessageDoc),
     }),
 });
 async function addMessagesHandler(ctx, args) {
@@ -55,13 +60,13 @@ async function addMessagesHandler(ctx, args) {
     const threadId = args.threadId;
     if (!userId && args.threadId) {
         const thread = await ctx.db.get(args.threadId);
-        assert(thread, `Thread ${args.threadId} not found`);
+        (0, convex_helpers_1.assert)(thread, `Thread ${args.threadId} not found`);
         userId = thread.userId;
     }
     const { embeddings, failPendingSteps, pending, messages, promptMessageId, ...rest } = args;
     const parentMessage = promptMessageId && (await ctx.db.get(promptMessageId));
     if (failPendingSteps) {
-        assert(args.threadId, "threadId is required to fail pending steps");
+        (0, convex_helpers_1.assert)(args.threadId, "threadId is required to fail pending steps");
         const pendingMessages = await ctx.db
             .query("messages")
             .withIndex("threadId_status_tool_order_stepOrder", (q) => q.eq("threadId", threadId).eq("status", "pending"))
@@ -73,7 +78,7 @@ async function addMessagesHandler(ctx, args) {
     let order, stepOrder;
     let fail = false;
     if (promptMessageId) {
-        assert(parentMessage, `Parent message ${promptMessageId} not found`);
+        (0, convex_helpers_1.assert)(parentMessage, `Parent message ${promptMessageId} not found`);
         if (parentMessage.status === "failed") {
             fail = true;
         }
@@ -89,13 +94,13 @@ async function addMessagesHandler(ctx, args) {
     }
     const toReturn = [];
     if (embeddings) {
-        assert(embeddings.vectors.length === messages.length, "embeddings.vectors.length must match messages.length");
+        (0, convex_helpers_1.assert)(embeddings.vectors.length === messages.length, "embeddings.vectors.length must match messages.length");
     }
     for (let i = 0; i < messages.length; i++) {
         const message = messages[i];
         let embeddingId;
         if (embeddings && embeddings.vectors[i]) {
-            embeddingId = await insertVector(ctx, embeddings.dimension, {
+            embeddingId = await (0, index_js_1.insertVector)(ctx, embeddings.dimension, {
                 vector: embeddings.vectors[i],
                 model: embeddings.model,
                 table: "messages",
@@ -111,8 +116,8 @@ async function addMessagesHandler(ctx, args) {
             parentMessageId: promptMessageId,
             userId,
             order,
-            tool: isTool(message.message),
-            text: extractText(message.message),
+            tool: (0, shared_js_1.isTool)(message.message),
+            text: (0, shared_js_1.extractText)(message.message),
             status: fail ? "failed" : pending ? "pending" : "success",
             error: fail ? "Parent message failed" : undefined,
             stepOrder,
@@ -136,11 +141,11 @@ async function addMessagesHandler(ctx, args) {
     return { messages: toReturn.map(publicMessage) };
 }
 // exported for tests
-export async function getMaxMessage(ctx, threadId, order) {
+async function getMaxMessage(ctx, threadId, order) {
     return orderedMessagesStream(ctx, threadId, "desc", order).first();
 }
 function orderedMessagesStream(ctx, threadId, sortOrder, order) {
-    return mergedStream([true, false].flatMap((tool) => messageStatuses.map((status) => stream(ctx.db, schema)
+    return (0, stream_1.mergedStream)([true, false].flatMap((tool) => exports.messageStatuses.map((status) => (0, stream_1.stream)(ctx.db, schema_js_1.schema)
         .query("messages")
         .withIndex("threadId_status_tool_order_stepOrder", (q) => {
         const qq = q
@@ -154,15 +159,15 @@ function orderedMessagesStream(ctx, threadId, sortOrder, order) {
     })
         .order(sortOrder))), ["order", "stepOrder"]);
 }
-export const rollbackMessage = mutation({
+exports.rollbackMessage = (0, server_js_1.mutation)({
     args: {
-        messageId: v.id("messages"),
-        error: v.optional(v.string()),
+        messageId: schema_js_1.v.id("messages"),
+        error: schema_js_1.v.optional(schema_js_1.v.string()),
     },
-    returns: v.null(),
+    returns: schema_js_1.v.null(),
     handler: async (ctx, { messageId, error }) => {
         const message = await ctx.db.get(messageId);
-        assert(message, `Message ${messageId} not found`);
+        (0, convex_helpers_1.assert)(message, `Message ${messageId} not found`);
         const messages = await orderedMessagesStream(ctx, message.threadId, "asc", message.order).collect();
         for (const m of messages) {
             if (m.status === "pending") {
@@ -175,33 +180,33 @@ export const rollbackMessage = mutation({
         });
     },
 });
-export const commitMessage = mutation({
+exports.commitMessage = (0, server_js_1.mutation)({
     args: {
-        messageId: v.id("messages"),
+        messageId: schema_js_1.v.id("messages"),
     },
-    returns: v.null(),
+    returns: schema_js_1.v.null(),
     handler: commitMessageHandler,
 });
-export const updateMessage = mutation({
+exports.updateMessage = (0, server_js_1.mutation)({
     args: {
-        messageId: v.id("messages"),
-        patch: v.object({
-            message: v.optional(vMessageDoc.fields.message),
-            status: v.optional(vMessageStatus),
-            error: v.optional(v.string()),
+        messageId: schema_js_1.v.id("messages"),
+        patch: schema_js_1.v.object({
+            message: schema_js_1.v.optional(schema_js_1.vMessageDoc.fields.message),
+            status: schema_js_1.v.optional(validators_js_1.vMessageStatus),
+            error: schema_js_1.v.optional(schema_js_1.v.string()),
         }),
     },
-    returns: vMessageDoc,
+    returns: schema_js_1.vMessageDoc,
     handler: async (ctx, args) => {
         const message = await ctx.db.get(args.messageId);
-        assert(message, `Message ${args.messageId} not found`);
+        (0, convex_helpers_1.assert)(message, `Message ${args.messageId} not found`);
         const patch = {
             ...args.patch,
         };
         if (args.patch.message !== undefined) {
             patch.message = args.patch.message;
-            patch.tool = isTool(args.patch.message);
-            patch.text = extractText(args.patch.message);
+            patch.tool = (0, shared_js_1.isTool)(args.patch.message);
+            patch.text = (0, shared_js_1.extractText)(args.patch.message);
         }
         await ctx.db.patch(args.messageId, patch);
         return publicMessage((await ctx.db.get(args.messageId)));
@@ -209,9 +214,9 @@ export const updateMessage = mutation({
 });
 async function commitMessageHandler(ctx, { messageId }) {
     const message = await ctx.db.get(messageId);
-    assert(message, `Message ${messageId} not found`);
+    (0, convex_helpers_1.assert)(message, `Message ${messageId} not found`);
     const order = message.order;
-    const messages = await mergedStream([true, false].map((tool) => stream(ctx.db, schema)
+    const messages = await (0, stream_1.mergedStream)([true, false].map((tool) => (0, stream_1.stream)(ctx.db, schema_js_1.schema)
         .query("messages")
         .withIndex("threadId_status_tool_order_stepOrder", (q) => q
         .eq("threadId", message.threadId)
@@ -222,26 +227,26 @@ async function commitMessageHandler(ctx, { messageId }) {
         await ctx.db.patch(message._id, { status: "success" });
     }
 }
-export const listMessagesByThreadId = query({
+exports.listMessagesByThreadId = (0, server_js_1.query)({
     args: {
-        threadId: v.id("threads"),
-        excludeToolMessages: v.optional(v.boolean()),
+        threadId: schema_js_1.v.id("threads"),
+        excludeToolMessages: schema_js_1.v.optional(schema_js_1.v.boolean()),
         /** @deprecated Use excludeToolMessages instead. */
-        isTool: v.optional(v.literal("use excludeToolMessages instead of this")),
+        isTool: schema_js_1.v.optional(schema_js_1.v.literal("use excludeToolMessages instead of this")),
         /** What order to sort the messages in. To get the latest, use "desc". */
-        order: v.union(v.literal("asc"), v.literal("desc")),
-        paginationOpts: v.optional(paginationOptsValidator),
-        statuses: v.optional(v.array(vMessageStatus)),
-        upToAndIncludingMessageId: v.optional(v.id("messages")),
+        order: schema_js_1.v.union(schema_js_1.v.literal("asc"), schema_js_1.v.literal("desc")),
+        paginationOpts: schema_js_1.v.optional(server_1.paginationOptsValidator),
+        statuses: schema_js_1.v.optional(schema_js_1.v.array(validators_js_1.vMessageStatus)),
+        upToAndIncludingMessageId: schema_js_1.v.optional(schema_js_1.v.id("messages")),
     },
     handler: async (ctx, args) => {
-        const statuses = args.statuses ?? vMessageStatus.members.map((m) => m.value);
+        const statuses = args.statuses ?? validators_js_1.vMessageStatus.members.map((m) => m.value);
         const last = args.upToAndIncludingMessageId &&
             (await ctx.db.get(args.upToAndIncludingMessageId));
-        assert(!last || last.threadId === args.threadId, "upToAndIncludingMessageId must be a message in the thread");
+        (0, convex_helpers_1.assert)(!last || last.threadId === args.threadId, "upToAndIncludingMessageId must be a message in the thread");
         const toolOptions = args.excludeToolMessages ? [false] : [true, false];
         const order = args.order ?? "desc";
-        const streams = toolOptions.flatMap((tool) => statuses.map((status) => stream(ctx.db, schema)
+        const streams = toolOptions.flatMap((tool) => statuses.map((status) => (0, stream_1.stream)(ctx.db, schema_js_1.schema)
             .query("messages")
             .withIndex("threadId_status_tool_order_stepOrder", (q) => {
             const qq = q
@@ -257,48 +262,48 @@ export const listMessagesByThreadId = query({
             .filterWith(async (m) => !last ||
             m.order < last.order ||
             (m.order === last.order && m.stepOrder <= last.stepOrder))));
-        const messages = await mergedStream(streams, [
+        const messages = await (0, stream_1.mergedStream)(streams, [
             "order",
             "stepOrder",
         ]).paginate(args.paginationOpts ?? {
-            numItems: DEFAULT_RECENT_MESSAGES,
+            numItems: shared_js_1.DEFAULT_RECENT_MESSAGES,
             cursor: null,
         });
         return { ...messages, page: messages.page.map(publicMessage) };
     },
-    returns: vPaginationResult(vMessageDoc),
+    returns: (0, validators_js_1.vPaginationResult)(schema_js_1.vMessageDoc),
 });
-export const getMessagesByIds = query({
+exports.getMessagesByIds = (0, server_js_1.query)({
     args: {
-        messageIds: v.array(v.id("messages")),
+        messageIds: schema_js_1.v.array(schema_js_1.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)),
+    returns: schema_js_1.v.array(schema_js_1.v.union(schema_js_1.v.null(), schema_js_1.vMessageDoc)),
 });
 /** @deprecated Use listMessagesByThreadId instead. */
-export const getThreadMessages = query({
-    args: { deprecated: v.literal("Use listMessagesByThreadId instead") },
+exports.getThreadMessages = (0, server_js_1.query)({
+    args: { deprecated: schema_js_1.v.literal("Use listMessagesByThreadId instead") },
     handler: async () => {
         throw new Error("Use listMessagesByThreadId instead of getThreadMessages");
     },
-    returns: vPaginationResult(vMessageDoc),
+    returns: (0, validators_js_1.vPaginationResult)(schema_js_1.vMessageDoc),
 });
-export const searchMessages = action({
+exports.searchMessages = (0, server_js_1.action)({
     args: {
-        threadId: v.optional(v.id("threads")),
-        searchAllMessagesForUserId: v.optional(v.string()),
-        beforeMessageId: v.optional(v.id("messages")),
-        ...vSearchOptions.fields,
+        threadId: schema_js_1.v.optional(schema_js_1.v.id("threads")),
+        searchAllMessagesForUserId: schema_js_1.v.optional(schema_js_1.v.string()),
+        beforeMessageId: schema_js_1.v.optional(schema_js_1.v.id("messages")),
+        ...validators_js_1.vSearchOptions.fields,
     },
-    returns: v.array(vMessageDoc),
+    returns: schema_js_1.v.array(schema_js_1.vMessageDoc),
     handler: async (ctx, args) => {
-        assert(args.searchAllMessagesForUserId || args.threadId, "Specify userId or threadId");
+        (0, convex_helpers_1.assert)(args.searchAllMessagesForUserId || args.threadId, "Specify userId or threadId");
         const limit = args.limit;
         let textSearchMessages;
         if (args.text) {
-            textSearchMessages = await ctx.runQuery(api.messages.textSearch, {
+            textSearchMessages = await ctx.runQuery(api_js_1.api.messages.textSearch, {
                 searchAllMessagesForUserId: args.searchAllMessagesForUserId,
                 threadId: args.threadId,
                 text: args.text,
@@ -308,10 +313,10 @@ export const searchMessages = action({
         }
         if (args.vector) {
             const dimension = args.vector.length;
-            if (!VectorDimensions.includes(dimension)) {
+            if (!tables_js_1.VectorDimensions.includes(dimension)) {
                 throw new Error(`Unsupported vector dimension: ${dimension}`);
             }
-            const vectors = (await searchVectors(ctx, args.vector, {
+            const vectors = (await (0, index_js_1.searchVectors)(ctx, args.vector, {
                 dimension,
                 model: args.vectorModel ?? "unknown",
                 table: "messages",
@@ -330,12 +335,12 @@ export const searchMessages = action({
             }))
                 .sort((a, b) => b.score - a.score);
             const vectorIds = vectorScores.slice(0, limit).map((v) => v.id);
-            const messages = await ctx.runQuery(internal.messages._fetchSearchMessages, {
+            const messages = await ctx.runQuery(api_js_1.internal.messages._fetchSearchMessages, {
                 searchAllMessagesForUserId: args.searchAllMessagesForUserId,
                 threadId: args.threadId,
                 vectorIds,
                 textSearchMessages: textSearchMessages?.filter((m) => !vectorIds.includes(m.embeddingId)),
-                messageRange: args.messageRange ?? DEFAULT_MESSAGE_RANGE,
+                messageRange: args.messageRange ?? shared_js_1.DEFAULT_MESSAGE_RANGE,
                 beforeMessageId: args.beforeMessageId,
                 limit,
             });
@@ -344,21 +349,21 @@ export const searchMessages = action({
         return textSearchMessages?.flat() ?? [];
     },
 });
-export const _fetchSearchMessages = internalQuery({
+exports._fetchSearchMessages = (0, server_js_1.internalQuery)({
     args: {
-        threadId: v.optional(v.id("threads")),
-        vectorIds: v.array(vVectorId),
-        searchAllMessagesForUserId: v.optional(v.string()),
-        textSearchMessages: v.optional(v.array(vMessageDoc)),
-        messageRange: v.object({ before: v.number(), after: v.number() }),
-        beforeMessageId: v.optional(v.id("messages")),
-        limit: v.number(),
+        threadId: schema_js_1.v.optional(schema_js_1.v.id("threads")),
+        vectorIds: schema_js_1.v.array(tables_js_1.vVectorId),
+        searchAllMessagesForUserId: schema_js_1.v.optional(schema_js_1.v.string()),
+        textSearchMessages: schema_js_1.v.optional(schema_js_1.v.array(schema_js_1.vMessageDoc)),
+        messageRange: schema_js_1.v.object({ before: schema_js_1.v.number(), after: schema_js_1.v.number() }),
+        beforeMessageId: schema_js_1.v.optional(schema_js_1.v.id("messages")),
+        limit: schema_js_1.v.number(),
     },
-    returns: v.array(vMessageDoc),
+    returns: schema_js_1.v.array(schema_js_1.vMessageDoc),
     handler: async (ctx, args) => {
         const beforeMessage = args.beforeMessageId && (await ctx.db.get(args.beforeMessageId));
         const { searchAllMessagesForUserId, threadId } = args;
-        assert(searchAllMessagesForUserId || threadId, "Specify searchAllMessagesForUserId or threadId to search");
+        (0, convex_helpers_1.assert)(searchAllMessagesForUserId || threadId, "Specify searchAllMessagesForUserId or threadId to search");
         let messages = (await Promise.all(args.vectorIds.map((embeddingId) => ctx.db
             .query("messages")
             .withIndex("embeddingId", (q) => q.eq("embeddingId", embeddingId))
@@ -438,16 +443,16 @@ export const _fetchSearchMessages = internalQuery({
 });
 // returns ranges of messages in order of text search relevance,
 // excluding duplicates in later ranges.
-export const textSearch = query({
+exports.textSearch = (0, server_js_1.query)({
     args: {
-        threadId: v.optional(v.id("threads")),
-        searchAllMessagesForUserId: v.optional(v.string()),
-        text: v.string(),
-        limit: v.number(),
-        beforeMessageId: v.optional(v.id("messages")),
+        threadId: schema_js_1.v.optional(schema_js_1.v.id("threads")),
+        searchAllMessagesForUserId: schema_js_1.v.optional(schema_js_1.v.string()),
+        text: schema_js_1.v.string(),
+        limit: schema_js_1.v.number(),
+        beforeMessageId: schema_js_1.v.optional(schema_js_1.v.id("messages")),
     },
     handler: async (ctx, args) => {
-        assert(args.searchAllMessagesForUserId || args.threadId, "Specify userId or threadId");
+        (0, convex_helpers_1.assert)(args.searchAllMessagesForUserId || args.threadId, "Specify userId or threadId");
         const beforeMessage = args.beforeMessageId && (await ctx.db.get(args.beforeMessageId));
         const order = beforeMessage?.order;
         const messages = await ctx.db
@@ -473,6 +478,6 @@ export const textSearch = query({
                 m.stepOrder < beforeMessage.stepOrder))
             .map(publicMessage);
     },
-    returns: v.array(vMessageDoc),
+    returns: schema_js_1.v.array(schema_js_1.vMessageDoc),
 });
 //# sourceMappingURL=messages.js.map