remotion-claude-agent-demo 0.1.0

package/apps/web/src/app/messages/stream/route.ts

@@ -0,0 +1,381 @@
+import { NextResponse } from "next/server";
+
+import type { A2aError, A2aMessage } from "@/lib/a2a/types";
+import { sseData, sseHeaders } from "@/lib/a2a/sse";
+import {
+  attachAbortController,
+  createTask,
+  isCancelRequested,
+  updateStatus,
+  appendHistory,
+} from "@/lib/a2a/task-store";
+import { streamChatReply } from "@/lib/agent/chat";
+import {
+  getSessionIdForContext,
+  setSessionIdForContext,
+} from "@/lib/agent/session-store";
+import { markContextActive, markContextIdle } from "@/lib/agent/background-delivery";
+import { getEnv } from "@/lib/env";
+
+export const runtime = "nodejs";
+
+function badRequest(message: string): NextResponse<A2aError> {
+  return NextResponse.json(
+    { error: { code: "ValidationError", message } },
+    { status: 400, headers: { "Content-Type": "application/a2a+json" } },
+  );
+}
+
+function ensureTextMessage(msg: unknown): msg is A2aMessage {
+  if (!msg || typeof msg !== "object") return false;
+  const rec = msg as Record<string, unknown>;
+  if (rec.kind !== "message") return false;
+  if (rec.role !== "user" && rec.role !== "agent") return false;
+  if (!Array.isArray(rec.parts)) return false;
+  return true;
+}
+
+function extractUserText(message: A2aMessage): string {
+  const parts = message.parts;
+  for (const p of parts) {
+    if (p && typeof p === "object") {
+      const rec = p as Record<string, unknown>;
+      if (rec.kind === "text" && typeof rec.text === "string") return rec.text;
+    }
+  }
+  return "";
+}
+
+function extractClientSessionId(body: Record<string, unknown>): string | undefined {
+  const config = body.configuration;
+  if (!config || typeof config !== "object") return undefined;
+  const rec = config as Record<string, unknown>;
+  const meta = rec.metadata;
+  if (!meta || typeof meta !== "object") return undefined;
+  const metaRec = meta as Record<string, unknown>;
+  const sessionId = metaRec.sessionId;
+  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : undefined;
+}
+
+export async function POST(request: Request) {
+  const env = getEnv();
+  if (
+    (request.headers.get("A2A-Version") ?? env.a2aVersion) !== env.a2aVersion
+  ) {
+    return NextResponse.json(
+      {
+        error: {
+          code: "VersionNotSupportedError",
+          message: "Unsupported A2A-Version",
+        },
+      },
+      { status: 400, headers: { "Content-Type": "application/a2a+json" } },
+    );
+  }
+
+  let body: unknown;
+  try {
+    body = await request.json();
+  } catch {
+    return badRequest("Invalid JSON body");
+  }
+
+  if (!body || typeof body !== "object")
+    return badRequest("Invalid request body");
+  const rec = body as Record<string, unknown>;
+  const msg = rec.message;
+  if (!ensureTextMessage(msg)) return badRequest("Missing or invalid message");
+
+  const userText = extractUserText(msg);
+  if (!userText) return badRequest("Message must include a text part");
+
+  const clientSessionId = extractClientSessionId(rec);
+  const taskId = globalThis.crypto.randomUUID();
+  const contextId =
+    typeof msg.contextId === "string" && msg.contextId.length > 0
+      ? msg.contextId
+      : globalThis.crypto.randomUUID();
+  const task = createTask({ taskId, contextId, initialMessage: msg });
+
+  const abortController = new AbortController();
+  attachAbortController(taskId, abortController);
+
+  const resumeSessionId = getSessionIdForContext(contextId) ?? clientSessionId;
+  if (resumeSessionId && !getSessionIdForContext(contextId)) {
+    setSessionIdForContext({ contextId, sessionId: resumeSessionId });
+  }
+
+  const stream = new ReadableStream<Uint8Array>({
+    async start(controller) {
+      controller.enqueue(
+        sseData({
+          kind: "task",
+          task,
+        }),
+      );
+
+      const assistantMessageId = globalThis.crypto.randomUUID();
+      let assistantText = "";
+      let statusIndex = 0;
+
+      markContextActive(contextId);
+      statusIndex = updateStatus(taskId, {
+        state: "working",
+        timestamp: new Date().toISOString(),
+        message: "responding",
+      });
+      controller.enqueue(
+        sseData({
+          kind: "statusUpdate",
+          statusUpdate: {
+            kind: "statusUpdate",
+            taskId,
+            status: {
+              state: "working",
+              timestamp: new Date().toISOString(),
+              message: "responding",
+            },
+            index: statusIndex,
+          },
+        }),
+      );
+
+      const enqueueToolCall = (ev: {
+        toolName: string;
+        toolId: string;
+        input: unknown;
+        status: "started" | "completed";
+        output?: unknown;
+        toolSeq?: number;
+      }) =>
+        controller.enqueue(
+          sseData({
+            kind: "toolCall",
+            toolCall: {
+              kind: "toolCall",
+              toolName: ev.toolName,
+              toolId: ev.toolId,
+              input: ev.input,
+              status: ev.status,
+              output: ev.output,
+              toolSeq: ev.toolSeq,
+            },
+          }),
+        );
+
+      const enqueueAskUserQuestion = (ev: {
+        requestId: string;
+        taskId: string;
+        questions: Array<{
+          question: string;
+          header: string;
+          options: Array<{ label: string; description: string }>;
+          multiSelect?: boolean;
+        }>;
+      }) =>
+        controller.enqueue(
+          sseData({
+            kind: "askUserQuestion",
+            askUserQuestion: {
+              kind: "askUserQuestion",
+              requestId: ev.requestId,
+              taskId: ev.taskId,
+              questions: ev.questions,
+            },
+          }),
+        );
+
+      const enqueueQuestionDismissed = (ev: {
+        requestId: string;
+        taskId: string;
+        reason: "timeout" | "cancelled";
+      }) =>
+        controller.enqueue(
+          sseData({
+            kind: "questionDismissed",
+            questionDismissed: {
+              kind: "questionDismissed",
+              requestId: ev.requestId,
+              taskId: ev.taskId,
+              reason: ev.reason,
+            },
+          }),
+        );
+
+      const enqueueSubagentEvent = (ev: {
+        agentId: string;
+        agentType: string;
+        status: "started" | "stopped";
+      }) =>
+        controller.enqueue(
+          sseData({
+            kind: "subagent",
+            subagent: {
+              kind: "subagent",
+              agentId: ev.agentId,
+              agentType: ev.agentType,
+              status: ev.status,
+            },
+          }),
+        );
+
+      try {
+        for await (const ev of streamChatReply({
+          userText,
+          taskId,
+          contextId,
+          resumeSessionId,
+          abortController,
+          onSessionId: (sid) => {
+            setSessionIdForContext({ contextId, sessionId: sid });
+            controller.enqueue(
+              sseData({
+                kind: "session",
+                sessionId: sid,
+                contextId,
+              }),
+            );
+          },
+          onToolEvent: enqueueToolCall,
+          onAskUserQuestion: enqueueAskUserQuestion,
+          onQuestionDismissed: enqueueQuestionDismissed,
+          onSubagentEvent: enqueueSubagentEvent,
+        })) {
+          if (isCancelRequested(taskId)) {
+            controller.enqueue(
+              sseData({
+                kind: "statusUpdate",
+                statusUpdate: {
+                  kind: "statusUpdate",
+                  taskId,
+                  status: {
+                    state: "cancelled",
+                    timestamp: new Date().toISOString(),
+                    message: "cancelled",
+                  },
+                  index: updateStatus(taskId, {
+                    state: "cancelled",
+                    timestamp: new Date().toISOString(),
+                    message: "cancelled",
+                  }),
+                  final: true,
+                },
+              }),
+            );
+            controller.close();
+            return;
+          }
+
+          if (ev.type === "token") {
+            assistantText += ev.text;
+            controller.enqueue(
+              sseData({
+                kind: "message",
+                message: {
+                  kind: "message",
+                  messageId: assistantMessageId,
+                  role: "agent",
+                  parts: [{ kind: "text", text: ev.text }],
+                  contextId,
+                },
+              }),
+            );
+          }
+
+          if (ev.type === "toolCall") {
+            // 兜底路径：仅当没有 onToolEvent callback 时才会触发
+            controller.enqueue(
+              sseData({
+                kind: "toolCall",
+                toolCall: {
+                  kind: "toolCall",
+                  toolName: ev.toolName,
+                  toolId: ev.toolId,
+                  input: ev.input,
+                  status: ev.status,
+                  output: ev.output,
+                  toolSeq: ev.toolSeq,
+                },
+              }),
+            );
+          }
+
+          if (ev.type === "subagent") {
+            controller.enqueue(
+              sseData({
+                kind: "subagent",
+                subagent: {
+                  kind: "subagent",
+                  agentId: ev.agentId,
+                  agentType: ev.agentType,
+                  status: ev.status,
+                },
+              }),
+            );
+          }
+        }
+
+        const finalMsg: A2aMessage = {
+          kind: "message",
+          messageId: assistantMessageId,
+          role: "agent",
+          parts: [{ kind: "text", text: assistantText }],
+          contextId,
+        };
+        appendHistory(taskId, finalMsg);
+
+        controller.enqueue(
+          sseData({
+            kind: "statusUpdate",
+            statusUpdate: {
+              kind: "statusUpdate",
+              taskId,
+              status: {
+                state: "completed",
+                timestamp: new Date().toISOString(),
+                message: "completed",
+              },
+              index: updateStatus(taskId, {
+                state: "completed",
+                timestamp: new Date().toISOString(),
+                message: "completed",
+              }),
+              final: true,
+            },
+          }),
+        );
+      } catch (e) {
+        const message = e instanceof Error ? e.message : "Unknown error";
+        controller.enqueue(
+          sseData({
+            kind: "statusUpdate",
+            statusUpdate: {
+              kind: "statusUpdate",
+              taskId,
+              status: {
+                state: "failed",
+                timestamp: new Date().toISOString(),
+                message,
+              },
+              index: updateStatus(taskId, {
+                state: "failed",
+                timestamp: new Date().toISOString(),
+                message,
+              }),
+              final: true,
+            },
+          }),
+        );
+      } finally {
+        markContextIdle(contextId);
+        controller.close();
+      }
+    },
+  });
+
+  return new Response(stream, {
+    headers: sseHeaders({
+      "A2A-Version": env.a2aVersion,
+    }),
+  });
+}