@convex-dev/agent 0.1.9-alpha.4 → 0.1.9-alpha.5

package/src/component/_generated/api.d.ts

@@ -1575,13 +1575,18 @@ export type Mounts = {
     list: FunctionReference<
       "query",
       "public",
-      { startOrder?: number; threadId: string },
+      {
+        startOrder?: number;
+        statuses?: Array<"streaming" | "finished" | "aborted">;
+        threadId: string;
+      },
       Array<{
         agentName?: string;
         model?: string;
         order: number;
         provider?: string;
         providerOptions?: Record<string, Record<string, any>>;
+        status: "streaming" | "finished" | "aborted";
         stepOrder: number;
         streamId: string;
         userId?: string;

package/src/component/schema.ts

@@ -112,10 +112,6 @@ export const schema = defineSchema({
       v.object({
         kind: v.literal("aborted"),
         reason: v.string(),
-      }),
-      v.object({
-        kind: v.literal("error"),
-        error: v.string(),
       })
     ),
   })

package/src/component/streams.ts

@@ -103,33 +103,47 @@ export const list = query({
   args: {
     threadId: v.id("threads"),
     startOrder: v.optional(v.number()),
+    statuses: v.optional(
+      v.array(
+        v.union(
+          v.literal("streaming"),
+          v.literal("finished"),
+          v.literal("aborted")
+        )
+      )
+    ),
   },
   returns: v.array(vStreamMessage),
   handler: async (ctx, args) => {
-    return ctx.db
-      .query("streamingMessages")
-      .withIndex("threadId_state_order_stepOrder", (q) =>
-        q
-          .eq("threadId", args.threadId)
-          .eq("state.kind", "streaming")
-          .gte("order", args.startOrder ?? 0)
-      )
-      .order("desc")
-      .take(100)
-      .then((msgs) =>
-        msgs.map((m) => ({
-          streamId: m._id,
-          ...pick(m, [
-            "order",
-            "stepOrder",
-            "userId",
-            "agentName",
-            "model",
-            "provider",
-            "providerOptions",
-          ]),
-        }))
-      );
+    const statuses = args.statuses ?? ["streaming"];
+    const messages = await mergedStream(
+      statuses.map((status) =>
+        stream(ctx.db, schema)
+          .query("streamingMessages")
+          .withIndex("threadId_state_order_stepOrder", (q) =>
+            q
+              .eq("threadId", args.threadId)
+              .eq("state.kind", status)
+              .gte("order", args.startOrder ?? 0)
+          )
+          .order("desc")
+      ),
+      ["order", "stepOrder"]
+    ).take(100);
+
+    return messages.map((m) => ({
+      streamId: m._id,
+      status: m.state.kind,
+      ...pick(m, [
+        "order",
+        "stepOrder",
+        "userId",
+        "agentName",
+        "model",
+        "provider",
+        "providerOptions",
+      ]),
+    }));
   },
 });
 

package/src/react/deltas.ts

@@ -255,12 +255,14 @@ export function createStreamingMessage(
 ): MessageDoc {
   const { streamId, ...rest } = message;
   const metadata: MessageDoc = {
+    ...rest,
     _id: `${streamId}-${index}`,
     _creationTime: Date.now(),
-    status: "pending",
+    status: (
+      { streaming: "pending", finished: "success", aborted: "failed" } as const
+    )[message.status],
     threadId,
     tool: false,
-    ...rest,
   };
   switch (part.type) {
     case "text-delta":

package/src/validators.ts

@@ -472,6 +472,11 @@ export type StreamArgs = Infer<typeof vStreamArgs>;
 
 export const vStreamMessage = v.object({
   streamId: v.string(),
+  status: v.union(
+    v.literal("streaming"),
+    v.literal("finished"),
+    v.literal("aborted")
+  ),
   order: v.number(),
   stepOrder: v.number(),
   // metadata