@convex-dev/agent 0.1.1 → 0.1.2-alpha.0

package/src/react/toUIMessages.ts

@@ -0,0 +1,153 @@
+import { UIMessage } from "ai";
+import type { ToolInvocationUIPart } from "@ai-sdk/ui-utils";
+import { MessageDoc } from "../client";
+import { deserializeMessage, toUIFilePart } from "../mapping";
+
+export type UIMessageOrdered = UIMessage & {
+  order: number;
+  stepOrder: number;
+};
+
+export function toUIMessages(messages: MessageDoc[]): UIMessageOrdered[] {
+  const uiMessages: UIMessageOrdered[] = [];
+  let assistantMessage: UIMessageOrdered | undefined;
+  for (const message of messages) {
+    const coreMessage = message.message && deserializeMessage(message.message);
+    const text = message.text ?? "";
+    const content = coreMessage?.content;
+    const nonStringContent =
+      content && typeof content !== "string" ? content : [];
+    if (!coreMessage) continue;
+    if (coreMessage.role === "system") {
+      uiMessages.push({
+        id: message.id ?? message._id,
+        createdAt: new Date(message._creationTime),
+        role: "system",
+        content: text,
+        parts: [{ type: "text", text }],
+        order: message.order,
+        stepOrder: message.stepOrder,
+      });
+    } else if (coreMessage.role === "user") {
+      const parts: UIMessage["parts"] = [];
+      if (text) {
+        parts.push({ type: "text", text });
+      }
+      if (message.files) {
+        parts.push(...message.files.map(toUIFilePart));
+      }
+      uiMessages.push({
+        id: message.id ?? message._id,
+        createdAt: new Date(message._creationTime),
+        role: "user",
+        content: message.text ?? "",
+        parts,
+        order: message.order,
+        stepOrder: message.stepOrder,
+      });
+    } else {
+      if (coreMessage.role === "tool" && !assistantMessage) {
+        console.warn(
+          "Tool message without preceding assistant message.. skipping",
+          message
+        );
+        continue;
+      }
+      if (!assistantMessage) {
+        assistantMessage = {
+          id: message.id ?? message._id,
+          createdAt: new Date(message._creationTime),
+          role: "assistant",
+          content: message.text ?? "",
+          parts: [],
+          order: message.order,
+          stepOrder: message.stepOrder,
+        };
+        uiMessages.push(assistantMessage);
+      }
+      // update it to the last message's id
+      assistantMessage.id = message.id ?? message._id;
+      if (message.text) {
+        assistantMessage.parts.push({
+          type: "text",
+          text: message.text,
+        });
+        assistantMessage.content += message.text;
+      }
+      if (message.reasoning) {
+        assistantMessage.parts.push({
+          type: "reasoning",
+          reasoning: message.reasoning,
+          details: message.reasoningDetails ?? [],
+        });
+      }
+      for (const source of message.sources ?? []) {
+        assistantMessage.parts.push({
+          type: "source",
+          source,
+        });
+      }
+      for (const file of message.files ?? []) {
+        assistantMessage.parts.push(toUIFilePart(file));
+      }
+      for (const contentPart of nonStringContent) {
+        switch (contentPart.type) {
+          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,
+              },
+            });
+            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,
+            };
+            if (call) {
+              (call as ToolInvocationUIPart).toolInvocation = toolInvocation;
+            } else {
+              console.warn(
+                "Tool result without preceding tool call.. adding anyways",
+                contentPart
+              );
+              assistantMessage.parts.push({
+                type: "tool-invocation",
+                toolInvocation,
+              });
+            }
+            break;
+          }
+        }
+      }
+    }
+    if (!message.tool) {
+      // Reset it so the next set of tool calls will create a new assistant message
+      assistantMessage = undefined;
+    }
+  }
+  return uiMessages;
+}

package/src/validators.test.ts

@@ -18,6 +18,7 @@ import {
   vUserMessage,
 } from "./validators";
 import { vUserContent } from "./validators";
