remotion-claude-agent-demo 0.1.0

package/apps/web/src/lib/agent/answer-store.ts

@@ -0,0 +1,109 @@
+/**
+ * 管理 AskUserQuestion 的等待和回答机制
+ * 当 Claude 调用 AskUserQuestion 时，后端会暂停执行等待用户回答
+ */
+
+import type { AskUserQuestion } from "@/lib/a2a/types";
+
+type PendingQuestion = {
+  requestId: string;
+  taskId: string;
+  questions: AskUserQuestion[];
+  resolve: (answers: Record<string, string>) => void;
+  reject: (reason: Error) => void;
+  timeoutId: ReturnType<typeof setTimeout>;
+};
+
+// 存储等待中的问题
+const pendingQuestions = new Map<string, PendingQuestion>();
+
+// 默认超时时间 60 秒（SDK 要求）
+const DEFAULT_TIMEOUT_MS = 60_000;
+
+/**
+ * 创建一个等待用户回答的 Promise
+ * 在 canUseTool 回调中调用
+ */
+export function waitForAnswer(input: {
+  requestId: string;
+  taskId: string;
+  questions: AskUserQuestion[];
+  timeoutMs?: number;
+}): Promise<Record<string, string>> {
+  const { requestId, taskId, questions, timeoutMs = DEFAULT_TIMEOUT_MS } = input;
+
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      pendingQuestions.delete(requestId);
+      reject(new Error(`AskUserQuestion timeout after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    pendingQuestions.set(requestId, {
+      requestId,
+      taskId,
+      questions,
+      resolve,
+      reject,
+      timeoutId,
+    });
+  });
+}
+
+/**
+ * 提交用户的回答
+ * 在 answer API 端点中调用
+ */
+export function submitAnswer(input: {
+  requestId: string;
+  answers: Record<string, string>;
+}): boolean {
+  const { requestId, answers } = input;
+  const pending = pendingQuestions.get(requestId);
+
+  if (!pending) {
+    return false;
+  }
+
+  clearTimeout(pending.timeoutId);
+  pendingQuestions.delete(requestId);
+  pending.resolve(answers);
+  return true;
+}
+
+/**
+ * 取消等待中的问题
+ */
+export function cancelPendingQuestion(requestId: string): boolean {
+  const pending = pendingQuestions.get(requestId);
+
+  if (!pending) {
+    return false;
+  }
+
+  clearTimeout(pending.timeoutId);
+  pendingQuestions.delete(requestId);
+  pending.reject(new Error("Question cancelled"));
+  return true;
+}
+
+/**
+ * 检查是否有等待中的问题
+ */
+export function hasPendingQuestion(requestId: string): boolean {
+  return pendingQuestions.has(requestId);
+}
+
+/**
+ * 获取等待中的问题详情
+ */
+export function getPendingQuestion(requestId: string): {
+  taskId: string;
+  questions: AskUserQuestion[];
+} | null {
+  const pending = pendingQuestions.get(requestId);
+  if (!pending) return null;
+  return {
+    taskId: pending.taskId,
+    questions: pending.questions,
+  };
+}

package/apps/web/src/lib/agent/background-delivery.ts

@@ -0,0 +1,343 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+import { appendDeliveryMessageEvent } from "@/lib/a2a/activity-store";
+import { getSessionIdForContext, setSessionIdForContext } from "@/lib/agent/session-store";
+import { getEnv } from "@/lib/env";
+import { getWorkspaceDir } from "@/lib/workspace";
+
+const MAX_DELIVERY_CHARS = 300;
+const MAX_PROMPT_DETAIL_CHARS = 600;
+const MAX_DIRECT_DETAIL_CHARS = 160;
+
+export type BackgroundDeliveryItem = {
+  contextId: string;
+  jobId: string;
+  description?: string;
+  subagentType?: string;
+  status: "completed" | "failed";
+  result?: string;
+  error?: string;
+  finishedAt?: number;
+};
+
+type DeliveryQueue = {
+  delivering: boolean;
+  items: BackgroundDeliveryItem[];
+};
+
+type DeliveryStore = {
+  queues: Map<string, DeliveryQueue>;
+  activeContexts: Set<string>;
+};
+
+declare global {
+  var __A2A_DELIVERY_STORE__: DeliveryStore | undefined;
+}
+
+function getStore(): DeliveryStore {
+  if (!globalThis.__A2A_DELIVERY_STORE__) {
+    globalThis.__A2A_DELIVERY_STORE__ = {
+      queues: new Map(),
+      activeContexts: new Set(),
+    };
+  }
+  return globalThis.__A2A_DELIVERY_STORE__;
+}
+
+function getQueue(contextId: string): DeliveryQueue {
+  const store = getStore();
+  const existing = store.queues.get(contextId);
+  if (existing) return existing;
+  const queue: DeliveryQueue = { delivering: false, items: [] };
+  store.queues.set(contextId, queue);
+  return queue;
+}
+
+export function markContextActive(contextId: string) {
+  getStore().activeContexts.add(contextId);
+}
+
+export function markContextIdle(contextId: string) {
+  getStore().activeContexts.delete(contextId);
+  void flushBackgroundDeliveries(contextId);
+}
+
+export function enqueueBackgroundDelivery(item: BackgroundDeliveryItem) {
+  const queue = getQueue(item.contextId);
+  queue.items.push(item);
+  if (!getStore().activeContexts.has(item.contextId)) {
+    void flushBackgroundDeliveries(item.contextId);
+  }
+}
+
+function compactText(input?: string): string {
+  if (!input) return "";
+  return input.replace(/\s+/g, " ").trim();
+}
+
+function truncateText(input: string, max: number): string {
+  const clean = compactText(input);
+  if (clean.length <= max) return clean;
+  return `${clean.slice(0, Math.max(0, max - 3)).trimEnd()}...`;
+}
+
+function buildTaskLabel(item: BackgroundDeliveryItem): string {
+  return item.description || item.subagentType || "后台任务";
+}
+
+function buildDirectMessage(item: BackgroundDeliveryItem): string {
+  const taskLabel = buildTaskLabel(item);
+  const statusLabel = item.status === "completed" ? "已完成" : "已失败";
+  const detailSource = item.status === "failed" ? item.error : item.result;
+  const detail = detailSource
+    ? truncateText(detailSource, MAX_DIRECT_DETAIL_CHARS)
+    : "";
+  const detailLabel = detail
+    ? item.status === "failed"
+      ? `错误：${detail}`
+      : `结果：${detail}`
+    : "";
+  return detailLabel
+    ? `任务 ${taskLabel}（id:${item.jobId}）${statusLabel}。${detailLabel}`
+    : `任务 ${taskLabel}（id:${item.jobId}）${statusLabel}`;
+}
+
+async function* singleTurnPrompt(text: string) {
+  yield {
+    type: "user" as const,
+    message: {
+      role: "user" as const,
+      content: text,
+    },
+    parent_tool_use_id: null,
+    session_id: "",
+  };
+}
+
+function extractTextDelta(event: unknown): string | null {
+  if (!event || typeof event !== "object") return null;
+  const rec = event as Record<string, unknown>;
+  if (rec.type !== "content_block_delta") return null;
+  const delta = rec.delta;
+  if (!delta || typeof delta !== "object") return null;
+  const deltaRec = delta as Record<string, unknown>;
+  const text = deltaRec.text;
+  return typeof text === "string" ? text : null;
+}
+
+function extractTextFromContent(content: unknown): string | null {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  let text = "";
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const rec = block as Record<string, unknown>;
+    if (rec.type === "text" && typeof rec.text === "string") {
+      text += rec.text;
+    }
+  }
+  return text ? text : null;
+}
+
+function extractAssistantText(message: unknown): string | null {
+  if (!message || typeof message !== "object") return null;
+  const rec = message as Record<string, unknown>;
+  if (rec.type === "assistant") {
+    const msg = rec.message;
+    if (!msg || typeof msg !== "object") return null;
+    const content = (msg as Record<string, unknown>).content;
+    return extractTextFromContent(content);
+  }
+  if (rec.type === "result" && rec.subtype === "success") {
+    const result = rec.result;
+    if (typeof result === "string" && result.trim().length > 0) return result;
+  }
+  return null;
+}
+
+function extractSdkSessionId(message: unknown): string | undefined {
+  if (!message || typeof message !== "object") return undefined;
+  const rec = message as Record<string, unknown>;
+  const sid = rec.session_id;
+  return typeof sid === "string" && sid.length > 0 ? sid : undefined;
+}
+
+function buildResumePrompt(item: BackgroundDeliveryItem): string {
+  const taskLabel = buildTaskLabel(item);
+  const statusLabel = item.status === "completed" ? "已完成" : "已失败";
+  const detailSource = item.status === "failed" ? item.error : item.result;
+  const detail = detailSource
+    ? truncateText(detailSource, MAX_PROMPT_DETAIL_CHARS)
+    : "";
+  const detailLabel = detail
+    ? item.status === "failed"
+      ? `错误：${detail}`
+      : `结果：${detail}`
+    : "";
+  const lines = [
+    "你是主会话的通知助手，只需输出一条简短通知。",
+    "要求：不要调用任何工具；不要提出后续动作；不要重复；不要提问；不使用 Markdown；最多两句话。",
+    `任务：${taskLabel}（id:${item.jobId}）`,
+    `状态：${statusLabel}`,
+  ];
+  if (detailLabel) lines.push(detailLabel);
+  lines.push("请输出通知：");
+  return lines.join("\n");
+}
+
+async function generateDeliveryMessage(
+  item: BackgroundDeliveryItem,
+  sessionId: string,
+  onUpdate?: (text: string) => void,
+): Promise<string> {
+  const env = getEnv();
+  let output = "";
+  let stderrBuf = "";
+  let finalText: string | null = null;
+  let lastUpdateLen = 0;
+  let sawTextDelta = false;
+  let abortedForLength = false;
+  const abortController = new AbortController();
+
+  const emitProgress = () => {
+    if (!onUpdate || output.length === 0) return;
+    if (output.length !== lastUpdateLen) {
+      lastUpdateLen = output.length;
+      onUpdate(output);
+    }
+  };
+
+  const q = query({
+    prompt: singleTurnPrompt(buildResumePrompt(item)),
+    options: {
+      abortController,
+      model: env.anthropicModel,
+      resume: sessionId,
+      forkSession: false,
+      includePartialMessages: true,
+      maxThinkingTokens: 256,
+      maxTurns: 1,
+      permissionMode: "bypassPermissions",
+      allowedTools: [],
+      settingSources: ["project"],
+      cwd: getWorkspaceDir(),
+      stderr: (data) => {
+        stderrBuf += data;
+        if (stderrBuf.length > 20000) stderrBuf = stderrBuf.slice(-20000);
+      },
+      env: {
+        ...process.env,
+        ...(env.anthropicApiKey
+          ? { ANTHROPIC_API_KEY: env.anthropicApiKey }
+          : {}),
+        ...(env.anthropicBaseUrl
+          ? { ANTHROPIC_BASE_URL: env.anthropicBaseUrl }
+          : {}),
+        ...(env.anthropicDefaultHaikuModel
+          ? { ANTHROPIC_DEFAULT_HAIKU_MODEL: env.anthropicDefaultHaikuModel }
+          : {}),
+        ...(env.anthropicModel ? { ANTHROPIC_MODEL: env.anthropicModel } : {}),
+      },
+    },
+  });
+
+  try {
+    for await (const msg of q) {
+      const sid = extractSdkSessionId(msg);
+      if (sid) setSessionIdForContext({ contextId: item.contextId, sessionId: sid });
+
+      if (msg.type === "stream_event") {
+        const delta = extractTextDelta(msg.event);
+        if (delta) {
+          output += delta;
+          sawTextDelta = true;
+          if (output.length >= MAX_DELIVERY_CHARS) {
+            abortedForLength = true;
+            emitProgress();
+            abortController.abort();
+            break;
+          }
+          emitProgress();
+        }
+        continue;
+      }
+
+      const assistantText = extractAssistantText(msg);
+      if (assistantText) finalText = assistantText;
+    }
+  } catch (err) {
+    if (!abortedForLength) {
+      throw err;
+    }
+  }
+
+  if (abortedForLength && output.trim().length > 0) {
+    return truncateText(output, MAX_DELIVERY_CHARS);
+  }
+
+  if (sawTextDelta) return output;
+  const trimmed = output.trim();
+  if (trimmed) return output;
+
+  if (finalText && finalText.trim().length > 0) return finalText;
+
+  const stderr = stderrBuf.trim();
+  if (stderr) throw new Error(stderr);
+  return buildDirectMessage(item);
+}
+
+export async function flushBackgroundDeliveries(contextId: string) {
+  const store = getStore();
+  if (store.activeContexts.has(contextId)) return;
+
+  const queue = getQueue(contextId);
+  if (queue.delivering) return;
+  queue.delivering = true;
+
+  try {
+    while (queue.items.length > 0 && !store.activeContexts.has(contextId)) {
+      const item = queue.items.shift();
+      if (!item) return;
+
+      let lastEmittedText = "";
+      let didStreamUpdate = false;
+      const emitDelivery = (text: string) => {
+        if (!text || text === lastEmittedText) return;
+        const isDelta = text.startsWith(lastEmittedText);
+        const rawText = isDelta ? text.slice(lastEmittedText.length) : text;
+        if (rawText.length === 0) return;
+        lastEmittedText = text;
+        appendDeliveryMessageEvent({
+          contextId,
+          data: {
+            jobId: item.jobId,
+            text: rawText,
+            createdAt: Date.now(),
+            isDelta,
+          },
+        });
+      };
+
+      const sessionId = getSessionIdForContext(contextId);
+      if (!sessionId) {
+        emitDelivery(buildDirectMessage(item));
+        continue;
+      }
+
+      try {
+        const text = await generateDeliveryMessage(item, sessionId, (update) => {
+          didStreamUpdate = true;
+          emitDelivery(update);
+        });
+        emitDelivery(text);
+      } catch (err) {
+        console.warn("Background delivery resume failed", err);
+        if (!didStreamUpdate) {
+          emitDelivery(buildDirectMessage(item));
+        }
+      }
+    }
+  } finally {
+    queue.delivering = false;
+  }
+}

package/apps/web/src/lib/agent/background-tool.ts

@@ -0,0 +1,78 @@
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+
+import { enqueueBackgroundTask, listBackgroundTaskSummaries } from "@/lib/agent/background";
+
+export const BACKGROUND_TASK_TOOL_NAME = "mcp__background_tasks__start";
+export const BACKGROUND_TASK_LIST_TOOL_NAME = "mcp__background_tasks__list";
+
+export function createBackgroundTaskServer(input: {
+  contextId: string;
+  parentTaskId: string;
+}) {
+  return createSdkMcpServer({
+    name: "background_tasks",
+    version: "1.0.0",
+    tools: [
+      tool(
+        "start",
+        "Start a background task and return a jobId immediately. Progress is reported via the activity stream.",
+        {
+          description: z.string().min(1).describe("Short label shown in the UI"),
+          prompt: z.string().min(1).describe("Task instructions"),
+          subagent_type: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("Subagent name from .claude/agents"),
+        },
+        async (args) => {
+          const job = enqueueBackgroundTask({
+            contextId: input.contextId,
+            parentTaskId: input.parentTaskId,
+            description: args.description,
+            prompt: args.prompt,
+            subagentType: args.subagent_type,
+          });
+
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ jobId: job.jobId, status: job.status }),
+              },
+            ],
+          };
+        },
+      ),
+      tool(
+        "list",
+        "List background tasks for the current session with status/todo snapshot.",
+        { _: z.optional(z.never()).describe("No arguments") },
+        async () => {
+          const tasks = listBackgroundTaskSummaries({ contextId: input.contextId }).map(
+            (task) => ({
+              jobId: task.jobId,
+              status: task.status,
+              description: task.description,
+              subagentType: task.subagentType,
+              createdAt: task.createdAt,
+              startedAt: task.startedAt,
+              finishedAt: task.finishedAt,
+              todos: task.todos,
+              todoUpdatedAt: task.todoUpdatedAt,
+            }),
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ tasks }),
+              },
+            ],
+          };
+        },
+      ),
+    ],
+  });
+}