@convex-dev/agent 0.2.0-alpha.2 → 0.2.0

package/src/react/deltas.ts

@@ -1,12 +1,11 @@
+import type { TextStreamPart, ToolSet } from "ai";
 import type { MessageDoc } from "../client/index.js";
 import type {
   Message,
   MessageStatus,
   StreamDelta,
   StreamMessage,
-  TextStreamPart,
   vReasoningPart,
-  vSource,
   vTextPart,
   vToolCallPart,
   vToolResultPart,
@@ -74,7 +73,7 @@ export function applyDeltasToStreamMessage(
 ): [{ streamId: string; cursor: number; messages: MessageDoc[] }, boolean] {
   let changed = false;
   let cursor = existing?.cursor ?? 0;
-  let parts: TextStreamPart[] = [];
+  let parts: TextStreamPart<ToolSet>[] = [];
   for (const delta of deltas.sort((a, b) => a.start - b.start)) {
     if (delta.parts.length === 0) {
       console.warn(`Got delta with no parts: ${JSON.stringify(delta)}`);
@@ -162,7 +161,7 @@ export function applyDeltasToStreamMessage(
     }
     switch (part.type) {
       case "text-delta": {
-        const text = "text" in part ? part.text : part.textDelta;
+        const text = part.text;
         currentMessage.text = (currentMessage.text ?? "") + text;
         if (lastContent?.type === "text") {
           lastContent.text = (lastContent.text ?? "") + text;
@@ -173,9 +172,8 @@ export function applyDeltasToStreamMessage(
         }
         break;
       }
-      case "tool-input-start":
-      case "tool-call-streaming-start": {
-        const toolCallId = "toolCallId" in part ? part.toolCallId : part.id;
+      case "tool-input-start": {
+        const toolCallId = part.id;
         currentMessage.tool = true;
         contentToAdd = {
           type: "tool-call",
@@ -189,7 +187,6 @@ export function applyDeltasToStreamMessage(
         } satisfies Infer<typeof vToolCallPart>;
         break;
       }
-      case "tool-call-delta":
       case "tool-input-delta":
         {
           currentMessage.tool = true;
@@ -213,18 +210,6 @@ export function applyDeltasToStreamMessage(
         contentToAdd = toolResultContent(part);
         break;
       }
-      case "reasoning":
-        currentMessage.reasoning =
-          (currentMessage.reasoning ?? "") + part.textDelta;
-        if (lastContent?.type === "reasoning") {
-          lastContent.text = (lastContent.text ?? "") + part.textDelta;
-        } else {
-          contentToAdd = {
-            type: "reasoning",
-            text: part.textDelta,
-          };
-        }
-        break;
       case "reasoning-delta": {
         currentMessage.reasoning = (currentMessage.reasoning ?? "") + part.text;
         if (lastContent?.type === "reasoning") {
@@ -244,17 +229,10 @@ export function applyDeltasToStreamMessage(
         if (!currentMessage.sources) {
           currentMessage.sources = [];
         }
-        if ("source" in part) {
-          currentMessage.sources.push({
-            type: "source",
-            ...part.source,
-          } satisfies Infer<typeof vSource>);
-        } else {
-          currentMessage.sources.push(part);
-        }
+        currentMessage.sources.push(part);
         break;
       case "raw":
-        contentToAdd = part.rawValue;
+        // ignore
         break;
       default:
         console.warn(`Received unexpected part: ${JSON.stringify(part)}`);
@@ -276,7 +254,7 @@ export function applyDeltasToStreamMessage(
 }
 
 function toolCallContent(
-  part: Extract<TextStreamPart, { type: "tool-call" }>,
+  part: Extract<TextStreamPart<ToolSet>, { type: "tool-call" }>,
 ): Infer<typeof vToolCallPart> {
   const args = "args" in part ? part.args : part.input;
   return {
@@ -289,18 +267,14 @@ function toolCallContent(
 }
 
 function toolResultContent(
-  part: Extract<TextStreamPart, { type: "tool-result" }>,
+  part: Extract<TextStreamPart<ToolSet>, { type: "tool-result" }>,
 ): Infer<typeof vToolResultPart> {
-  const result =
-    "output" in part ? part.output : "result" in part ? part.result : undefined;
-  const args =
-    "input" in part ? part.input : "args" in part ? part.args : undefined;
   return {
     type: "tool-result",
     toolCallId: part.toolCallId,
     toolName: part.toolName,
-    result,
-    args,
+    result: part.output,
+    args: part.input,
     providerExecuted: part.providerExecuted,
   } satisfies Infer<typeof vToolResultPart>;
 }
@@ -344,7 +318,7 @@ function statusFromStreamStatus(
 export function createStreamingMessage(
   threadId: string,
   message: StreamMessage,
-  part: TextStreamPart,
+  part: TextStreamPart<ToolSet>,
   index: number,
 ): MessageDoc {
   const { streamId, ...rest } = message;
@@ -358,19 +332,14 @@ export function createStreamingMessage(
   };
   switch (part.type) {
     case "text-delta": {
-      const text = "text" in part ? part.text : part.textDelta;
+      const text = part.text || "";
       return {
         ...metadata,
-        message: {
-          role: "assistant",
-          content: [{ type: "text", text }],
-        },
+        message: { role: "assistant", content: [{ type: "text", text }] },
         text,
       };
     }
-    case "tool-input-start":
-    case "tool-call-streaming-start": {
-      const toolCallId = "toolCallId" in part ? part.toolCallId : part.id;
+    case "tool-input-start": {
       return {
         ...metadata,
         tool: true,
@@ -380,7 +349,7 @@ export function createStreamingMessage(
             {
               type: "tool-call",
               toolName: part.toolName,
-              toolCallId,
+              toolCallId: part.id,
               args: "", // when it's a string, it's a partial call
               providerExecuted:
                 "providerExecuted" in part ? part.providerExecuted : undefined,
@@ -391,26 +360,17 @@ export function createStreamingMessage(
         },
       };
     }
-    case "tool-input-delta":
-    case "tool-call-delta": {
+    case "tool-input-delta": {
       console.warn("Received tool call delta part first??");
-      const delta = "argsTextDelta" in part ? part.argsTextDelta : part.delta;
-      const toolCallId = "toolCallId" in part ? part.toolCallId : part.id;
-      const toolName =
-        "toolName" in part ? part.toolName : part.type.slice("tool-".length);
+      const delta = part.delta;
+      const toolCallId = part.id;
+      const toolName = part.type.slice("tool-".length);
       return {
         ...metadata,
         tool: true,
         message: {
           role: "assistant",
-          content: [
-            {
-              type: "tool-call",
-              toolCallId,
-              toolName,
-              args: delta,
-            },
-          ],
+          content: [{ type: "tool-call", toolCallId, toolName, args: delta }],
         },
       };
     }
@@ -418,29 +378,14 @@ export function createStreamingMessage(
       return {
         ...metadata,
         tool: true,
-        message: {
-          role: "assistant",
-          content: [toolCallContent(part)],
-        },
+        message: { role: "assistant", content: [toolCallContent(part)] },
       };
     }
     case "tool-result":
       return {
         ...metadata,
         tool: true,
-        message: {
-          role: "tool",
-          content: [toolResultContent(part)],
-        },
-      };
-    case "reasoning":
-      return {
-        ...metadata,
-        message: {
-          role: "assistant",
-          content: [{ type: "reasoning", text: part.textDelta }],
-        },
-        reasoning: part.textDelta,
+        message: { role: "tool", content: [toolResultContent(part)] },
       };
     case "reasoning-delta": {
       return {
@@ -458,14 +403,7 @@ export function createStreamingMessage(
         ...metadata,
         tool: true,
         message: { role: "tool", content: [] },
-        sources: [
-          "source" in part
-            ? {
-                ...part.source,
-                type: "source",
-              }
-            : part,
-        ],
+        sources: [part],
       };
     // case "raw":
     //   return {

package/src/react/index.ts

@@ -7,7 +7,7 @@ import {
 } from "convex/react";
 import { usePaginatedQuery } from "convex-helpers/react";
 import type { FunctionArgs } from "convex/server";
-import { useMemo, useRef, useState } from "react";
+import { useMemo, useState } from "react";
 import type { MessageDoc } from "../client/index.js";
 import type { SyncStreamsReturnValue } from "../client/types.js";
 import type { StreamArgs } from "../validators.js";
@@ -23,6 +23,7 @@ import type {
 
 export { optimisticallySendMessage } from "./optimisticallySendMessage.js";
 export { useSmoothText } from "./useSmoothText.js";
+export { SmoothText } from "./SmoothText.js";
 export { toUIMessages, type UIMessage, type ThreadQuery };
 
 /**
@@ -97,6 +98,15 @@ export function useThreadMessages<
     { initialNumItems: options.initialNumItems },
   );
 
+  let startOrder = paginated.results.at(-1)?.order ?? 0;
+  for (let i = paginated.results.length - 1; i >= 0; i--) {
+    const m = paginated.results[i];
+    if (!m.streaming && m.status === "pending") {
+      // round down to the nearest 10 for some cache benefits
+      startOrder = m.order - (m.order % 10);
+      break;
+    }
+  }
   // These are streaming messages that will not include full messages.
   const streamMessages = useStreamingThreadMessages(
     query as ThreadStreamQuery<
@@ -107,7 +117,7 @@ export function useThreadMessages<
       args === "skip" ||
       paginated.status === "LoadingFirstPage"
       ? "skip"
-      : { ...args, startOrder: paginated.results.at(-1)?.order },
+      : { ...args, startOrder },
   );
 
   const merged = useMemo(() => {
@@ -120,16 +130,32 @@ export function useThreadMessages<
       ...paginated,
       results: paginated.results
         .map((m) => ({ ...m, streaming: false }))
+        // Note: this is intentionally after paginated results.
         .concat(streamListMessages)
         .sort((a, b) =>
           a.order === b.order ? a.stepOrder - b.stepOrder : a.order - b.order,
         )
-        // They shouldn't overlap, but check for duplicates just in case.
-        .filter(
-          (m, i, arr) =>
-            !arr[i - 1] ||
-            m.order !== arr[i - 1].order ||
-            m.stepOrder !== arr[i - 1].stepOrder,
+        .reduce(
+          (msgs, msg) => {
+            const last = msgs.at(-1);
+            if (!last) {
+              return [msg];
+            }
+            if (last.order !== msg.order || last.stepOrder !== msg.stepOrder) {
+              return [...msgs, msg];
+            }
+            if (
+              last.status === "pending" &&
+              (msg.streaming || msg.status !== "pending")
+            ) {
+              // Let's prefer a streaming or finalized message over a pending
+              // one.
+              return [...msgs.slice(0, -1), msg];
+            }
+            // skip the new one if the previous one (listed) was finalized
+            return msgs;
+          },
+          [] as (ThreadMessagesResult<Query> & { streaming: boolean })[],
         ),
     };
   }, [paginated, streamMessages]);
@@ -162,11 +188,7 @@ export function useStreamingThreadMessages<
   const [streams, setStreams] = useState<
     Array<{ streamId: string; cursor: number; messages: MessageDoc[] }>
   >([]);
-  const startOrderRef = useRef<number>(0);
   const queryArgs = args === "skip" ? args : omit(args, ["startOrder"]);
-  if (args !== "skip" && !startOrderRef.current && args.startOrder) {
-    startOrderRef.current = args.startOrder;
-  }
   // Get all the active streams
   const streamList = useQuery(
     query,
@@ -177,7 +199,7 @@ export function useStreamingThreadMessages<
           paginationOpts: { cursor: null, numItems: 0 },
           streamArgs: {
             kind: "list",
-            startOrder: startOrderRef.current,
+            startOrder: queryArgs.startOrder ?? 0,
           } as StreamArgs,
         } as FunctionArgs<Query>),
   ) as

package/src/react/optimisticallySendMessage.ts

@@ -12,17 +12,14 @@ export function optimisticallySendMessage(
   return (store, args) => {
     const queries = store.getAllQueries(query);
     let maxOrder = -1;
-    let maxStepOrder = 0;
     for (const q of queries) {
       if (q.args?.threadId !== args.threadId) continue;
       if (q.args.streamArgs) continue;
       for (const m of q.value?.page ?? []) {
         maxOrder = Math.max(maxOrder, m.order);
-        maxStepOrder = Math.max(maxStepOrder, m.stepOrder);
       }
     }
     const order = maxOrder + 1;
-    const stepOrder = 0;
     insertAtTop({
       paginatedQuery: query,
       argsToMatch: { threadId: args.threadId, streamArgs: undefined },
@@ -30,14 +27,11 @@ export function optimisticallySendMessage(
         _creationTime: Date.now(),
         _id: randomUUID(),
         order,
-        stepOrder,
+        stepOrder: 0,
         status: "pending",
         threadId: args.threadId,
         tool: false,
-        message: {
-          role: "user",
-          content: args.prompt,
-        },
+        message: { role: "user", content: args.prompt },
         text: args.prompt,
       },
       localQueryStore: store,

package/src/react/useSmoothText.ts

@@ -3,6 +3,19 @@ import { useEffect, useRef, useState } from "react";
 const FPS = 20;
 const MS_PER_FRAME = 1000 / FPS;
 const MAX_TIME_JUMP_MS = 250;
+
+export type SmoothTextOptions = {
+  /**
+   * The number of characters to display per second.
+   */
+  charsPerSec?: number;
+  /**
+   * Whether to initially start streaming.
+   * If this later turns to false, it'll continue streaming.
+   * This will start streaming the first value it sees.
+   */
+  startStreaming?: boolean;
+};
 /**
  * A hook that smoothly displays text as it is streamed.
  *
@@ -15,21 +28,7 @@ const MAX_TIME_JUMP_MS = 250;
  */
 export function useSmoothText(
   text: string,
-  {
-    charsPerSec = 256,
-    startStreaming = false,
-  }: {
-    /**
-     * The number of characters to display per second.
-     */
-    charsPerSec?: number;
-    /**
-     * Whether to initially start streaming.
-     * If this later turns to false, it'll continue streaming.
-     * This will start streaming the first value it sees.
-     */
-    startStreaming?: boolean;
-  } = {},
+  { charsPerSec = 256, startStreaming = false }: SmoothTextOptions = {},
 ): [string, { cursor: number; isStreaming: boolean }] {
   const [visibleText, setVisibleText] = useState(startStreaming ? "" : text);
   const smoothState = useRef({

package/src/validators.test.ts

@@ -1,8 +1,6 @@
-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 { TextStreamPart } from "./validators.js";
 import { vContextOptions, vStorageOptions } from "./validators.js";
 
 expectTypeOf<Infer<typeof vContextOptions>>().toExtend<ContextOptions>();
@@ -11,19 +9,4 @@ 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

@@ -180,7 +180,7 @@ export const vSource = v.union(
     type: v.optional(v.literal("source")),
     sourceType: v.literal("url"),
     id: v.string(),
-    url: v.optional(v.string()),
+    url: v.string(),
     title: v.optional(v.string()),
     providerOptions,
   }),
@@ -253,6 +253,9 @@ export const vMessageWithMetadataInternal = v.object({
   warnings: v.optional(v.array(vLanguageModelCallWarning)),
   error: v.optional(v.string()),
 });
+export type MessageWithMetadataInternal = Infer<
+  typeof vMessageWithMetadataInternal
+>;
 export const vMessageWithMetadata = v.object({
   ...vMessageWithMetadataInternal.fields,
   fileIds: v.optional(v.array(v.string())),
@@ -334,10 +337,7 @@ export const vTextArgs = v.object({
       v.literal("auto"),
       v.literal("none"),
       v.literal("required"),
-      v.object({
-        type: v.literal("tool"),
-        toolName: v.string(),
-      }),
+      v.object({ type: v.literal("tool"), toolName: v.string() }),
     ),
   ),
   maxSteps: v.optional(v.number()),
@@ -373,93 +373,6 @@ export function vPaginationResult<
   });
 }
 
-export const vTextStreamPartV4 = 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: 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(),
-    toolName: v.string(),
-  }),
-  v.object({
-    type: v.literal("tool-call-delta"),
-    toolCallId: v.string(),
-    toolName: v.string(),
-    argsTextDelta: v.string(),
-  }),
-);
-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({
   streamId: v.string(),
   cursor: v.number(),
@@ -468,14 +381,8 @@ export type StreamCursor = Infer<typeof vStreamCursor>;
 
 export const vStreamArgs = v.optional(
   v.union(
-    v.object({
-      kind: v.literal("list"),
-      startOrder: v.optional(v.number()),
-    }),
-    v.object({
-      kind: v.literal("deltas"),
-      cursors: v.array(vStreamCursor),
-    }),
+    v.object({ kind: v.literal("list"), startOrder: v.optional(v.number()) }),
+    v.object({ kind: v.literal("deltas"), cursors: v.array(vStreamCursor) }),
   ),
 );
 export type StreamArgs = Infer<typeof vStreamArgs>;
@@ -502,6 +409,6 @@ export const vStreamDelta = v.object({
   streamId: v.string(),
   start: v.number(), // inclusive
   end: v.number(), // exclusive
-  parts: v.array(vTextStreamPart),
+  parts: v.array(v.any()),
 });
 export type StreamDelta = Infer<typeof vStreamDelta>;