+import type { TextStreamPart } from "./validators";
 import {
   AssistantContent,
   CoreAssistantMessage,
@@ -28,8 +29,10 @@ import {
   FilePart,
   ImagePart,
   TextPart,
+  TextStreamPart as AITextStreamPart,
   ToolCallPart,
   ToolContent,
+  ToolSet,
   UserContent,
 } from "ai";
 import { SerializeUrlsAndUint8Arrays } from "./mapping";
@@ -107,4 +110,19 @@ expectTypeOf<ContextOptions>().toExtend<Infer<typeof vContextOptions>>();
 expectTypeOf<Infer<typeof vStorageOptions>>().toExtend<StorageOptions>();
 expectTypeOf<StorageOptions>().toExtend<Infer<typeof vStorageOptions>>();
 
+type StreamPart = Extract<
+  AITextStreamPart<ToolSet>,
+  {
+    type:
+      | "text-delta"
+      | "reasoning"
+      | "source"
+      | "tool-call"
+      | "tool-call-streaming-start"
+      | "tool-call-delta"
+      | "tool-result";
+  }
+>;
+expectTypeOf<StreamPart>().toExtend<TextStreamPart>();
+
 test("noop", () => { });

package/src/validators.ts

@@ -355,6 +355,7 @@ const vPromptFields = {
   system: v.optional(v.string()),
   prompt: v.optional(v.string()),
   messages: v.optional(v.array(vMessage)),
+  promptMessageId: v.optional(v.string()),
 };
 
 export const vCallSettingsFields = {
@@ -382,6 +383,7 @@ const vCommonArgs = {
 
 export const vTextArgs = v.object({
   ...vCommonArgs,
+  stream: v.optional(v.boolean()),
   toolChoice: v.optional(
     v.union(
       v.literal("auto"),
@@ -395,7 +397,6 @@ export const vTextArgs = v.object({
   ),
   maxSteps: v.optional(v.number()),
   experimental_continueSteps: v.optional(v.boolean()),
-  providerOptions,
 });
 export type TextArgs = Infer<typeof vTextArgs>;
 
@@ -409,7 +410,7 @@ export const vEmbeddingsWithMetadata = v.object({
 });
 export type EmbeddingsWithMetadata = Infer<typeof vEmbeddingsWithMetadata>;
 
-export function paginationResultValidator<
+export function vPaginationResult<
   T extends Validator<Value, "required", string>,
 >(itemValidator: T) {
   return v.object({
@@ -426,3 +427,72 @@ export function paginationResultValidator<
     ),
   });
 }
+
+export const vTextStreamPart = v.union(
+  v.object({
+    type: v.literal("text-delta"),
+    textDelta: v.string(),
+  }),
+  v.object({
+    type: v.literal("reasoning"),
+    textDelta: v.string(),
+  }),
+  v.object({
+    type: v.literal("source"),
+    source: vSource,
+  }),
+  vToolCallPart,
+  v.object({
+    type: v.literal("tool-call-streaming-start"),
+    toolCallId: v.string(),
+    toolName: v.string(),
+  }),
+  v.object({
+    type: v.literal("tool-call-delta"),
+    toolCallId: v.string(),
+    toolName: v.string(),
+    argsTextDelta: v.string(),
+  }),
+  vToolResultPart
+);
+export type TextStreamPart = Infer<typeof vTextStreamPart>;
+
+export const vStreamCursor = v.object({
+  streamId: v.string(),
+  cursor: v.number(),
+});
+export type StreamCursor = Infer<typeof vStreamCursor>;
+
+export const vStreamArgs = v.optional(
+  v.union(
+    v.object({
+      kind: v.literal("list"),
+    }),
+    v.object({
+      kind: v.literal("deltas"),
+      cursors: v.array(vStreamCursor),
+    })
+  )
+);
+export type StreamArgs = Infer<typeof vStreamArgs>;
+
+export const vStreamMessage = v.object({
+  streamId: v.string(),
+  order: v.number(),
+  stepOrder: v.number(),
+  // metadata
+  userId: v.optional(v.string()),
+  agentName: v.optional(v.string()),
+  model: v.optional(v.string()),
+  provider: v.optional(v.string()),
+  providerOptions: v.optional(vProviderOptions), // Sent to model
+});
+export type StreamMessage = Infer<typeof vStreamMessage>;
+
+export const vStreamDelta = v.object({
+  streamId: v.string(),
+  start: v.number(), // inclusive
+  end: v.number(), // exclusive
+  parts: v.array(vTextStreamPart),
+});
+export type StreamDelta = Infer<typeof vStreamDelta>;