@convex-dev/agent 0.6.3 → 0.7.0-alpha.0

package/src/component/vector/index.ts

@@ -11,6 +11,7 @@ import {
 import schema from "../schema.js";
 import {
   type EmbeddingsWithoutDenormalizedFields,
+  getVectorIdInfo,
   getVectorTableName,
   type VectorDimension,
   vEmbeddingsWithoutDenormalizedFields,
@@ -84,7 +85,7 @@ export const deleteBatchForThread = mutation({
       numItems: args.limit,
       maximumRowsRead: 300,
     });
-    await Promise.all(vectors.page.map((v) => ctx.db.delete(v._id)));
+    await Promise.all(vectors.page.map((v) => ctx.db.delete(tableName, v._id)));
     return {
       isDone: vectors.isDone,
       continueCursor: vectors.continueCursor,
@@ -108,7 +109,7 @@ export const insertBatch = mutation({
       args.vectors.map(async ({ messageId, ...v }) => {
         const embeddingId = await insertVector(ctx, args.vectorDimension, v);
         if (messageId) {
-          await ctx.db.patch(messageId, { embeddingId });
+          await ctx.db.patch("messages", messageId, { embeddingId });
         }
         return embeddingId;
       }),
@@ -180,12 +181,13 @@ export const updateBatch = mutation({
   returns: v.null(),
   handler: async (ctx, args) => {
     await Promise.all(
-      args.vectors.map((embedding) =>
-        ctx.db.patch(embedding.id, {
+      args.vectors.map((embedding) => {
+        const { tableName } = getVectorIdInfo(ctx, embedding.id);
+        return ctx.db.patch(tableName, embedding.id, {
           model: embedding.model,
           vector: embedding.vector,
-        }),
-      ),
+        });
+      }),
     );
   },
 });
@@ -196,6 +198,11 @@ export const deleteBatch = mutation({
   },
   returns: v.null(),
   handler: async (ctx, args) => {
-    await Promise.all(args.ids.map((id) => ctx.db.delete(id)));
+    await Promise.all(
+      args.ids.map((id) => {
+        const { tableName } = getVectorIdInfo(ctx, id);
+        return ctx.db.delete(tableName, id);
+      }),
+    );
   },
 });

package/src/eslintConfig.test.ts

@@ -0,0 +1,44 @@
+import { Linter } from "eslint";
+import { describe, expect, it } from "vitest";
+
+describe("provider adapter boundary lint selectors", () => {
+  it("parse on Node 20 and reject every restricted dynamic import shape", async () => {
+    const configUrl = new URL("../eslint.config.js", import.meta.url).href;
+    const { default: eslintConfig } = (await import(configUrl)) as {
+      default: Array<{
+        files?: string[];
+        rules?: Record<string, unknown>;
+      }>;
+    };
+    const boundaryConfig = eslintConfig.find(
+      (config) =>
+        "files" in config &&
+        config.files?.some((pattern) => pattern.includes("src/streaming/")) &&
+        config.rules?.["no-restricted-syntax"],
+    );
+    const restrictedSyntax = boundaryConfig?.rules?.["no-restricted-syntax"];
+    expect(restrictedSyntax).toBeDefined();
+
+    const messages = new Linter({ configType: "flat" }).verify(
+      [
+        'import("ai");',
+        'import("ai/test");',
+        'import("@ai-sdk/provider");',
+        'import("vercel");',
+        'import("vercel/test");',
+        'import("../vercel");',
+        'import("../vercel/test");',
+      ].join("\n"),
+      {
+        languageOptions: { ecmaVersion: 2020, sourceType: "module" },
+        rules: {
+          "no-restricted-syntax": restrictedSyntax as Linter.RuleEntry,
+        },
+      },
+    );
+
+    expect(messages).toHaveLength(7);
+    expect(messages.every((message) => message.ruleId === "no-restricted-syntax"))
+      .toBe(true);
+  });
+});

package/src/react/index.ts

@@ -1,17 +1,20 @@
 "use client";
 import { useMemo, useState } from "react";
-export { toUIMessages, type UIMessage } from "../UIMessages.js";
+export { toUIMessages, type UIMessage } from "../vercel/UIMessages.js";
 
-export { optimisticallySendMessage } from "./optimisticallySendMessage.js";
+export { optimisticallySendMessage } from "../vercel/react/optimisticallySendMessage.js";
 export { useSmoothText } from "./useSmoothText.js";
 export { SmoothText } from "./SmoothText.js";
 export {
   type ThreadMessagesQuery,
   useThreadMessages,
   useStreamingThreadMessages,
-} from "./useThreadMessages.js";
-export { type UIMessagesQuery, useUIMessages } from "./useUIMessages.js";
-export { useStreamingUIMessages } from "./useStreamingUIMessages.js";
+} from "../vercel/react/useThreadMessages.js";
+export {
+  type UIMessagesQuery,
+  useUIMessages,
+} from "../vercel/react/useUIMessages.js";
+export { useStreamingUIMessages } from "../vercel/react/useStreamingUIMessages.js";
 
 /**
  * @deprecated use useThreadMessages or useStreamingThreadMessages instead

package/src/shared.ts

@@ -1,23 +1,19 @@
-import type {
-  FilePart,
-  ImagePart,
-  ReasoningPart,
-  ToolCallPart,
-  ToolResultPart,
-  ToolApprovalRequest,
-} from "@ai-sdk/provider-utils";
-import type {
-  ModelMessage,
-  TextPart,
-  UIDataTypes,
-  UIMessagePart,
-  UITools,
-} from "ai";
-import type { Message, MessageContentParts } from "./validators.js";
+type MessagePartLike = {
+  type: string;
+  text?: string;
+};
+
+type MessageLike =
+  | { role: "system"; content: string }
+  | {
+      role: "user" | "assistant";
+      content: string | readonly MessagePartLike[];
+    }
+  | { role: "tool"; content: readonly MessagePartLike[] };
 
 export const DEFAULT_RECENT_MESSAGES = 100;
 
-export function isTool(message: Message | ModelMessage) {
+export function isTool(message: MessageLike) {
   return (
     message.role === "tool" ||
     (message.role === "assistant" &&
@@ -26,7 +22,7 @@ export function isTool(message: Message | ModelMessage) {
   );
 }
 
-export function extractText(message: Message | ModelMessage) {
+export function extractText(message: MessageLike) {
   switch (message.role) {
     case "user":
       if (typeof message.content === "string") {
@@ -46,33 +42,27 @@ export function extractText(message: Message | ModelMessage) {
   return undefined;
 }
 
-export function joinText(
-  parts: (
-    | UIMessagePart<UIDataTypes, UITools>
-    | TextPart
-    | ImagePart
-    | FilePart
-    | ReasoningPart
-    | ToolCallPart
-    | ToolResultPart
-    | MessageContentParts
-    | ToolApprovalRequest
-  )[],
-) {
+export function joinText(parts: readonly MessagePartLike[]) {
   return parts
-    .filter((p) => p.type === "text")
-    .map((p) => p.text)
+    .filter(
+      (part): part is MessagePartLike & { text: string } =>
+        part.type === "text" && typeof part.text === "string",
+    )
+    .map((part) => part.text)
     .filter(Boolean)
     .join(" ");
 }
 
-export function extractReasoning(message: Message | ModelMessage) {
+export function extractReasoning(message: MessageLike) {
   if (typeof message.content === "string") {
     return undefined;
   }
   return message.content
-    .filter((c) => c.type === "reasoning")
-    .map((c) => c.text)
+    .filter(
+      (part): part is MessagePartLike & { text: string } =>
+        part.type === "reasoning" && typeof part.text === "string",
+    )
+    .map((part) => part.text)
     .join(" ");
 }