remotion-claude-agent-demo 0.1.0

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

@@ -0,0 +1,452 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+
+import { appendBackgroundTaskEvent, appendTodoUpdateEvent } from "@/lib/a2a/activity-store";
+import type { A2aTodoItem } from "@/lib/a2a/types";
+import { enqueueBackgroundDelivery } from "@/lib/agent/background-delivery";
+import { getEnv } from "@/lib/env";
+import { getWorkspaceDir } from "@/lib/workspace";
+
+const DEFAULT_CONCURRENCY = 2;
+const PROGRESS_INTERVAL_MS = 1200;
+const PROGRESS_CHARS = 400;
+
+export type BackgroundTaskInput = {
+  contextId: string;
+  description?: string;
+  prompt: string;
+  subagentType?: string;
+  parentTaskId?: string;
+};
+
+export type BackgroundTaskStatus = "queued" | "running" | "completed" | "failed" | "cancelled";
+
+export type BackgroundTaskRecord = {
+  jobId: string;
+  contextId: string;
+  status: BackgroundTaskStatus;
+  description?: string;
+  prompt: string;
+  subagentType?: string;
+  parentTaskId?: string;
+  createdAt: number;
+  startedAt?: number;
+  finishedAt?: number;
+  result?: string;
+  error?: string;
+  sessionId?: string;
+  todos?: A2aTodoItem[];
+  todoUpdatedAt?: number;
+  cancelRequested?: boolean;
+  abortController?: AbortController;
+};
+
+export type BackgroundTaskSummary = {
+  jobId: string;
+  contextId: string;
+  status: BackgroundTaskStatus;
+  description?: string;
+  subagentType?: string;
+  createdAt: number;
+  startedAt?: number;
+  finishedAt?: number;
+  result?: string;
+  error?: string;
+  todos?: A2aTodoItem[];
+  todoUpdatedAt?: number;
+};
+
+type BackgroundQueue = {
+  running: number;
+  queue: string[];
+  jobs: Map<string, BackgroundTaskRecord>;
+};
+
+declare global {
+  var __A2A_BACKGROUND_QUEUE__: BackgroundQueue | undefined;
+}
+
+function getQueue(): BackgroundQueue {
+  if (!globalThis.__A2A_BACKGROUND_QUEUE__) {
+    globalThis.__A2A_BACKGROUND_QUEUE__ = {
+      running: 0,
+      queue: [],
+      jobs: new Map(),
+    };
+  }
+  return globalThis.__A2A_BACKGROUND_QUEUE__;
+}
+
+function getConcurrency(): number {
+  const raw = process.env.BACKGROUND_TASK_CONCURRENCY;
+  const value = raw ? Number(raw) : DEFAULT_CONCURRENCY;
+  if (!Number.isFinite(value) || value <= 0) return DEFAULT_CONCURRENCY;
+  return Math.floor(value);
+}
+
+function makeJobPrompt(input: BackgroundTaskInput): string {
+  if (input.description) {
+    return [`Task: ${input.description}`, "", input.prompt].join("\n");
+  }
+  return input.prompt;
+}
+
+function publishEvent(job: BackgroundTaskRecord, status: BackgroundTaskStatus) {
+  appendBackgroundTaskEvent({
+    contextId: job.contextId,
+    data: {
+      jobId: job.jobId,
+      status,
+      description: job.description,
+      prompt: job.prompt,
+      subagentType: job.subagentType,
+      createdAt: job.createdAt,
+      startedAt: job.startedAt,
+      finishedAt: job.finishedAt,
+      result: job.result,
+      error: job.error,
+      parentTaskId: job.parentTaskId,
+      sessionId: job.sessionId,
+    },
+  });
+}
+
+export function listBackgroundTaskSummaries(input?: {
+  contextId?: string;
+}): BackgroundTaskSummary[] {
+  const queue = getQueue();
+  const tasks = Array.from(queue.jobs.values());
+  const filtered = input?.contextId
+    ? tasks.filter((job) => job.contextId === input.contextId)
+    : tasks;
+  return filtered.map((job) => ({
+    jobId: job.jobId,
+    contextId: job.contextId,
+    status: job.status,
+    description: job.description,
+    subagentType: job.subagentType,
+    createdAt: job.createdAt,
+    startedAt: job.startedAt,
+    finishedAt: job.finishedAt,
+    result: job.result ? job.result.slice(0, 2000) : undefined,
+    error: job.error ? job.error.slice(0, 2000) : undefined,
+    todos: job.todos,
+    todoUpdatedAt: job.todoUpdatedAt,
+  }));
+}
+
+export function enqueueBackgroundTask(input: BackgroundTaskInput): BackgroundTaskRecord {
+  const queue = getQueue();
+  const jobId = globalThis.crypto.randomUUID();
+  const now = Date.now();
+  const job: BackgroundTaskRecord = {
+    jobId,
+    contextId: input.contextId,
+    status: "queued",
+    description: input.description,
+    prompt: input.prompt,
+    subagentType: input.subagentType,
+    parentTaskId: input.parentTaskId,
+    createdAt: now,
+  };
+
+  queue.jobs.set(jobId, job);
+  queue.queue.push(jobId);
+  publishEvent(job, "queued");
+  setTimeout(() => {
+    void drainQueue();
+  }, 0);
+  return job;
+}
+
+export function cancelBackgroundTasksForParent(parentTaskId: string): number {
+  const queue = getQueue();
+  let cancelled = 0;
+
+  for (const job of queue.jobs.values()) {
+    if (job.parentTaskId !== parentTaskId) continue;
+    if (job.status === "completed" || job.status === "failed" || job.status === "cancelled") {
+      continue;
+    }
+
+    job.cancelRequested = true;
+    if (job.status === "queued") {
+      queue.queue = queue.queue.filter((id) => id !== job.jobId);
+      job.status = "cancelled";
+      job.finishedAt = Date.now();
+      job.error = "cancelled";
+      publishEvent(job, "cancelled");
+      cancelled += 1;
+      continue;
+    }
+
+    job.abortController?.abort();
+    cancelled += 1;
+  }
+
+  return cancelled;
+}
+
+export function cancelBackgroundTask(jobId: string): boolean {
+  const queue = getQueue();
+  const job = queue.jobs.get(jobId);
+  if (!job) return false;
+  if (job.status === "completed" || job.status === "failed" || job.status === "cancelled") {
+    return false;
+  }
+
+  job.cancelRequested = true;
+  if (job.status === "queued") {
+    queue.queue = queue.queue.filter((id) => id !== job.jobId);
+    job.status = "cancelled";
+    job.finishedAt = Date.now();
+    job.error = "cancelled";
+    publishEvent(job, "cancelled");
+    return true;
+  }
+
+  job.abortController?.abort();
+  return true;
+}
+
+async function drainQueue() {
+  const queue = getQueue();
+  const concurrency = getConcurrency();
+
+  while (queue.running < concurrency && queue.queue.length > 0) {
+    const jobId = queue.queue.shift();
+    if (!jobId) break;
+    const job = queue.jobs.get(jobId);
+    if (!job || job.status !== "queued") continue;
+    queue.running += 1;
+    void runJob(job)
+      .catch((err) => {
+        console.warn("Background task failed", err);
+      })
+      .finally(() => {
+        queue.running -= 1;
+        void drainQueue();
+      });
+  }
+}
+
+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 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;
+}
+
+async function* singleTurnPrompt(text: string) {
+  yield {
+    type: "user" as const,
+    message: {
+      role: "user" as const,
+      content: text,
+    },
+    parent_tool_use_id: null,
+    session_id: "",
+  };
+}
+
+async function runJob(job: BackgroundTaskRecord): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  const env = getEnv();
+  job.status = "running";
+  job.startedAt = Date.now();
+  publishEvent(job, "running");
+
+  let output = "";
+  let stderrBuf = "";
+  let lastProgressAt = 0;
+  let lastProgressLen = 0;
+
+  const abortController = new AbortController();
+  job.abortController = abortController;
+
+  const q = query({
+    prompt: singleTurnPrompt(
+      makeJobPrompt({
+        contextId: job.contextId,
+        description: job.description,
+        prompt: job.prompt,
+        subagentType: job.subagentType,
+        parentTaskId: job.parentTaskId,
+      }),
+    ),
+    options: {
+      abortController,
+      model: env.anthropicModel,
+      agent: job.subagentType ?? "assistant",
+      includePartialMessages: true,
+      maxThinkingTokens: 10000,
+      allowedTools: [
+        "WebSearch",
+        "WebFetch",
+        "Bash",
+        "BashOutput",
+        "KillBash",
+        "Read",
+        "Write",
+        "Edit",
+        "Glob",
+        "Grep",
+        "Skill",
+        "Task",
+        "TodoWrite",
+      ],
+      settingSources: ["project"],
+      permissionMode: "bypassPermissions",
+      cwd: getWorkspaceDir(),
+      hooks: {
+        PreToolUse: [
+          {
+            matcher: undefined,
+            hooks: [
+              async (hookInput: unknown) => {
+                const i = hookInput as Record<string, unknown>;
+                if (i.tool_name === "TodoWrite") {
+                  const todos = extractTodos(i.tool_input);
+                  if (todos) {
+                    job.todos = todos;
+                    job.todoUpdatedAt = Date.now();
+                    appendTodoUpdateEvent({
+                      contextId: job.contextId,
+                      data: {
+                        jobId: job.jobId,
+                        todos,
+                        updatedAt: job.todoUpdatedAt,
+                      },
+                    });
+                  }
+                }
+                return { continue: true };
+              },
+            ],
+          },
+        ],
+      },
+      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) {
+      if (!job.sessionId) {
+        const sid = extractSdkSessionId(msg);
+        if (sid) job.sessionId = sid;
+      }
+      if (msg.type === "stream_event") {
+        const delta = extractTextDelta(msg.event);
+        if (delta) {
+          output += delta;
+          const now = Date.now();
+          if (
+            now - lastProgressAt >= PROGRESS_INTERVAL_MS &&
+            output.length - lastProgressLen >= PROGRESS_CHARS
+          ) {
+            lastProgressAt = now;
+            lastProgressLen = output.length;
+            job.result = output;
+            publishEvent(job, "running");
+          }
+        }
+      }
+    }
+
+    if (job.cancelRequested || abortController.signal.aborted) {
+      job.status = "cancelled";
+      job.finishedAt = Date.now();
+      job.error = "cancelled";
+      publishEvent(job, "cancelled");
+      return;
+    }
+
+    job.status = "completed";
+    job.finishedAt = Date.now();
+    job.result = output;
+    publishEvent(job, "completed");
+    enqueueBackgroundDelivery({
+      contextId: job.contextId,
+      jobId: job.jobId,
+      description: job.description,
+      subagentType: job.subagentType,
+      status: "completed",
+      result: job.result,
+      finishedAt: job.finishedAt,
+    });
+  } catch (err) {
+    const base = err instanceof Error ? err.message : "Unknown error";
+    const stderr = stderrBuf.trim();
+    if (job.cancelRequested || abortController.signal.aborted) {
+      job.status = "cancelled";
+      job.finishedAt = Date.now();
+      job.error = "cancelled";
+      publishEvent(job, "cancelled");
+      return;
+    }
+
+    job.status = "failed";
+    job.finishedAt = Date.now();
+    job.error = [base, stderr].filter((s) => s && s.length > 0).join("\n");
+    publishEvent(job, "failed");
+    enqueueBackgroundDelivery({
+      contextId: job.contextId,
+      jobId: job.jobId,
+      description: job.description,
+      subagentType: job.subagentType,
+      status: "failed",
+      result: job.result,
+      error: job.error,
+      finishedAt: job.finishedAt,
+    });
+  }
+}
+
+function extractTodos(input: unknown): A2aTodoItem[] | null {
+  if (!input || typeof input !== "object") return null;
+  const rec = input as Record<string, unknown>;
+  if (!Array.isArray(rec.todos)) return null;
+  const todos = rec.todos
+    .map((todo): A2aTodoItem | null => {
+      if (!todo || typeof todo !== "object") return null;
+      const t = todo as Record<string, unknown>;
+      const content = typeof t.content === "string" ? t.content : null;
+      const status =
+        t.status === "pending" || t.status === "in_progress" || t.status === "completed"
+          ? (t.status as A2aTodoItem["status"])
+          : null;
+      if (!content || !status) return null;
+      const item: A2aTodoItem = { content, status };
+      if (typeof t.activeForm === "string") item.activeForm = t.activeForm;
+      return item;
+    })
+    .filter((t): t is A2aTodoItem => t !== null);
+  return todos.length > 0 ? todos : null;
+}