@convex-dev/agent 0.6.0 → 0.6.1

package/package.json

@@ -7,7 +7,7 @@
     "email": "support@convex.dev",
     "url": "https://github.com/get-convex/agent/issues"
   },
-  "version": "0.6.0",
+  "version": "0.6.1",
   "license": "Apache-2.0",
   "keywords": [
     "convex",
@@ -84,66 +84,66 @@
     }
   },
   "devDependencies": {
-    "@ai-sdk/anthropic": "^3.0.13",
-    "@ai-sdk/google": "^3.0.30",
-    "@ai-sdk/groq": "^3.0.8",
-    "@ai-sdk/openai": "^3.0.10",
-    "@ai-sdk/provider": "^3.0.3",
-    "@ai-sdk/provider-utils": "^4.0.6",
-    "@convex-dev/rag": "0.7.0",
-    "@convex-dev/rate-limiter": "0.3.0",
-    "@convex-dev/workflow": "0.3.2",
+    "@ai-sdk/anthropic": "3.0.13",
+    "@ai-sdk/google": "3.0.30",
+    "@ai-sdk/groq": "3.0.8",
+    "@ai-sdk/openai": "3.0.10",
+    "@ai-sdk/provider": "3.0.3",
+    "@ai-sdk/provider-utils": "4.0.6",
+    "@convex-dev/rag": "0.7.2",
+    "@convex-dev/rate-limiter": "0.3.2",
+    "@convex-dev/workflow": "0.3.6",
     "@edge-runtime/vm": "5.0.0",
-    "@eslint/js": "9.38.0",
+    "@eslint/js": "9.39.4",
     "@hookform/resolvers": "5.2.2",
     "@langchain/textsplitters": "0.1.0",
     "@radix-ui/react-accordion": "1.2.12",
     "@radix-ui/react-checkbox": "1.3.3",
-    "@radix-ui/react-label": "2.1.7",
+    "@radix-ui/react-label": "2.1.8",
     "@radix-ui/react-select": "2.2.6",
-    "@radix-ui/react-slot": "1.2.3",
+    "@radix-ui/react-slot": "1.2.4",
     "@radix-ui/react-toast": "1.2.15",
     "@tailwindcss/typography": "0.5.19",
-    "@types/node": "20.19.24",
-    "@types/react": "19.2.2",
-    "@types/react-dom": "19.2.2",
+    "@types/node": "20.19.37",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
     "@vitejs/plugin-react": "4.7.0",
-    "ai": "^6.0.35",
-    "autoprefixer": "10.4.21",
+    "ai": "6.0.35",
+    "autoprefixer": "10.4.27",
     "chokidar-cli": "3.0.0",
     "class-variance-authority": "0.7.1",
     "clsx": "2.1.1",
-    "convex": "1.29.3",
-    "convex-helpers": "0.1.104",
-    "convex-test": "0.0.38",
+    "convex": "1.33.1",
+    "convex-helpers": "0.1.114",
+    "convex-test": "0.0.41",
     "cpy-cli": "5.0.0",
-    "dayjs": "1.11.18",
+    "dayjs": "1.11.20",
     "dotenv": "16.6.1",
-    "eslint": "9.38.0",
+    "eslint": "9.39.4",
     "eslint-plugin-jsx-a11y": "6.10.2",
     "eslint-plugin-react": "7.37.5",
-    "eslint-plugin-react-hooks": "^6",
-    "eslint-plugin-react-refresh": "0.4.24",
-    "globals": "16.4.0",
-    "lucide-react": "0.548.0",
+    "eslint-plugin-react-hooks": "6.1.1",
+    "eslint-plugin-react-refresh": "0.5.2",
+    "globals": "16.5.0",
+    "lucide-react": "0.577.0",
     "npm-run-all2": "8.0.4",
-    "ollama-ai-provider": "^1.2.0",
+    "ollama-ai-provider": "1.2.0",
     "openai": "5.23.2",
-    "path-exists-cli": "^2.0.0",
-    "pkg-pr-new": "0.0.60",
-    "postcss": "8.5.6",
-    "prettier": "3.6.2",
-    "react": "19.2.3",
-    "react-dom": "19.2.3",
-    "react-hook-form": "7.65.0",
+    "path-exists-cli": "2.0.0",
+    "pkg-pr-new": "0.0.66",
+    "postcss": "8.5.8",
+    "prettier": "3.8.1",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
+    "react-hook-form": "7.71.2",
     "react-markdown": "10.1.0",
-    "react-router-dom": "7.9.5",
+    "react-router-dom": "7.13.1",
     "readline": "1.3.0",
-    "tailwind-merge": "3.3.1",
-    "tailwindcss": "3.4.18",
+    "tailwind-merge": "3.5.0",
+    "tailwindcss": "3.4.19",
     "tailwindcss-animate": "1.0.7",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.46.2",
+    "typescript-eslint": "8.57.1",
     "vite": "6.4.1",
     "vitest": "3.2.4",
     "zod": "3.25.76"

package/src/UIMessages.ts

@@ -396,8 +396,6 @@ function createAssistantUIMessage<
     ? ("streaming" as const)
     : lastMessage.status;
 
-<<<<<<< Updated upstream
-=======
   // Extract approval parts from raw message content for UI rendering
   type ApprovalPart =
     | { type: "tool-approval-request"; approvalId: string; toolCallId: string }
@@ -443,7 +441,6 @@ function createAssistantUIMessage<
     }
   }
 
