Second tool approval in a thread fails when contextHandler returns history beyond recentMessages #411

import {
  Agent,
  createTool,
  docsToModelMessages,
  listMessages,
  saveMessage,
} from "@convex-dev/agent";
import agentComponent from "@convex-dev/agent/test";
import { MockLanguageModelV4 } from "ai/test";
import { defineTestApp } from "convex-test";
import { defineSchema } from "convex/server";
import { v } from "convex/values";
import { z } from "zod/v4";

const app = defineTestApp({
  schema: defineSchema({}),
  components: { agent: agentComponent },
});
const component = app.components.agent;

const usage = {
  inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
  outputTokens: { total: 1, text: 1, reasoning: 0 },
};
const reply = (content: any) => ({
  content: [content],
  finishReason: { unified: "stop" as const, raw: undefined },
  usage,
  warnings: [],
});
const callTool = (n: number) =>
  reply({
    type: "tool-call",
    toolCallId: `call-${n}`,
    toolName: "deleteFile",
    input: JSON.stringify({ name: `file-${n}.txt` }),
  });

// Two user messages, each of which calls a tool that needs approval.
const model = new MockLanguageModelV4({
  doGenerate: [
    callTool(1),
    reply({ type: "text", text: "Deleted file-1.txt" }),
    callTool(2),
    reply({ type: "text", text: "Deleted file-2.txt" }),
  ],
});

const agent = new Agent(component, {
  name: "repro",
  languageModel: model,
  tools: {
    deleteFile: createTool({
      inputSchema: z.object({ name: z.string() }),
      needsApproval: true,
      execute: async (_ctx, { name }) => `deleted ${name}`,
    }),
  },
  contextOptions: { recentMessages: 1 },
  // Build the context from the whole thread, e.g. to summarize old turns.
  contextHandler: async (ctx, { threadId }) => {
    const { page } = await listMessages(ctx, component, {
      threadId: threadId!,
      paginationOpts: { cursor: null, numItems: 100 },
    });
    return docsToModelMessages(page.reverse());
  },
});

const send = app.action({
  args: { threadId: v.string(), text: v.string() },
  handler: async (ctx, { threadId, text }) => {
    const { messageId } = await saveMessage(ctx, component, {
      threadId,
      prompt: text,
    });
    const result = await agent.generateText(
      ctx,
      { threadId },
      { promptMessageId: messageId },
    );
    const request = result.content.find(
      (part) => part.type === "tool-approval-request",
    );
    return request!.approvalId;
  },
});

const approve = app.mutation({
  args: { threadId: v.string(), approvalId: v.string() },
  handler: (ctx, args) => agent.approveToolCall(ctx, args),
});

const resume = app.action({
  args: { threadId: v.string(), messageId: v.string() },
  handler: async (ctx, { threadId, messageId }) => {
    const result = await agent.generateText(
      ctx,
      { threadId },
      { promptMessageId: messageId },
    );
    return result.text;
  },
});

const createThread = app.mutation({
  args: {},
  handler: (ctx) => agent.createThread(ctx, {}).then((t) => t.threadId),
});

export const { api, createTest } = app.defineModules({
  repro: { createThread, send, approve, resume },
});

import { expect, test } from "vitest";
import { api, createTest } from "./agent";

test("second tool approval in a thread", async () => {
  const t = createTest();
  const threadId = await t.mutation(api.repro.createThread, {});

  for (const n of [1, 2]) {
    const approvalId = await t.action(api.repro.send, {
      threadId,
      text: `Delete file-${n}.txt`,
    });
    const { messageId } = await t.mutation(api.repro.approve, {
      threadId,
      approvalId,
    });
    // n = 2 throws "Continuation context cannot add approval requests"
    const text = await t.action(api.repro.resume, { threadId, messageId });
    expect(text).toBe(`Deleted file-${n}.txt`);
  }
});