@convex-dev/agent 0.3.2 → 0.6.0-alpha.0

package/src/mapping.ts

@@ -25,7 +25,6 @@ import {
   type Message,
   type MessageWithMetadata,
   type Usage,
-  type vContent,
   type vFilePart,
   type vImagePart,
   type vReasoningPart,
@@ -36,6 +35,8 @@ import {
   type SourcePart,
   vToolResultOutput,
   type MessageDoc,
+  vToolApprovalRequest,
+  vToolApprovalResponse,
 } from "./validators.js";
 import type { ActionCtx, AgentComponent } from "./client/types.js";
 import type { MutationCtx } from "./client/types.js";
@@ -155,6 +156,17 @@ export function toModelMessageUsage(usage: Usage): LanguageModelUsage {
     totalTokens: usage.totalTokens,
     reasoningTokens: usage.reasoningTokens,
     cachedInputTokens: usage.cachedInputTokens,
+    // These detail fields are required by LanguageModelUsage type but we don't
+    // have the granular data, so we provide empty objects with undefined values.
+    inputTokenDetails: {
+      cacheReadTokens: undefined,
+      cacheWriteTokens: undefined,
+      noCacheTokens: undefined,
+    },
+    outputTokenDetails: {
+      textTokens: undefined,
+      reasoningTokens: undefined,
+    },
   };
 }
 
@@ -165,18 +177,33 @@ export function serializeWarnings(
     return undefined;
   }
   return warnings.map((warning) => {
-    if (warning.type !== "unsupported-setting") {
-      return warning;
+    if (warning.type === "compatibility") {
+      return {
+        type: "unsupported-setting",
+        setting: warning.feature,
+        details: warning.details,
+      };
     }
-    return { ...warning, setting: warning.setting.toString() };
-  });
+    return warning;
+  }) as any;
 }
 
 export function toModelMessageWarnings(
   warnings: MessageWithMetadata["warnings"],
 ): CallWarning[] | undefined {
-  // We don't need to do anythign here for now
-  return warnings;
+  if (!warnings) {
+    return undefined;
+  }
+  return warnings.map((warning) => {
+    if (warning.type === "unsupported-setting") {
+      return {
+        type: "compatibility",
+        feature: warning.setting,
+        details: warning.details,
+      };
+    }
+    return warning;
+  }) as any;
 }
 
 export async function serializeNewMessagesInStep<TOOLS extends ToolSet>(
@@ -307,7 +334,7 @@ export async function serializeContent(
           }
           return {
             type: part.type,
-            mimeType: getMimeOrMediaType(part),
+            mediaType: getMimeOrMediaType(part),
             ...metadata,
             image,
           } satisfies Infer<typeof vImagePart>;
@@ -327,15 +354,18 @@ export async function serializeContent(
             type: part.type,
             data,
             filename: part.filename,
-            mimeType: getMimeOrMediaType(part)!,
+            mediaType: getMimeOrMediaType(part)!,
             ...metadata,
           } satisfies Infer<typeof vFilePart>;
         }
         case "tool-call": {
-          const args = "input" in part ? part.input : part.args;
+          // Handle legacy data where only args field exists
+          const input = part.input ?? (part as any)?.args ?? {};
           return {
             type: part.type,
-            args: args ?? null,
+            input,
+            /** @deprecated Use `input` instead. */
+            args: input,
             toolCallId: part.toolCallId,
             toolName: part.toolName,
             providerExecuted: part.providerExecuted,
@@ -363,13 +393,31 @@ export async function serializeContent(
         case "source": {
           return part satisfies Infer<typeof vSourcePart>;
         }
+        case "tool-approval-request": {
+          return {
+            type: part.type,
+            approvalId: part.approvalId,
+            toolCallId: part.toolCallId,
+            ...metadata,
+          } satisfies Infer<typeof vToolApprovalRequest>;
+        }
+        case "tool-approval-response": {
+          return {
+            type: part.type,
+            approvalId: part.approvalId,
+            approved: part.approved,
+            reason: part.reason,
+            providerExecuted: part.providerExecuted,
+            ...metadata,
+          } satisfies Infer<typeof vToolApprovalResponse>;
+        }
         default:
-          return part satisfies Infer<typeof vContent>;
+          return null;
       }
     }),
   );
   return {
-    content: serialized as SerializedContent,
+    content: serialized.filter((p) => p !== null) as SerializedContent,
     fileIds: fileIds.length > 0 ? fileIds : undefined,
   };
 }