->>>>>>> Stashed changes
   // Collect all parts from all messages
   const allParts: UIMessage<METADATA, DATA_PARTS, TOOLS>["parts"] = [];
 
@@ -525,12 +522,9 @@ function createAssistantUIMessage<
           break;
         }
         case "tool-result": {
-<<<<<<< Updated upstream
-=======
           // Note: execution-denied outputs are handled separately via pre-extraction
           // from raw content (converted to text format for providers in start.ts).
           // See executionDeniedResults processing at the end of this function.
->>>>>>> Stashed changes
           const typedPart = contentPart as unknown as ToolResultPart & {
             output: { type: string; value?: unknown; reason?: string };
           };
@@ -696,8 +690,6 @@ function createAssistantUIMessage<
     }
   }
 
-<<<<<<< Updated upstream
-=======
   // Final output states that should not be overwritten by approval processing
   const finalStates = new Set([
     "output-available",
@@ -776,7 +768,6 @@ function createAssistantUIMessage<
     }
   }
 
->>>>>>> Stashed changes
   return {
     ...common,
     role: "assistant",

package/src/client/approval.test.ts

@@ -57,6 +57,17 @@ function getApprovalIdFromSavedMessages(
   return approvalRequest.approvalId;
 }
 
+// Second tool that also requires approval
+const renameFileTool = createTool({
+  description: "Rename a file",
+  inputSchema: z.object({
+    oldName: z.string(),
+    newName: z.string(),
+  }),
+  needsApproval: () => true,
+  execute: async (_ctx, input) => `Renamed: ${input.oldName} → ${input.newName}`,
+});
+
 // --- Agents (separate mock model instances to avoid shared callIndex) ---
 
 const approvalAgent = new Agent(components.agent, {
@@ -257,6 +268,114 @@ export const testApproveFlowWithInterveningMessage = action({
   },
 });
 
+// Agent that calls two tools in one step, both needing approval
+const multiToolAgent = new Agent(components.agent, {
+  name: "multi-tool-test",
+  instructions: "You manage files.",
+  tools: { deleteFile: deleteFileTool, renameFile: renameFileTool },
+  languageModel: mockModel({
+    contentSteps: [
+      // Step 1: model calls two tools at once
+      [
+        {
+          type: "tool-call",
+          toolCallId: "tc-multi-1",
+          toolName: "deleteFile",
+          input: JSON.stringify({ filename: "old.txt" }),
+        },
+        {
+          type: "tool-call",
+          toolCallId: "tc-multi-2",
+          toolName: "renameFile",
+          input: JSON.stringify({ oldName: "a.txt", newName: "b.txt" }),
+        },
+      ],
+      // Step 2: after both tools execute, model responds
+      [{ type: "text", text: "Done! Deleted old.txt and renamed a.txt to b.txt." }],
+    ],
+  }),
+  stopWhen: stepCountIs(5),
+  usageHandler: testUsageHandler,
+});
+
+export const testMultiToolApproveFlow = action({
+  args: {},
+  handler: async (ctx) => {
+    const { thread } = await multiToolAgent.createThread(ctx, {
+      userId: "u-multi",
+    });
+
+    // Step 1: Generate — model calls two tools, both need approval
+    const result1 = await thread.generateText({
+      prompt: "Delete old.txt and rename a.txt to b.txt",
+    });
+
+    // Extract both approval IDs
+    const approvalParts = result1.savedMessages
+      ?.flatMap((m) =>
+        Array.isArray(m.message?.content)
+          ? (m.message.content as unknown[])
+          : [],
+      )
+      .filter(
+        (
+          p,
+        ): p is {
+          type: "tool-approval-request";
+          approvalId: string;
+          toolCallId: string;
+        } => (p as { type?: string }).type === "tool-approval-request",
+      );
+
+    if (!approvalParts || approvalParts.length !== 2) {
+      throw new Error(
+        `Expected 2 approval requests, got ${approvalParts?.length ?? 0}`,
+      );
+    }
+
+    // Approve both tool calls
+    const { messageId: _msgId1 } = await ctx.runMutation(
+      anyApi["approval.test"].submitApprovalForMultiToolAgent,
+      { threadId: thread.threadId, approvalId: approvalParts[0].approvalId },
+    );
+    const { messageId: msgId2 } = await ctx.runMutation(
+      anyApi["approval.test"].submitApprovalForMultiToolAgent,
+      { threadId: thread.threadId, approvalId: approvalParts[1].approvalId },
+    );
+
+    // Continue generation with the last approval message
+    const result2 = await thread.generateText({
+      promptMessageId: msgId2,
+    });
+
+    const allMessages = await multiToolAgent.listMessages(ctx, {
+      threadId: thread.threadId,
+      paginationOpts: { cursor: null, numItems: 40 },
+    });
+
+    return {
+      approvalCount: approvalParts.length,
+      firstText: result1.text,
+      secondText: result2.text,
+      threadMessageRoles: allMessages.page.map((m) => m.message?.role),
+      // Check that both approvals were merged into one tool message
+      toolMessageCount: allMessages.page.filter(
+        (m) => m.message?.role === "tool",
+      ).length,
+    };
+  },
+});
+
+export const submitApprovalForMultiToolAgent = mutation({
+  args: {
+    threadId: v.string(),
+    approvalId: v.string(),
+  },
+  handler: async (ctx, { threadId, approvalId }) => {
+    return multiToolAgent.approveToolCall(ctx, { threadId, approvalId });
+  },
+});
+
 export const submitApprovalForApprovalAgent = mutation({
   args: { threadId: v.string(), approvalId: v.string(), reason: v.optional(v.string()) },
   handler: async (ctx, { threadId, approvalId, reason }) => {
@@ -276,7 +395,9 @@ const testApi: ApiFromModules<{
     testApproveFlow: typeof testApproveFlow;
     testDenyFlow: typeof testDenyFlow;
     testApproveFlowWithInterveningMessage: typeof testApproveFlowWithInterveningMessage;
+    testMultiToolApproveFlow: typeof testMultiToolApproveFlow;
     submitApprovalForApprovalAgent: typeof submitApprovalForApprovalAgent;
+    submitApprovalForMultiToolAgent: typeof submitApprovalForMultiToolAgent;
     submitDenialForDenialAgent: typeof submitDenialForDenialAgent;
   };
 }>["fns"] = anyApi["approval.test"] as any;
@@ -338,6 +459,29 @@ describe("Tool Approval Workflow", () => {
     expect(result.lastUsage!.outputTokenDetails).toBeDefined();
   });
 
+  test("multi-tool: approve two tool calls from the same step", async () => {
+    usageCalls.length = 0;
+    const t = initConvexTest(schema);
+    const result = await t.action(testApi.testMultiToolApproveFlow, {});
+
+    expect(result.approvalCount).toBe(2);
+    expect(result.firstText).toBe("");
+    expect(result.secondText).toBe(
+      "Done! Deleted old.txt and renamed a.txt to b.txt.",
+    );
+    // Both approval responses should be merged into one tool message
+    // (write-time merge in respondToToolCallApproval via findApprovalContext)
+    // Thread: user, assistant(2 tool-calls + 2 approvals),
+    //         tool(2 approval-responses merged), tool(2 tool-results), assistant(text)
+    expect(result.threadMessageRoles).toEqual([
+      "assistant", // final text
+      "tool", // tool-results
+      "tool", // approval-responses (merged)
+      "assistant", // tool-calls + approval-requests
+      "user", // prompt
+    ]);
+  });
+
   test("approve remains valid with an intervening thread message", async () => {
     usageCalls.length = 0;
     const t = initConvexTest(schema);

package/src/client/index.ts

@@ -1123,25 +1123,34 @@ export class Agent<
     // The "already handled" check (tool-approval-response) relies on seeing
     // responses before their corresponding requests. If the pagination order
     // changes, this logic will need to be updated.
-    let cursor: string | null = null;
     let existingResponseMessage: MessageDoc | undefined;
-    do {
-      const page = await this.listMessages(ctx, {
-        threadId: args.threadId,
-        paginationOpts: { cursor, numItems: 100 },
-      });
+    // Limit the search to the most recent messages. Approvals should always
+    // be near the end of the thread.
+    const page = await this.listMessages(ctx, {
+      threadId: args.threadId,
+      paginationOpts: { cursor: null, numItems: 100 },
+    });
+    {
       for (const message of page.page) {
         const content = message.message?.content;
         if (!Array.isArray(content)) continue;
         // Check if this assistant message starts a different approval step.
         // If so, any response message we've seen so far belongs to a newer
         // step — reset it so we don't merge across step boundaries.
+        // Only reset if the target approval is NOT in this message (i.e.,
+        // this is a genuinely different step, not the same step with
+        // multiple tool calls).
         if (
           message.message?.role === "assistant" &&
           content.some(
             (p: any) =>
               p.type === "tool-approval-request" &&
               p.approvalId !== args.approvalId,
+          ) &&
+          !content.some(
+            (p: any) =>
+              p.type === "tool-approval-request" &&
+              p.approvalId === args.approvalId,
           )
         ) {
           existingResponseMessage = undefined;
@@ -1169,11 +1178,10 @@ export class Agent<
           }
         }
       }
-      cursor = page.isDone ? null : page.continueCursor;
-    } while (cursor !== null);
+    }
 
     throw new Error(
-      `Approval request ${args.approvalId} was not found in thread ${args.threadId}`,
+      `Approval request ${args.approvalId} was not found in the last 100 messages of thread ${args.threadId}`,
     );
   }
 

package/src/client/search.ts

@@ -35,28 +35,6 @@ import {
   toModelMessage,
 } from "../mapping.js";
 
-/**
- * Filter out approval parts from messages before sending to AI providers.
- * Providers like Anthropic don't understand tool-approval-request and
- * tool-approval-response parts and will error if they are included.
- */
-function filterApprovalPartsForProvider(messages: ModelMessage[]): ModelMessage[] {
-  return messages.map((message) => {
-    if (!Array.isArray(message.content)) {
-      return message;
-    }
-    const filteredContent = message.content.filter(
-      (part) =>
-        (part as { type: string }).type !== "tool-approval-request" &&
-        (part as { type: string }).type !== "tool-approval-response",
-    );
-    return {
-      ...message,
-      content: filteredContent,
-    } as typeof message;
-  });
-}
-
 const DEFAULT_VECTOR_SCORE_THRESHOLD = 0.0;
 // 10k characters should be more than enough for most cases, and stays under
 // the 8k token limit for some models.
@@ -256,11 +234,7 @@ export async function fetchRecentAndSearchMessages(
     searchMessages = filterOutOrphanedToolMessages(
       sorted(searchResults.filter((m) => !included?.has(m._id))),
     );
-    searchMessages = filterApprovalPartsForProvider(searchMessages);
   }
-
-  // filter out approval parts before returning
-  searchMessages = filterApprovalPartsForProvider(searchMessages);
   // Ensure we don't include tool messages without a corresponding tool call
   return { recentMessages, searchMessages };
 }
@@ -704,9 +678,6 @@ export async function fetchContextWithPrompt(
     processedMessages = await inlineMessagesFiles(processedMessages);
   }
 
-  // Filter out approval parts before sending to AI providers
-  processedMessages = filterApprovalPartsForProvider(processedMessages);
-
   return {
     messages: processedMessages,
     order: promptMessage?.order,

package/src/client/start.ts

@@ -10,7 +10,7 @@ import {
   type ToolSet,
 } from "ai";
 import {
-  serializeNewMessagesInStep,
+  serializeResponseMessages,
   serializeObjectResult,
 } from "../mapping.js";
 import { embedMessages, fetchContextWithPrompt } from "./search.js";
@@ -252,7 +252,7 @@ export async function startGeneration<
             previousResponseMessageCount,
           );
           previousResponseMessageCount = allResponseMessages.length;
-          serialized = await serializeNewMessagesInStep(
+          serialized = await serializeResponseMessages(
             ctx,
             component,
             toSave.step,

package/src/client/streamText.ts

@@ -168,6 +168,15 @@ export async function streamText<
       // finish() was never called, leaving the streaming message stuck in
       // "streaming" state. Clean it up by marking it as aborted.
       await streamer?.fail(e instanceof Error ? e.message : String(e));
+      // Save the deferred final step if it was already generated but not yet persisted
+      if (pendingFinalStep) {
+        try {
+          await call.save({ step: pendingFinalStep }, false);
+        } catch (saveError) {
+          console.error("Failed to save deferred final step:", saveError);
+        }
+        pendingFinalStep = undefined;
+      }
       throw e;
     }
   }

package/src/client/streaming.ts

@@ -244,16 +244,25 @@ export class DeltaStreamer<T> {
     this.abortController = new AbortController();
     if (config.abortSignal) {
       config.abortSignal.addEventListener("abort", async () => {
-        if (this.abortController.signal.aborted) {
-          return;
-        }
-        if (this.streamId) {
+        try {
+          if (this.abortController.signal.aborted) {
+            return;
+          }
           this.abortController.abort();
-          await this.#ongoingWrite;
-          await this.ctx.runMutation(this.component.streams.abort, {
-            streamId: this.streamId,
-            reason: "abortSignal",
-          });
+          // Wait for in-flight stream creation before trying to abort it
+          if (this.#creatingStreamIdPromise) {
+            await this.#creatingStreamIdPromise;
+          }
+          if (this.streamId) {
+            await this.#ongoingWrite;
+            await this.ctx.runMutation(this.component.streams.abort, {
+              streamId: this.streamId,
+              reason: "abortSignal",
+            });
+          }
+        } catch {
+          // Best-effort cleanup — the stream will be garbage-collected
+          // by the 10-minute timeout if this fails.
         }
       });
     }
@@ -293,7 +302,9 @@ export class DeltaStreamer<T> {
       await this.addParts([chunk]);
     }
     // Skip finish if it will be handled externally (atomically with message save)
-    // or if the stream was aborted (e.g., due to a failed delta write)
+    // or if the stream was aborted (e.g., due to a failed delta write).
+    // Aborted streams are cleaned up via streams.abort (called by the abort
+    // signal handler), so we don't need to call finish() for them.
     if (!this.#finishedExternally && !this.abortController.signal.aborted) {
       await this.finish();
     }
@@ -376,10 +387,7 @@ export class DeltaStreamer<T> {
       return;
     }
     await this.#ongoingWrite;
-    if (this.abortController.signal.aborted) {
-      return;
-    }
-    await this.#sendDelta();
+    await this.#sendDelta(); // #sendDelta checks aborted internally
     if (this.abortController.signal.aborted) {
       return;
     }
@@ -439,16 +447,15 @@ export function compressTextStreamParts(
       } else {
         compressed.push(part);
       }
+    } else if (part.type === "file") {
+      compressed.push({
+        type: "file",
+        file: {
+          ...part.file,
+          uint8Array: undefined as unknown as Uint8Array,
+        },
+      });
     } else {
-      if (part.type === "file") {
-        compressed.push({
-          type: "file",
-          file: {
-            ...part.file,
-            uint8Array: undefined as unknown as Uint8Array,
-          },
-        });
-      }
       compressed.push(part);
     }
   }

package/src/component/_generated/dataModel.ts

@@ -38,7 +38,7 @@ export type Doc<TableName extends TableNames> = DocumentByName<
  * Convex documents are uniquely identified by their `Id`, which is accessible
  * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
  *
- * Documents can be loaded using `db.get(id)` in query and mutation functions.
+ * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
  *
  * IDs are just strings at runtime, but this type can be used to distinguish them from other
  * strings when type checking.

package/src/component/_generated/server.ts

@@ -107,11 +107,6 @@ export const internalAction: ActionBuilder<DataModel, "internal"> =
  */
 export const httpAction: HttpActionBuilder = httpActionGeneric;
 
-type GenericCtx =
-  | GenericActionCtx<DataModel>
-  | GenericMutationCtx<DataModel>
-  | GenericQueryCtx<DataModel>;
-
 /**
  * A set of services for use within Convex query functions.
  *

package/src/mapping.ts

@@ -297,21 +297,49 @@ export function toModelMessageWarnings(
   }) as any;
 }
 
+/**
+ * Serialize explicitly provided response messages for a step.
+ * Used by the streaming/generation loop where the caller tracks which
+ * messages are new via slicing.
+ */
+export async function serializeResponseMessages<TOOLS extends ToolSet>(
+  ctx: ActionCtx,
+  component: AgentComponent,
+  step: StepResult<TOOLS>,
+  model: ModelOrMetadata | undefined,
+  responseMessages: ModelMessage[],
+): Promise<{ messages: MessageWithMetadata[] }> {
+  return serializeStepMessages(ctx, component, step, model, responseMessages);
+}
+
+/**
+ * Serialize the new messages from a step using a heuristic to determine
+ * which response messages are new (last 1-2 messages).
+ */
 export async function serializeNewMessagesInStep<TOOLS extends ToolSet>(
   ctx: ActionCtx,
   component: AgentComponent,
   step: StepResult<TOOLS>,
   model: ModelOrMetadata | undefined,
-  /**
-   * If provided, these are the new response messages for this step
-   * (pre-sliced by the caller). When not provided, falls back to the
-   * existing heuristic of slicing the last 1-2 messages.
-   *
-   * This is needed for tool approval flows where the SDK adds extra
-   * messages (e.g. approval tool-results) at the beginning of
-   * responseMessages that the old slice(-1/-2) logic would miss.
-   */
-  newResponseMessages?: ModelMessage[],
+): Promise<{ messages: MessageWithMetadata[] }> {
+  const hasToolMessage = step.response.messages.at(-1)?.role === "tool";
+  let messagesToSerialize: ModelMessage[];
+  if (hasToolMessage) {
+    messagesToSerialize = step.response.messages.slice(-2);
+  } else if (step.content.length) {
+    messagesToSerialize = step.response.messages.slice(-1);
+  } else {
+    messagesToSerialize = [{ role: "assistant" as const, content: [] }];
+  }
+  return serializeStepMessages(ctx, component, step, model, messagesToSerialize);
+}
+
+async function serializeStepMessages<TOOLS extends ToolSet>(
+  ctx: ActionCtx,
+  component: AgentComponent,
+  step: StepResult<TOOLS>,
+  model: ModelOrMetadata | undefined,
+  messagesToSerialize: ModelMessage[],
 ): 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/src/generate-text/to-response-messages.ts#L120
@@ -330,18 +358,6 @@ export async function serializeNewMessagesInStep<TOOLS extends ToolSet>(
   } satisfies Omit<MessageWithMetadata, "message" | "text" | "fileIds">;
   const toolFields = { sources: step.sources };
 
-  // Determine which messages to serialize for this step
-  let messagesToSerialize: ModelMessage[];
-  if (newResponseMessages) {
-    messagesToSerialize = newResponseMessages;
-  } else if (hasToolMessage) {
-    messagesToSerialize = step.response.messages.slice(-2);
-  } else if (step.content.length) {
-    messagesToSerialize = step.response.messages.slice(-1);
-  } else {
-    messagesToSerialize = [{ role: "assistant" as const, content: [] }];
-  }
-
   const messages: MessageWithMetadata[] = await Promise.all(
     messagesToSerialize.map(async (msg): Promise<MessageWithMetadata> => {
       const { message, fileIds } = await serializeMessage(ctx, component, msg);

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":28.127082999999402,"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}],[":client/streaming.test.ts",{"duration":177.87866699695587,"failed":false}]]}