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

package/src/mapping.ts

@@ -139,6 +139,97 @@ export function docsToModelMessages(messages: MessageDoc[]): ModelMessage[] {
     .map(toModelMessage);
 }
 
+/**
+ * Scan messages for unresolved `tool-approval-request` parts and inject
+ * synthetic `tool-approval-response` denials so that the AI SDK receives
+ * a complete history (every tool-call has a corresponding result or denial).
+ *
+ * This handles the case where a user sends a new message instead of
+ * resolving pending approvals — the old approvals are auto-denied rather
+ * than silently dropped.
+ */
+export function autoDenyUnresolvedApprovals(
+  messages: ModelMessage[],
+): ModelMessage[] {
+  // Collect all approval requests: approvalId → { toolCallId, messageIndex }
+  const requests = new Map<
+    string,
+    { toolCallId: string; messageIndex: number }
+  >();
+  // Collect all resolved approval IDs
+  const resolvedIds = new Set<string>();
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content as any[]) {
+      if (part.type === "tool-approval-request") {
+        requests.set(part.approvalId, {
+          toolCallId: part.toolCallId,
+          messageIndex: i,
+        });
+      } else if (part.type === "tool-approval-response") {
+        resolvedIds.add(part.approvalId);
+      }
+    }
+  }
+
+  // Find unresolved approvals
+  const unresolved: Array<{
+    approvalId: string;
+    toolCallId: string;
+    messageIndex: number;
+  }> = [];
+  for (const [approvalId, info] of requests) {
+    if (!resolvedIds.has(approvalId)) {
+      unresolved.push({ approvalId, ...info });
+    }
+  }
+
+  if (unresolved.length === 0) {
+    return messages;
+  }
+
+  // Group unresolved approvals by the assistant message index they came from
+  const byMessageIndex = new Map<
+    number,
+    Array<{ approvalId: string; toolCallId: string }>
+  >();
+  for (const entry of unresolved) {
+    console.warn(
+      `Auto-denying unresolved tool approval ${entry.approvalId} ` +
+        `(toolCallId: ${entry.toolCallId}): new generation started`,
+    );
+    let group = byMessageIndex.get(entry.messageIndex);
+    if (!group) {
+      group = [];
+      byMessageIndex.set(entry.messageIndex, group);
+    }
+    group.push(entry);
+  }
+
+  // Build result by inserting synthetic denial messages after each relevant
+  // assistant message
+  const result: ModelMessage[] = [];
+  for (let i = 0; i < messages.length; i++) {
+    result.push(messages[i]);
+    const group = byMessageIndex.get(i);
+    if (group) {
+      result.push({
+        role: "tool",
+        content: group.map((entry) => ({
+          type: "tool-approval-response" as const,
+          approvalId: entry.approvalId,
+          approved: false,
+          reason: "auto-denied: new generation started",
+        })),
+      });
+    }
+  }
+
+  return result;
+}
+
 export function serializeUsage(usage: LanguageModelUsage): Usage {
   return {
     promptTokens: usage.inputTokens ?? 0,
@@ -206,11 +297,49 @@ export function toModelMessageWarnings(
   }) as any;
 }
 
+/**
+ * Serialize explicitly provided response messages for a step.
+ * Used by the streaming/generation loop where the caller tracks which
+ * messages are new via slicing.
+ */
+export async function serializeResponseMessages<TOOLS extends ToolSet>(
+  ctx: ActionCtx,
+  component: AgentComponent,
+  step: StepResult<TOOLS>,
+  model: ModelOrMetadata | undefined,
+  responseMessages: ModelMessage[],
+): Promise<{ messages: MessageWithMetadata[] }> {
+  return serializeStepMessages(ctx, component, step, model, responseMessages);
+}
+
+/**
+ * Serialize the new messages from a step using a heuristic to determine
+ * which response messages are new (last 1-2 messages).
+ */
 export async function serializeNewMessagesInStep<TOOLS extends ToolSet>(
   ctx: ActionCtx,
   component: AgentComponent,
   step: StepResult<TOOLS>,
   model: ModelOrMetadata | undefined,
+): Promise<{ messages: MessageWithMetadata[] }> {
+  const hasToolMessage = step.response.messages.at(-1)?.role === "tool";
+  let messagesToSerialize: ModelMessage[];
+  if (hasToolMessage) {
+    messagesToSerialize = step.response.messages.slice(-2);
+  } else if (step.content.length) {
+    messagesToSerialize = step.response.messages.slice(-1);
+  } else {
+    messagesToSerialize = [{ role: "assistant" as const, content: [] }];
+  }
+  return serializeStepMessages(ctx, component, step, model, messagesToSerialize);
+}
+
+async function serializeStepMessages<TOOLS extends ToolSet>(
+  ctx: ActionCtx,
+  component: AgentComponent,
+  step: StepResult<TOOLS>,
+  model: ModelOrMetadata | undefined,
+  messagesToSerialize: ModelMessage[],
 ): Promise<{ messages: MessageWithMetadata[] }> {
   // If there are tool results, there's another message with the tool results
   // ref: https://github.com/vercel/ai/blob/main/packages/ai/src/generate-text/to-response-messages.ts#L120
@@ -228,13 +357,9 @@ export async function serializeNewMessagesInStep<TOOLS extends ToolSet>(
     sources: hasToolMessage ? undefined : step.sources,
   } satisfies Omit<MessageWithMetadata, "message" | "text" | "fileIds">;
   const toolFields = { sources: step.sources };
+
   const messages: MessageWithMetadata[] = await Promise.all(
-    (hasToolMessage
-      ? step.response.messages.slice(-2)
-      : step.content.length
-        ? step.response.messages.slice(-1)
-        : [{ role: "assistant" as const, content: [] }]
-    ).map(async (msg): Promise<MessageWithMetadata> => {
+    messagesToSerialize.map(async (msg): Promise<MessageWithMetadata> => {
       const { message, fileIds } = await serializeMessage(ctx, component, msg);
       return parse(vMessageWithMetadata, {
         message,

package/src/react/useDeltaStreams.ts

@@ -83,6 +83,12 @@ export function useDeltaStreams<
             ),
           );
 
+  // When no active streams remain, clear the stale state so we stop
+  // returning old streaming UIMessages.
+  if (streamMessages !== undefined && streamMessages.length === 0) {
+    state.deltaStreams = undefined;
+  }
+
   // Get the deltas for all the active streams, if any.
   const cursorQuery = useQuery(
     query,