@@ -378,57 +426,78 @@ export function fromModelMessageContent(content: Content): Message["content"] {
   if (typeof content === "string") {
     return content;
   }
-  return content.map((part) => {
-    const metadata: {
-      providerOptions?: ProviderOptions;
-      providerMetadata?: ProviderMetadata;
-    } = {};
-    if ("providerOptions" in part) {
-      metadata.providerOptions = part.providerOptions as ProviderOptions;
-    }
-    if ("providerMetadata" in part) {
-      metadata.providerMetadata = part.providerMetadata as ProviderMetadata;
-    }
-    switch (part.type) {
-      case "text":
-        return part satisfies Infer<typeof vTextPart>;
-      case "image":
-        return {
-          type: part.type,
-          mimeType: getMimeOrMediaType(part),
-          ...metadata,
-          image: serializeDataOrUrl(part.image),
-        } satisfies Infer<typeof vImagePart>;
-      case "file":
-        return {
-          type: part.type,
-          data: serializeDataOrUrl(part.data),
-          filename: part.filename,
-          mimeType: getMimeOrMediaType(part)!,
-          ...metadata,
-        } satisfies Infer<typeof vFilePart>;
-      case "tool-call":
-        return {
-          type: part.type,
-          args: part.input ?? null,
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          providerExecuted: part.providerExecuted,
-          ...metadata,
-        } satisfies Infer<typeof vToolCallPart>;
-      case "tool-result":
-        return normalizeToolResult(part, metadata);
-      case "reasoning":
-        return {
-          type: part.type,
-          text: part.text,
-          ...metadata,
-        } satisfies Infer<typeof vReasoningPart>;
-      // Not in current generation output, but could be in historical messages
-      default:
-        return part satisfies Infer<typeof vContent>;
-    }
-  }) as Message["content"];
+  return content
+    .map((part) => {
+      const metadata: {
+        providerOptions?: ProviderOptions;
+        providerMetadata?: ProviderMetadata;
+      } = {};
+      if ("providerOptions" in part) {
+        metadata.providerOptions = part.providerOptions as ProviderOptions;
+      }
+      if ("providerMetadata" in part) {
+        metadata.providerMetadata = part.providerMetadata as ProviderMetadata;
+      }
+      switch (part.type) {
+        case "text":
+          return part satisfies Infer<typeof vTextPart>;
+        case "image":
+          return {
+            type: part.type,
+            mediaType: getMimeOrMediaType(part),
+            ...metadata,
+            image: serializeDataOrUrl(part.image),
+          } satisfies Infer<typeof vImagePart>;
+        case "file":
+          return {
+            type: part.type,
+            data: serializeDataOrUrl(part.data),
+            filename: part.filename,
+            mediaType: getMimeOrMediaType(part)!,
+            ...metadata,
+          } satisfies Infer<typeof vFilePart>;
+        case "tool-call":
+          // Handle legacy data where only args field exists
+          return {
+            type: part.type,
+            input: part.input ?? (part as any)?.args ?? {},
+            /** @deprecated Use `input` instead. */
+            args: part.input ?? (part as any)?.args ?? {},
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            providerExecuted: part.providerExecuted,
+            ...metadata,
+          } satisfies Infer<typeof vToolCallPart>;
+        case "tool-result":
+          return normalizeToolResult(part, metadata);
+        case "reasoning":
+          return {
+            type: part.type,
+            text: part.text,
+            ...metadata,
+          } satisfies Infer<typeof vReasoningPart>;
+        case "tool-approval-request":
+          return {
+            type: part.type,
+            approvalId: part.approvalId,
+            toolCallId: part.toolCallId,
+            ...metadata,
+          } satisfies Infer<typeof vToolApprovalRequest>;
+        case "tool-approval-response":
+          return {
+            type: part.type,
+            approvalId: part.approvalId,
+            approved: part.approved,
+            reason: part.reason,
+            providerExecuted: part.providerExecuted,
+            ...metadata,
+          } satisfies Infer<typeof vToolApprovalResponse>;
+        // Not in current generation output, but could be in historical messages
+        default:
+          return null;
+      }
+    })
+    .filter((p) => p !== null) as Message["content"];
 }
 
 export function toModelMessageContent(
@@ -437,84 +506,103 @@ export function toModelMessageContent(
   if (typeof content === "string") {
     return content;
   }
-  return content.map((part) => {
-    const metadata: {
-      providerOptions?: ProviderOptions;
-      providerMetadata?: ProviderMetadata;
-    } = {};
-    if ("providerOptions" in part) {
-      metadata.providerOptions = part.providerOptions;
-    }
-    if ("providerMetadata" in part) {
-      metadata.providerMetadata = part.providerMetadata;
-    }
-    switch (part.type) {
-      case "text":
-        return {
-          type: part.type,
-          text: part.text,
-          ...metadata,
-        } satisfies TextPart;
-      case "image":
-        return {
-          type: part.type,
-          image: toModelMessageDataOrUrl(part.image),
-          mediaType: getMimeOrMediaType(part),
-          ...metadata,
-        } satisfies ImagePart;
-      case "file":
-        return {
-          type: part.type,
-          data: toModelMessageDataOrUrl(part.data),
-          filename: part.filename,
-          mediaType: getMimeOrMediaType(part)!,
-          ...metadata,
-        } satisfies FilePart;
-      case "tool-call": {
-        const input = "input" in part ? part.input : part.args;
-        return {
-          type: part.type,
-          input: input ?? null,
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          providerExecuted: part.providerExecuted,
-          ...metadata,
-        } satisfies ToolCallPart;
+  return content
+    .map((part) => {
+      const metadata: {
+        providerOptions?: ProviderOptions;
+        providerMetadata?: ProviderMetadata;
+      } = {};
+      if ("providerOptions" in part) {
+        metadata.providerOptions = part.providerOptions;
       }
-      case "tool-result": {
-        return normalizeToolResult(part, metadata);
+      if ("providerMetadata" in part) {
+        metadata.providerMetadata = part.providerMetadata;
       }
-      case "reasoning":
-        return {
-          type: part.type,
-          text: part.text,
-          ...metadata,
-        } satisfies ReasoningPart;
-      case "redacted-reasoning":
-        // TODO: should we just drop this?
-        return {
-          type: "reasoning",
-          text: "",
-          ...metadata,
-          providerOptions: metadata.providerOptions
-            ? {
-                ...Object.fromEntries(
-                  Object.entries(metadata.providerOptions ?? {}).map(
-                    ([key, value]) => [
-                      key,
-                      { ...value, redactedData: part.data },
-                    ],
+      switch (part.type) {
+        case "text":
+          return {
+            type: part.type,
+            text: part.text,
+            ...metadata,
+          } satisfies TextPart;
+        case "image":
+          return {
+            type: part.type,
+            image: toModelMessageDataOrUrl(part.image),
+            mediaType: getMimeOrMediaType(part),
+            ...metadata,
+          } satisfies ImagePart;
+        case "file":
+          return {
+            type: part.type,
+            data: toModelMessageDataOrUrl(part.data),
+            filename: part.filename,
+            mediaType: getMimeOrMediaType(part)!,
+            ...metadata,
+          } satisfies FilePart;
+        case "tool-call": {
+          // Handle legacy data where only args field exists
+          const input = part.input ?? (part as any)?.args ?? {};
+          return {
+            type: part.type,
+            input,
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            providerExecuted: part.providerExecuted,
+            ...metadata,
+          } satisfies ToolCallPart;
+        }
+        case "tool-result": {
+          return normalizeToolResult(part, metadata);
+        }
+        case "reasoning":
+          return {
+            type: part.type,
+            text: part.text,
+            ...metadata,
+          } satisfies ReasoningPart;
+        case "redacted-reasoning":
+          // TODO: should we just drop this?
+          return {
+            type: "reasoning",
+            text: "",
+            ...metadata,
+            providerOptions: metadata.providerOptions
+              ? {
+                  ...Object.fromEntries(
+                    Object.entries(metadata.providerOptions ?? {}).map(
+                      ([key, value]) => [
+                        key,
+                        { ...value, redactedData: part.data },
+                      ],
+                    ),
                   ),
-                ),
-              }
-            : undefined,
-        } satisfies ReasoningPart;
-      case "source":
-        return part satisfies SourcePart;
-      default:
-        return part satisfies Content;
-    }
-  }) as Content;
+                }
+              : undefined,
+          } satisfies ReasoningPart;
+        case "source":
+          return part satisfies SourcePart;
+        case "tool-approval-request":
+          return {
+            type: part.type,
+            approvalId: part.approvalId,
+            toolCallId: part.toolCallId,
+            ...metadata,
+          } satisfies Infer<typeof vToolApprovalRequest>;
+        case "tool-approval-response":
+          return {
+            type: part.type,
+            approvalId: part.approvalId,
+            approved: part.approved,
+            reason: part.reason,
+            providerExecuted: part.providerExecuted,
+            ...metadata,
+          } satisfies Infer<typeof vToolApprovalResponse>;
+        default:
+          return null;
+      }
+    })
+    .filter((p) => p !== null) as Content;
 }
 
 export function normalizeToolOutput(
@@ -544,11 +632,15 @@ function normalizeToolResult(
 ): ToolResultPart & Infer<typeof vToolResultPart> {
   return {
     type: part.type,
-    output:
-      part.output ??
-      normalizeToolOutput("result" in part ? part.result : undefined),
+    output: part.output
+      ? validate(vToolResultOutput, part.output)
+        ? (part.output as any)
+        : normalizeToolOutput(JSON.stringify(part.output))
+      : normalizeToolOutput("result" in part ? part.result : undefined),
     toolCallId: part.toolCallId,
     toolName: part.toolName,
+    // Preserve isError flag for error reporting
+    ...("isError" in part && part.isError ? { isError: true } : {}),
     ...metadata,
   } satisfies ToolResultPart;
 }

package/src/react/useThreadMessages.ts

@@ -16,7 +16,7 @@ import type {
   PaginationOptions,
   PaginationResult,
 } from "convex/server";
-import { useMemo } from "react";
+import { useMemo, useState, useEffect, useRef } from "react";
 import type { SyncStreamsReturnValue } from "../client/types.js";
 import { sorted } from "../shared.js";
 import { fromUIMessages } from "../UIMessages.js";
@@ -239,12 +239,24 @@ export function useStreamingThreadMessages<Query extends StreamQuery<any>>(
     args === "skip" ? undefined : (args.startOrder ?? undefined);
   const queryOptions = { startOrder, ...options };
   const uiMessages = useStreamingUIMessages(query, queryArgs, queryOptions);
-  if (args === "skip") {
-    return undefined;
-  }
-  // TODO: we aren't passing through as much metadata as we could here.
-  // We could share the stream metadata logic with useStreamingUIMessages.
-  return uiMessages
-    ?.map((m) => fromUIMessages([m], { threadId: args.threadId }))
-    .flat();
+  const [messages, setMessages] = useState<Array<MessageDoc> | undefined>();
+  const generationRef = useRef(0);
+
+  useEffect(() => {
+    if (args === "skip" || !uiMessages) {
+      setMessages(undefined);
+      return;
+    }
+    const currentGeneration = ++generationRef.current;
+    (async () => {
+      const nested = await Promise.all(
+        uiMessages.map((m) => fromUIMessages([m], { threadId: args.threadId })),
+      );
+      if (generationRef.current === currentGeneration) {
+        setMessages(nested.flat());
+      }
+    })();
+  }, [uiMessages, args === "skip" ? undefined : args.threadId]);
+
+  return messages;
 }

package/src/shared.ts

@@ -4,6 +4,7 @@ import type {
   ReasoningPart,
   ToolCallPart,
   ToolResultPart,
+  ToolApprovalRequest,
 } from "@ai-sdk/provider-utils";
 import type {
   ModelMessage,
@@ -55,6 +56,7 @@ export function joinText(
     | ToolCallPart
     | ToolResultPart
     | MessageContentParts
+    | ToolApprovalRequest
   )[],
 ) {
   return parts