@convex-dev/agent 0.1.18-alpha.0 → 0.5.0-alpha.1

package/src/react/toUIMessages.ts

@@ -1,22 +1,41 @@
-import type { ToolInvocationUIPart } from "@ai-sdk/ui-utils";
-import type { UIMessage as AIUIMessage } from "ai";
+import type {
+  UIMessage as AIUIMessage,
+  DeepPartial,
+  ReasoningUIPart,
+  SourceDocumentUIPart,
+  SourceUrlUIPart,
+  StepStartUIPart,
+  TextUIPart,
+  ToolUIPart,
+  UIDataTypes,
+  UITools,
+} from "ai";
 import type { MessageDoc } from "../client/index.js";
 import { deserializeMessage, toUIFilePart } from "../mapping.js";
 import type { MessageStatus } from "../validators.js";
 
-export type UIMessage = AIUIMessage & {
+export type UIMessage<
+  METADATA = unknown,
+  DATA_PARTS extends UIDataTypes = UIDataTypes,
+  TOOLS extends UITools = UITools,
+> = AIUIMessage<METADATA, DATA_PARTS, TOOLS> & {
   key: string;
   order: number;
   stepOrder: number;
   status: "streaming" | MessageStatus;
   agentName?: string;
+  text: string;
 };
 
-export function toUIMessages(
+export function toUIMessages<
+  METADATA = unknown,
+  DATA_PARTS extends UIDataTypes = UIDataTypes,
+  TOOLS extends UITools = UITools,
+>(
   messages: (MessageDoc & { streaming?: boolean })[],
-): UIMessage[] {
-  const uiMessages: UIMessage[] = [];
-  let assistantMessage: UIMessage | undefined;
+): UIMessage<METADATA, DATA_PARTS, TOOLS>[] {
+  const uiMessages: UIMessage<METADATA, DATA_PARTS, TOOLS>[] = [];
+  let assistantMessage: UIMessage<METADATA, DATA_PARTS, TOOLS> | undefined;
   for (const message of messages) {
     const coreMessage = message.message && deserializeMessage(message.message);
     const text = message.text ?? "";
@@ -31,17 +50,23 @@ export function toUIMessages(
       stepOrder: message.stepOrder,
       status: message.streaming ? ("streaming" as const) : message.status,
       key: `${message.threadId}-${message.order}-${message.stepOrder}`,
+      text,
+    };
+    const partCommon = {
+      state: message.streaming ? ("streaming" as const) : ("done" as const),
+      ...(message.providerMetadata
+        ? { providerMetadata: message.providerMetadata }
+        : {}),
     };
     if (coreMessage.role === "system") {
       uiMessages.push({
         ...common,
         role: "system",
-        content: text,
         agentName: message.agentName,
-        parts: [{ type: "text", text }],
+        parts: [{ type: "text", text, ...partCommon } satisfies TextUIPart],
       });
     } else if (coreMessage.role === "user") {
-      const parts: UIMessage["parts"] = [];
+      const parts: UIMessage<METADATA, DATA_PARTS, TOOLS>["parts"] = [];
       if (text) {
         parts.push({ type: "text", text });
       }
@@ -56,7 +81,6 @@ export function toUIMessages(
       uiMessages.push({
         ...common,
         role: "user",
-        content: message.text ?? "",
         parts,
       });
     } else {
@@ -72,7 +96,6 @@ export function toUIMessages(
           ...common,
           role: "assistant",
           agentName: message.agentName,
-          content: "",
           parts: [],
         };
         uiMessages.push(assistantMessage);
@@ -83,78 +106,134 @@ export function toUIMessages(
       }
       // update it to the last message's id
       assistantMessage.id = message._id;
-      if (message.reasoning) {
+      if (
+        message.reasoning &&
+        !nonStringContent.some((c) => c.type === "reasoning")
+      ) {
         assistantMessage.parts.push({
           type: "reasoning",
-          reasoning: message.reasoning,
-          details: message.reasoningDetails ?? [],
-        });
+          text: message.reasoning,
+          ...partCommon,
+        } satisfies ReasoningUIPart);
       }
-      if (message.text) {
+      if (message.text && !nonStringContent.length) {
         assistantMessage.parts.push({
           type: "text",
           text: message.text,
-        });
-        assistantMessage.content += message.text;
+          ...partCommon,
+        } satisfies TextUIPart);
       }
       for (const source of message.sources ?? []) {
-        assistantMessage.parts.push({
-          type: "source",
-          source,
-        });
+        if (source.sourceType === "url") {
+          assistantMessage.parts.push({
+            type: "source-url",
+            url: source.url!,
+            sourceId: source.id,
+            providerMetadata: message.providerMetadata,
+            title: source.title,
+          } satisfies SourceUrlUIPart);
+        } else {
+          assistantMessage.parts.push({
+            type: "source-document",
+            mediaType: source.mediaType,
+            sourceId: source.id,
+            title: source.title,
+            filename: source.filename,
+            providerMetadata: message.providerMetadata,
+          } satisfies SourceDocumentUIPart);
+        }
       }
       for (const contentPart of nonStringContent) {
         switch (contentPart.type) {
+          case "text":
+            assistantMessage.parts.push({
+              ...partCommon,
+              ...contentPart,
+            } satisfies TextUIPart);
+            break;
+          case "reasoning":
+            assistantMessage.parts.push({
+              ...partCommon,
+              ...contentPart,
+            } satisfies ReasoningUIPart);
+            break;
           case "file":
           case "image":
             assistantMessage.parts.push(toUIFilePart(contentPart));
             break;
-          case "tool-call":
+          case "tool-call": {
             assistantMessage.parts.push({
               type: "step-start",
-            });
-            assistantMessage.parts.push({
-              type: "tool-invocation",
-              toolInvocation: {
-                state: "call",
-                step: assistantMessage.parts.filter(
-                  (part) => part.type === "tool-invocation",
-                ).length,
-                toolCallId: contentPart.toolCallId,
-                toolName: contentPart.toolName,
-                args: contentPart.args,
-              },
-            });
+            } satisfies StepStartUIPart);
+            const toolPart: ToolUIPart<TOOLS> = {
+              type: `tool-${contentPart.toolName as keyof TOOLS & string}`,
+              toolCallId: contentPart.toolCallId,
+              input: contentPart.input as DeepPartial<
+                TOOLS[keyof TOOLS & string]["input"]
+              >,
+              providerExecuted: contentPart.providerExecuted,
+              ...(message.streaming
+                ? { state: "input-streaming" }
+                : {
+                    state: "input-available",
+                    callProviderMetadata: message.providerMetadata,
+                  }),
+            };
+            assistantMessage.parts.push(toolPart);
             break;
+          }
           case "tool-result": {
             const call = assistantMessage.parts.find(
               (part) =>
-                part.type === "tool-invocation" &&
-                part.toolInvocation.toolCallId === contentPart.toolCallId,
-            ) as ToolInvocationUIPart | undefined;
-            const toolInvocation: ToolInvocationUIPart["toolInvocation"] = {
-              state: "result",
-              toolCallId: contentPart.toolCallId,
-              toolName: contentPart.toolName,
-              args: call?.toolInvocation.args,
-              result: contentPart.result,
-              step:
-                call?.toolInvocation.step ??
-                assistantMessage.parts.filter(
-                  (part) => part.type === "tool-invocation",
-                ).length,
-            };
+                part.type === `tool-${contentPart.toolName}` &&
+                "toolCallId" in part &&
+                part.toolCallId === contentPart.toolCallId,
+            ) as ToolUIPart | undefined;
             if (call) {
-              (call as ToolInvocationUIPart).toolInvocation = toolInvocation;
+              if (message.error) {
+                call.state = "output-error";
+                call.errorText = message.error;
+                call.output = contentPart.output;
+              } else {
+                call.state = "output-available";
+                call.output =
+                  contentPart.output?.type === "json"
+                    ? contentPart.output.value
+                    : contentPart.output;
+                // Technically we could pull this from the doc.message
+                // but the ModelMessage doesn't have it
+                // call.providerExecuted = contentPart.providerExecuted;
+              }
             } else {
               console.warn(
                 "Tool result without preceding tool call.. adding anyways",
                 contentPart,
               );
-              assistantMessage.parts.push({
-                type: "tool-invocation",
-                toolInvocation,
-              });
+              if (message.error) {
+                assistantMessage.parts.push({
+                  type: `tool-${contentPart.toolName}`,
+                  toolCallId: contentPart.toolCallId,
+                  state: "output-error",
+                  input: undefined,
+                  errorText: message.error,
+                  // Technically we could pull this from the doc.message
+                  // but the ModelMessage doesn't have it
+                  // providerExecuted: contentPart.providerExecuted,
+                  callProviderMetadata: message.providerMetadata,
+                } satisfies ToolUIPart<TOOLS>);
+              } else {
+                assistantMessage.parts.push({
+                  type: `tool-${contentPart.toolName}`,
+                  toolCallId: contentPart.toolCallId,
+                  state: "output-available",
+                  input: undefined,
+                  output:
+                    contentPart.output?.type === "json"
+                      ? contentPart.output.value
+                      : contentPart.output,
+                  callProviderMetadata: message.providerMetadata,
+                } satisfies ToolUIPart<TOOLS>);
+              }
             }
             break;
           }

package/src/validators.test.ts

@@ -1,108 +1,11 @@
-import type {
-  TextStreamPart as AITextStreamPart,
-  AssistantContent,
-  CoreAssistantMessage,
-  CoreMessage,
-  CoreSystemMessage,
-  CoreToolMessage,
-  CoreUserMessage,
-  FilePart,
-  ImagePart,
-  TextPart,
-  ToolCallPart,
-  ToolContent,
-  ToolSet,
-  UserContent,
-} from "ai";
+import type { TextStreamPart as AITextStreamPart, ToolSet } from "ai";
 import type { Infer } from "convex/values";
 import { expectTypeOf, test } from "vitest";
 import type { ContextOptions, StorageOptions } from "./client/types.js";
-import type { SerializeUrlsAndUint8Arrays } from "./mapping.js";
 import type { TextStreamPart } from "./validators.js";
-import {
-  vAssistantContent,
-  vAssistantMessage,
-  vContextOptions,
-  vFilePart,
-  vImagePart,
-  vMessage,
-  vReasoningPart,
-  vRedactedReasoningPart,
-  vStorageOptions,
-  vSystemMessage,
-  vTextPart,
-  vToolCallPart,
-  vToolContent,
-  vToolMessage,
-  vUserContent,
-  vUserMessage,
-} from "./validators.js";
+import { vContextOptions, vStorageOptions } from "./validators.js";
 
-// type assertion
-type OurUserContent = SerializeUrlsAndUint8Arrays<UserContent>;
-expectTypeOf<OurUserContent>().toExtend<Infer<typeof vUserContent>>();
-expectTypeOf<Infer<typeof vUserContent>>().toExtend<OurUserContent>();
 
-type OurAssistantContent = SerializeUrlsAndUint8Arrays<AssistantContent>;
-expectTypeOf<OurAssistantContent>().toExtend<Infer<typeof vAssistantContent>>();
-expectTypeOf<Infer<typeof vAssistantContent>>().toExtend<OurAssistantContent>();
-
-type OurToolContent = SerializeUrlsAndUint8Arrays<ToolContent>;
-expectTypeOf<OurToolContent>().toExtend<Infer<typeof vToolContent>>();
-expectTypeOf<Infer<typeof vToolContent>>().toExtend<OurToolContent>();
-
-expectTypeOf<Infer<typeof vToolCallPart>>().toExtend<ToolCallPart>();
-expectTypeOf<ToolCallPart>().toExtend<Infer<typeof vToolCallPart>>();
-
-type OurTextPart = SerializeUrlsAndUint8Arrays<TextPart>;
-expectTypeOf<OurTextPart>().toExtend<Infer<typeof vTextPart>>();
-expectTypeOf<Infer<typeof vTextPart>>().toExtend<OurTextPart>();
-
-type OurImagePart = SerializeUrlsAndUint8Arrays<ImagePart>;
-expectTypeOf<OurImagePart>().toExtend<Infer<typeof vImagePart>>();
-expectTypeOf<Infer<typeof vImagePart>>().toExtend<OurImagePart>();
-
-type OurFilePart = SerializeUrlsAndUint8Arrays<FilePart>;
-expectTypeOf<OurFilePart>().toExtend<Infer<typeof vFilePart>>();
-expectTypeOf<Infer<typeof vFilePart>>().toExtend<OurFilePart>();
-
-// narrow to the type
-type ReasoningPart = AssistantContent[number] & { type: "reasoning" } & object;
-type OurReasoningPart = SerializeUrlsAndUint8Arrays<ReasoningPart>;
-expectTypeOf<OurReasoningPart>().toExtend<Infer<typeof vReasoningPart>>();
-expectTypeOf<Infer<typeof vReasoningPart>>().toExtend<OurReasoningPart>();
-
-// narrow to the type
-type RedactedReasoningPart = AssistantContent[number] & {
-  type: "redacted-reasoning";
-} & object;
-type OurRedactedReasoningPart =
-  SerializeUrlsAndUint8Arrays<RedactedReasoningPart>;
-expectTypeOf<OurRedactedReasoningPart>().toExtend<
-  Infer<typeof vRedactedReasoningPart>
->();
-expectTypeOf<
-  Infer<typeof vRedactedReasoningPart>
->().toExtend<OurRedactedReasoningPart>();
-
-// test("noop", () => {
-type OurUserMessage = SerializeUrlsAndUint8Arrays<CoreUserMessage>;
-expectTypeOf<OurUserMessage>().toExtend<Infer<typeof vUserMessage>>();
-expectTypeOf<Infer<typeof vUserMessage>>().toExtend<OurUserMessage>();
-
-type OurAssistantMessage = SerializeUrlsAndUint8Arrays<CoreAssistantMessage>;
-expectTypeOf<OurAssistantMessage>().toExtend<Infer<typeof vAssistantMessage>>();
-expectTypeOf<Infer<typeof vAssistantMessage>>().toExtend<OurAssistantMessage>();
-
-expectTypeOf<Infer<typeof vToolMessage>>().toExtend<CoreToolMessage>();
-expectTypeOf<CoreToolMessage>().toExtend<Infer<typeof vToolMessage>>();
-
-expectTypeOf<Infer<typeof vSystemMessage>>().toExtend<CoreSystemMessage>();
-expectTypeOf<CoreSystemMessage>().toExtend<Infer<typeof vSystemMessage>>();
-
-type OurMessage = SerializeUrlsAndUint8Arrays<CoreMessage>;
-expectTypeOf<OurMessage>().toExtend<Infer<typeof vMessage>>();
-expectTypeOf<Infer<typeof vMessage>>().toExtend<OurMessage>();
 
 expectTypeOf<Infer<typeof vContextOptions>>().toExtend<ContextOptions>();
 expectTypeOf<ContextOptions>().toExtend<Infer<typeof vContextOptions>>();

package/src/validators.ts

@@ -69,6 +69,7 @@ export const vReasoningPart = v.object({
   text: v.string(),
   signature: v.optional(v.string()),
   providerOptions,
+  state: v.optional(v.union(v.literal("streaming"), v.literal("done"))),
 });
 
 export const vRedactedReasoningPart = v.object({
@@ -79,6 +80,7 @@ export const vRedactedReasoningPart = v.object({
 
 export const vReasoningDetails = v.array(
   v.union(
+    vReasoningPart,
     v.object({
       type: v.literal("text"),
       text: v.string(),
@@ -97,6 +99,7 @@ export const vToolCallPart = v.object({
   toolName: v.string(),
   args: v.any(),
   providerOptions,
+  providerExecuted: v.optional(v.boolean()),
 });
 
 export const vAssistantContent = v.union(
@@ -126,17 +129,20 @@ const vToolResultContent = v.array(
   ),
 );
 
-const vToolResultPart = v.object({
+export const vToolResultPart = v.object({
   type: v.literal("tool-result"),
   toolCallId: v.string(),
   toolName: v.string(),
   result: v.any(),
+  providerOptions,
+  providerExecuted: v.optional(v.boolean()),
+
+  // Deprecated in ai v5
+  isError: v.optional(v.boolean()),
   // This is only here b/c steps include it in toolResults
-  // Normal CoreMessage doesn't have this
+  // Normal ModelMessage doesn't have this
   args: v.optional(v.any()),
   experimental_content: v.optional(vToolResultContent),
-  isError: v.optional(v.boolean()),
-  providerOptions,
 });
 export const vToolContent = v.array(vToolResultPart);
 
@@ -175,13 +181,25 @@ export const vMessage = v.union(
 );
 export type Message = Infer<typeof vMessage>;
 
-export const vSource = v.object({
-  sourceType: v.literal("url"),
-  id: v.string(),
-  url: v.string(),
-  title: v.optional(v.string()),
-  providerOptions,
-});
+export const vSource = v.union(
+  v.object({
+    type: v.optional(v.literal("source")),
+    sourceType: v.literal("url"),
+    id: v.string(),
+    url: v.optional(v.string()),
+    title: v.optional(v.string()),
+    providerOptions,
+  }),
+  v.object({
+    type: v.literal("source"),
+    sourceType: v.literal("document"),
+    id: v.string(),
+    mediaType: v.string(),
+    title: v.string(),
+    filename: v.optional(v.string()),
+    providerMetadata,
+  }),
+);
 
 export const vRequest = v.object({
   body: v.optional(v.any()),
@@ -228,10 +246,12 @@ export const vUsage = v.object({
   promptTokens: v.number(),
   completionTokens: v.number(),
   totalTokens: v.number(),
+  reasoningTokens: v.optional(v.number()),
+  cachedInputTokens: v.optional(v.number()),
 });
 export type Usage = Infer<typeof vUsage>;
 
-export const vLanguageModelV1CallWarning = v.union(
+export const vLanguageModelCallWarning = v.union(
   v.object({
     type: v.literal("unsupported-setting"),
     setting: v.string(),
@@ -262,7 +282,7 @@ export const vMessageWithMetadataInternal = v.object({
   reasoning: v.optional(v.string()),
   reasoningDetails: v.optional(vReasoningDetails),
   usage: v.optional(vUsage),
-  warnings: v.optional(v.array(vLanguageModelV1CallWarning)),
+  warnings: v.optional(v.array(vLanguageModelCallWarning)),
   error: v.optional(v.string()),
 });
 export const vMessageWithMetadata = v.object({
@@ -285,7 +305,7 @@ export const vObjectResult = v.object({
   usage: v.optional(v.any()),
   object: v.any(),
   error: v.optional(v.string()),
-  warnings: v.optional(v.array(vLanguageModelV1CallWarning)),
+  warnings: v.optional(v.array(vLanguageModelCallWarning)),
   providerMetadata,
 });
 export type ObjectResult = Infer<typeof vObjectResult>;
@@ -388,7 +408,7 @@ export function vPaginationResult<
   });
 }
 
-export const vTextStreamPart = v.union(
+export const vTextStreamPartV4 = v.union(
   v.object({
     type: v.literal("text-delta"),
     textDelta: v.string(),
@@ -399,9 +419,16 @@ export const vTextStreamPart = v.union(
   }),
   v.object({
     type: v.literal("source"),
-    source: vSource,
+    source: v.object({
+      sourceType: v.literal("url"),
+      id: v.string(),
+      url: v.optional(v.string()),
+      title: v.optional(v.string()),
+      providerOptions,
+    }),
   }),
   vToolCallPart,
+  vToolResultPart,
   v.object({
     type: v.literal("tool-call-streaming-start"),
     toolCallId: v.string(),
@@ -413,8 +440,59 @@ export const vTextStreamPart = v.union(
     toolName: v.string(),
     argsTextDelta: v.string(),
   }),
-  vToolResultPart,
 );
+export const vTextStreamPartV5 = v.union(
+  v.object({
+    type: v.literal("text-delta"),
+    id: v.string(),
+    text: v.string(),
+    providerMetadata,
+  }),
+  v.object({
+    type: v.literal("reasoning-delta"),
+    id: v.string(),
+    text: v.string(),
+    providerMetadata,
+  }),
+  vSource,
+  v.object({
+    type: v.literal("tool-call"),
+    toolCallId: v.string(),
+    toolName: v.string(),
+    input: v.any(),
+    providerExecuted: v.optional(v.boolean()),
+    dynamic: v.optional(v.boolean()),
+    providerMetadata,
+  }),
+  v.object({
+    type: v.literal("tool-input-start"),
+    id: v.string(),
+    toolName: v.string(),
+    providerMetadata,
+    providerExecuted: v.optional(v.boolean()),
+    dynamic: v.optional(v.boolean()),
+  }),
+  v.object({
+    type: v.literal("tool-input-delta"),
+    id: v.string(),
+    delta: v.string(),
+    providerMetadata,
+  }),
+  v.object({
+    type: v.literal("tool-result"),
+    toolCallId: v.string(),
+    toolName: v.string(),
+    input: v.optional(v.any()),
+    output: v.optional(v.any()),
+    providerExecuted: v.optional(v.boolean()),
+    dynamic: v.optional(v.boolean()),
+  }),
+  v.object({
+    type: v.literal("raw"),
+    rawValue: v.any(),
+  }),
+);
+export const vTextStreamPart = v.union(vTextStreamPartV4, vTextStreamPartV5);
 export type TextStreamPart = Infer<typeof vTextStreamPart>;
 
 export const vStreamCursor = v.object({