remotion-claude-agent-demo 0.1.0

package/apps/web/src/lib/hooks/useA2AChat.ts

@@ -0,0 +1,863 @@
+"use client";
+
+import { useCallback, useEffect, useMemo } from "react";
+import { useAtom } from "jotai";
+import { cancelA2aTask, streamA2aChat, streamA2aEvents, submitA2aAnswer } from "@/lib/a2a/client";
+import type {
+  A2aActivityEvent,
+  A2aAskUserQuestionEvent,
+  A2aQuestionDismissedEvent,
+  A2aSubagentEvent,
+  A2aToolCallEvent,
+} from "@/lib/a2a/types";
+import type { AgentToolBlock } from "@/lib/chat/types";
+import { currentSessionIdAtom, sessionsAtom } from "@/lib/state/chat-atoms";
+import type { ChatSession } from "@/lib/state/chat-atoms";
+
+export type { AgentBlock, AgentTextBlock, AgentToolBlock, ChatItem, PendingQuestion, SubagentActivity } from "@/lib/chat/types";
+
+type TaskToolInput = {
+  prompt?: string;
+  description?: string;
+  run_in_background?: boolean;
+  background?: boolean;
+  runInBackground?: boolean;
+};
+
+type SendArgs = {
+  text: string;
+  sessionId?: string;
+};
+
+const DEFAULT_TITLE = "New session";
+const TITLE_MAX_LEN = 48;
+
+function nowId(): string {
+  return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function createSession(): ChatSession {
+  const now = Date.now();
+  const id = globalThis.crypto?.randomUUID?.() ?? nowId();
+  return {
+    id,
+    title: DEFAULT_TITLE,
+    createdAt: now,
+    updatedAt: now,
+    contextId: undefined,
+    sessionId: undefined,
+    items: [],
+    isStreaming: false,
+    error: null,
+    activeTaskId: undefined,
+    pendingQuestion: null,
+    subagentActivities: [],
+    inputDraft: "",
+  };
+}
+
+function deriveTitle(text: string): string {
+  const firstLine = text.split("\n")[0]?.trim() ?? "";
+  if (!firstLine) return DEFAULT_TITLE;
+  if (firstLine.length <= TITLE_MAX_LEN) return firstLine;
+  return firstLine.slice(0, TITLE_MAX_LEN - 3).trimEnd() + "...";
+}
+
+type PendingTask = {
+  toolId: string;
+  prompt?: string;
+  description?: string;
+  isBackground?: boolean;
+};
+
+type SessionRuntime = {
+  abortController: AbortController | null;
+  activityAbortController: AbortController | null;
+  activityContextId: string | null;
+  lastActivityId: number;
+  deliveredMessageIds: Set<number>;
+  pendingTask: PendingTask | null;
+  activeAgentId: string | null;
+};
+
+const runtimeBySession = new Map<string, SessionRuntime>();
+
+function getRuntime(sessionId: string): SessionRuntime {
+  const existing = runtimeBySession.get(sessionId);
+  if (existing) return existing;
+  const created: SessionRuntime = {
+    abortController: null,
+    activityAbortController: null,
+    activityContextId: null,
+    lastActivityId: 0,
+    deliveredMessageIds: new Set(),
+    pendingTask: null,
+    activeAgentId: null,
+  };
+  runtimeBySession.set(sessionId, created);
+  return created;
+}
+
+function clearRuntime(sessionId: string): void {
+  runtimeBySession.delete(sessionId);
+}
+
+export function useA2AChat() {
+  const [sessions, setSessions] = useAtom(sessionsAtom);
+  const [currentSessionId, setCurrentSessionId] = useAtom(currentSessionIdAtom);
+
+  useEffect(() => {
+    setSessions((prev) =>
+      prev.map((session) => ({
+        ...session,
+        title: session.title || DEFAULT_TITLE,
+        createdAt: session.createdAt ?? Date.now(),
+        updatedAt: session.updatedAt ?? Date.now(),
+        items: session.items ?? [],
+        isStreaming: false,
+        error: null,
+        activeTaskId: undefined,
+        pendingQuestion: null,
+        subagentActivities: session.subagentActivities ?? [],
+        inputDraft: session.inputDraft ?? "",
+      })),
+    );
+  }, [setSessions]);
+
+  useEffect(() => {
+    if (sessions.length === 0) {
+      const session = createSession();
+      setSessions([session]);
+      setCurrentSessionId(session.id);
+      return;
+    }
+    if (!currentSessionId || !sessions.some((s) => s.id === currentSessionId)) {
+      setCurrentSessionId(sessions[0]?.id ?? null);
+    }
+  }, [currentSessionId, sessions, setCurrentSessionId, setSessions]);
+
+
+  const currentSession = useMemo(
+    () => sessions.find((s) => s.id === currentSessionId) ?? null,
+    [sessions, currentSessionId],
+  );
+
+  const updateSession = useCallback(
+    (
+      sessionId: string,
+      updater: (session: ChatSession) => ChatSession,
+      options?: { touch?: boolean },
+    ) => {
+      setSessions((prev) =>
+        prev.map((session) => {
+          if (session.id !== sessionId) return session;
+          const next = updater(session);
+          const touch = options?.touch !== false;
+          return {
+            ...next,
+            updatedAt: touch ? Date.now() : session.updatedAt,
+          };
+        }),
+      );
+    },
+    [setSessions],
+  );
+
+  const setInputDraft = useCallback(
+    (text: string, sessionId?: string) => {
+      const sid = sessionId ?? currentSessionId;
+      if (!sid) return;
+      updateSession(
+        sid,
+        (session) => ({ ...session, inputDraft: text }),
+        { touch: false },
+      );
+    },
+    [currentSessionId, updateSession],
+  );
+
+  const switchSession = useCallback(
+    (sessionId: string) => {
+      setCurrentSessionId(sessionId);
+    },
+    [setCurrentSessionId],
+  );
+
+  const newSession = useCallback(() => {
+    const session = createSession();
+    setSessions((prev) => [session, ...prev]);
+    setCurrentSessionId(session.id);
+  }, [setCurrentSessionId, setSessions]);
+
+  const stopSessionRuntime = useCallback((sessionId: string, taskId?: string) => {
+    const runtime = getRuntime(sessionId);
+    runtime.abortController?.abort();
+    runtime.abortController = null;
+    runtime.activityAbortController?.abort();
+    runtime.activityAbortController = null;
+    runtime.activityContextId = null;
+    runtime.pendingTask = null;
+    runtime.activeAgentId = null;
+    runtime.lastActivityId = 0;
+    runtime.deliveredMessageIds = new Set();
+
+    if (taskId) {
+      void cancelA2aTask({ taskId });
+    }
+  }, []);
+
+  const deleteSession = useCallback(
+    (sessionId: string) => {
+      const target = sessions.find((s) => s.id === sessionId);
+      stopSessionRuntime(sessionId, target?.activeTaskId);
+      clearRuntime(sessionId);
+      setSessions((prev) => {
+        const next = prev.filter((session) => session.id !== sessionId);
+        if (next.length === 0) {
+          const fresh = createSession();
+          setCurrentSessionId(fresh.id);
+          return [fresh];
+        }
+        if (currentSessionId === sessionId) {
+          setCurrentSessionId(next[0].id);
+        }
+        return next;
+      });
+    },
+    [currentSessionId, sessions, setCurrentSessionId, setSessions, stopSessionRuntime],
+  );
+
+  const cancel = useCallback(() => {
+    if (!currentSession) return;
+    stopSessionRuntime(currentSession.id, currentSession.activeTaskId);
+    updateSession(currentSession.id, (session) => ({ ...session, isStreaming: false }), {
+      touch: false,
+    });
+  }, [currentSession, stopSessionRuntime, updateSession]);
+
+  const submitAnswer = useCallback(
+    async (answers: Record<string, string>) => {
+      if (!currentSession?.pendingQuestion) return;
+      const pending = currentSession.pendingQuestion;
+      try {
+        await submitA2aAnswer({
+          requestId: pending.requestId,
+          taskId: pending.taskId,
+          answers,
+        });
+        updateSession(
+          currentSession.id,
+          (session) => ({ ...session, pendingQuestion: null }),
+          { touch: false },
+        );
+      } catch (e) {
+        updateSession(
+          currentSession.id,
+          (session) => ({
+            ...session,
+            error: e instanceof Error ? e.message : "Failed to submit answer",
+          }),
+          { touch: false },
+        );
+      }
+    },
+    [currentSession, updateSession],
+  );
+
+  const upsertBackgroundActivity = useCallback(
+    (sessionId: string, event: A2aActivityEvent) => {
+      if (event.kind !== "backgroundTask") return;
+      const data = event.data;
+      const status =
+        data.status === "completed" || data.status === "failed" || data.status === "cancelled"
+          ? "stopped"
+          : "running";
+      const startedAt = data.startedAt ?? data.createdAt ?? Date.now();
+      const stoppedAt = data.finishedAt;
+      const result =
+        data.result ??
+        (data.status === "cancelled"
+          ? "Cancelled"
+          : data.error
+            ? `Error: ${data.error}`
+            : undefined);
+
+      updateSession(
+        sessionId,
+        (session) => {
+          const existing = session.subagentActivities.find((a) => a.agentId === data.jobId);
+          if (!existing) {
+            return {
+              ...session,
+              subagentActivities: [
+                ...session.subagentActivities,
+                {
+                  agentId: data.jobId,
+                  agentType: data.subagentType || "background",
+                  status,
+                  startedAt,
+                  stoppedAt,
+                  isBackground: true,
+                  prompt: data.prompt,
+                  description: data.description,
+                  result,
+                },
+              ],
+            };
+          }
+
+          return {
+            ...session,
+            subagentActivities: session.subagentActivities.map((a) =>
+              a.agentId === data.jobId
+                ? {
+                    ...a,
+                    agentType: data.subagentType || a.agentType,
+                    status,
+                    startedAt: a.startedAt ?? startedAt,
+                    stoppedAt: stoppedAt ?? a.stoppedAt,
+                    isBackground: true,
+                    prompt: data.prompt ?? a.prompt,
+                    description: data.description ?? a.description,
+                    result: result ?? a.result,
+                  }
+                : a,
+            ),
+          };
+        },
+        { touch: false },
+      );
+    },
+    [updateSession],
+  );
+
+  const upsertTodoActivity = useCallback(
+    (sessionId: string, event: A2aActivityEvent) => {
+      if (event.kind !== "todoUpdate") return;
+      const data = event.data;
+      updateSession(
+        sessionId,
+        (session) => {
+          const existing = session.subagentActivities.find((a) => a.agentId === data.jobId);
+          if (!existing) {
+            return {
+              ...session,
+              subagentActivities: [
+                ...session.subagentActivities,
+                {
+                  agentId: data.jobId,
+                  agentType: "background",
+                  status: "running",
+                  startedAt: data.updatedAt,
+                  isBackground: true,
+                  todos: data.todos,
+                  todoUpdatedAt: data.updatedAt,
+                },
+              ],
+            };
+          }
+
+          return {
+            ...session,
+            subagentActivities: session.subagentActivities.map((a) =>
+              a.agentId === data.jobId
+                ? { ...a, todos: data.todos, todoUpdatedAt: data.updatedAt }
+                : a,
+            ),
+          };
+        },
+        { touch: false },
+      );
+    },
+    [updateSession],
+  );
+
+  const appendDeliveryMessage = useCallback(
+    (sessionId: string, event: A2aActivityEvent) => {
+      if (event.kind !== "deliveryMessage") return;
+      const runtime = getRuntime(sessionId);
+      if (runtime.deliveredMessageIds.has(event.id)) return;
+      runtime.deliveredMessageIds.add(event.id);
+      const data = event.data;
+      if (!data.text) return;
+      const isDelta = data.isDelta === true;
+      updateSession(
+        sessionId,
+        (session) => {
+          const upsertIndex =
+            data.jobId
+              ? session.items.findIndex(
+                  (it) => it.role === "agent" && it.jobId === data.jobId,
+                )
+              : -1;
+
+          if (isDelta) {
+            const items = [...session.items];
+            if (upsertIndex < 0) {
+              items.push({
+                id: nowId(),
+                role: "agent",
+                jobId: data.jobId,
+                blocks: [{ kind: "text", text: data.text }],
+              });
+              return { ...session, items };
+            }
+
+            const target = items[upsertIndex];
+            if (target.role !== "agent") return { ...session, items };
+            const blocks = [...target.blocks];
+            const last = blocks[blocks.length - 1];
+            if (last?.kind === "text") {
+              blocks[blocks.length - 1] = { kind: "text", text: last.text + data.text };
+            } else {
+              blocks.push({ kind: "text", text: data.text });
+            }
+            items[upsertIndex] = { ...target, blocks };
+            return { ...session, items };
+          }
+
+          if (upsertIndex >= 0) {
+            const items = [...session.items];
+            const current = items[upsertIndex];
+            if (current.role === "agent") {
+              items[upsertIndex] = {
+                ...current,
+                jobId: data.jobId,
+                blocks: [{ kind: "text", text: data.text }],
+              };
+            }
+            return { ...session, items };
+          }
+
+          return {
+            ...session,
+            items: [
+              ...session.items,
+              {
+                id: nowId(),
+                role: "agent",
+                jobId: data.jobId,
+                blocks: [{ kind: "text", text: data.text }],
+              },
+            ],
+          };
+        },
+        { touch: true },
+      );
+    },
+    [updateSession],
+  );
+
+  const startActivityStream = useCallback(
+    (sessionId: string, ctxId: string) => {
+      const runtime = getRuntime(sessionId);
+      if (runtime.activityContextId === ctxId && runtime.activityAbortController) {
+        return;
+      }
+
+      runtime.activityAbortController?.abort();
+      const abort = new AbortController();
+      runtime.activityAbortController = abort;
+      runtime.activityContextId = ctxId;
+
+      const run = async () => {
+        let attempt = 0;
+        while (!abort.signal.aborted) {
+          try {
+            await streamA2aEvents({
+              contextId: ctxId,
+              since: runtime.lastActivityId,
+              signal: abort.signal,
+              callbacks: {
+                onActivity: (event) => {
+                  runtime.lastActivityId = event.id;
+                  upsertBackgroundActivity(sessionId, event);
+                  upsertTodoActivity(sessionId, event);
+                  appendDeliveryMessage(sessionId, event);
+                },
+                onError: (err) => {
+                  if (abort.signal.aborted) return;
+                  console.warn("Activity stream error", err);
+                },
+              },
+            });
+          } catch (err) {
+            if (abort.signal.aborted) return;
+            console.warn("Activity stream disconnected", err);
+          }
+
+          if (abort.signal.aborted) return;
+          attempt += 1;
+          const delayMs = Math.min(1000 * 2 ** attempt, 15000);
+          await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+      };
+
+      void run();
+    },
+    [appendDeliveryMessage, upsertBackgroundActivity, upsertTodoActivity],
+  );
+
+  useEffect(() => {
+    if (!currentSession?.contextId || !currentSession) return;
+    startActivityStream(currentSession.id, currentSession.contextId);
+  }, [currentSession, startActivityStream]);
+
+  const send = useCallback(
+    async ({ text, sessionId }: SendArgs) => {
+      const sid = sessionId ?? currentSessionId;
+      if (!sid) return;
+      const session = sessions.find((s) => s.id === sid);
+      if (!session || session.isStreaming) return;
+
+      const userId = nowId();
+      const agentId = nowId();
+      const runtime = getRuntime(sid);
+      runtime.activeAgentId = agentId;
+      runtime.pendingTask = null;
+
+      updateSession(
+        sid,
+        (prev) => ({
+          ...prev,
+          title: prev.title === DEFAULT_TITLE ? deriveTitle(text) : prev.title,
+          items: [
+            ...prev.items,
+            { id: userId, role: "user", text },
+            { id: agentId, role: "agent", blocks: [] },
+          ],
+          isStreaming: true,
+          error: null,
+          activeTaskId: undefined,
+          inputDraft: "",
+        }),
+        { touch: true },
+      );
+
+      const abort = new AbortController();
+      runtime.abortController?.abort();
+      runtime.abortController = abort;
+
+      try {
+        await streamA2aChat({
+          text,
+          contextId: session.contextId,
+          sessionId: session.sessionId,
+          signal: abort.signal,
+          callbacks: {
+            onOpen: ({ taskId, contextId: ctx }) => {
+              updateSession(
+                sid,
+                (prev) => ({
+                  ...prev,
+                  activeTaskId: taskId,
+                  contextId: ctx ?? prev.contextId,
+                  items: prev.items.map((it) =>
+                    it.role === "agent" && it.id === agentId ? { ...it, taskId } : it,
+                  ),
+                }),
+                { touch: false },
+              );
+              if (ctx) startActivityStream(sid, ctx);
+            },
+            onSessionId: (sessionId) => {
+              updateSession(
+                sid,
+                (prev) => ({ ...prev, sessionId }),
+                { touch: false },
+              );
+            },
+            onDelta: (deltaText) => {
+              updateSession(
+                sid,
+                (prev) => ({
+                  ...prev,
+                  items: prev.items.map((it) => {
+                    if (it.role !== "agent" || it.id !== agentId) return it;
+                    const blocks = [...it.blocks];
+                    const last = blocks[blocks.length - 1];
+                    if (last?.kind === "text") {
+                      blocks[blocks.length - 1] = {
+                        kind: "text",
+                        text: last.text + deltaText,
+                      };
+                    } else {
+                      blocks.push({ kind: "text", text: deltaText });
+                    }
+                    return { ...it, blocks };
+                  }),
+                }),
+                { touch: false },
+              );
+            },
+            onToolCall: (tc: A2aToolCallEvent) => {
+              if (tc.toolName === "Task") {
+                if (tc.status === "started" && tc.input) {
+                  const input = tc.input as TaskToolInput;
+                  const isBackground =
+                    input.run_in_background === true ||
+                    input.background === true ||
+                    input.runInBackground === true;
+                  runtime.pendingTask = {
+                    toolId: tc.toolId,
+                    prompt: input.prompt,
+                    description: input.description,
+                    isBackground,
+                  };
+                } else if (tc.status === "completed") {
+                  const output = tc.output;
+                  if (output) {
+                    const outputStr =
+                      typeof output === "string" ? output : JSON.stringify(output);
+                    updateSession(
+                      sid,
+                      (prev) => {
+                        const lastRunning = [...prev.subagentActivities]
+                          .reverse()
+                          .find((a) => a.status === "running" || !a.result);
+                        if (!lastRunning) return prev;
+                        return {
+                          ...prev,
+                          subagentActivities: prev.subagentActivities.map((a) =>
+                            a.agentId === lastRunning.agentId
+                              ? { ...a, result: outputStr.slice(0, 2000) }
+                              : a,
+                          ),
+                        };
+                      },
+                      { touch: false },
+                    );
+                  }
+                  runtime.pendingTask = null;
+                }
+              }
+
+              updateSession(
+                sid,
+                (prev) => ({
+                  ...prev,
+                  items: prev.items.map((it) => {
+                    if (it.role !== "agent" || it.id !== agentId) return it;
+                    const blocks = [...it.blocks];
+                    let idx = -1;
+                    if (tc.toolSeq !== undefined) {
+                      idx = blocks.findIndex(
+                        (b) => b.kind === "tool" && (b as AgentToolBlock).toolSeq === tc.toolSeq,
+                      );
+                    }
+                    if (idx < 0 && tc.toolId) {
+                      idx = blocks.findIndex(
+                        (b) => b.kind === "tool" && b.toolId === tc.toolId,
+                      );
+                    }
+                    if (idx < 0 && tc.status === "completed") {
+                      idx = blocks.findIndex(
+                        (b) =>
+                          b.kind === "tool" &&
+                          b.toolName === tc.toolName &&
+                          (b as AgentToolBlock).status === "started",
+                      );
+                    }
+
+                    const existing =
+                      idx >= 0 && blocks[idx].kind === "tool"
+                        ? (blocks[idx] as AgentToolBlock)
+                        : null;
+                    const newBlock: AgentToolBlock = {
+                      kind: "tool",
+                      toolId: tc.toolId || existing?.toolId || "",
+                      toolName: tc.toolName,
+                      input:
+                        tc.input !== undefined && tc.input !== null
+                          ? tc.input
+                          : existing?.input,
+                      status: tc.status,
+                      output: tc.output ?? existing?.output,
+                      toolSeq: tc.toolSeq ?? existing?.toolSeq,
+                    };
+                    if (idx >= 0) {
+                      blocks[idx] = newBlock;
+                    } else {
+                      blocks.push(newBlock);
+                    }
+                    return { ...it, blocks };
+                  }),
+                }),
+                { touch: false },
+              );
+            },
+            onAskUserQuestion: (event: A2aAskUserQuestionEvent) => {
+              updateSession(
+                sid,
+                (prev) => ({
+                  ...prev,
+                  pendingQuestion: {
+                    requestId: event.requestId,
+                    taskId: event.taskId,
+                    questions: event.questions,
+                  },
+                }),
+                { touch: false },
+              );
+            },
+            onQuestionDismissed: (event: A2aQuestionDismissedEvent) => {
+              updateSession(
+                sid,
+                (prev) => ({
+                  ...prev,
+                  pendingQuestion:
+                    prev.pendingQuestion?.requestId === event.requestId
+                      ? null
+                      : prev.pendingQuestion,
+                }),
+                { touch: false },
+              );
+            },
+            onSubagent: (event: A2aSubagentEvent) => {
+              updateSession(
+                sid,
+                (prev) => {
+                  if (event.status === "started") {
+                    const exists = prev.subagentActivities.find(
+                      (a) => a.agentId === event.agentId,
+                    );
+                    if (exists) {
+                      return {
+                        ...prev,
+                        subagentActivities: prev.subagentActivities.map((a) =>
+                          a.agentId === event.agentId
+                            ? { ...a, status: "running" as const }
+                            : a,
+                        ),
+                      };
+                    }
+                    const pending = runtime.pendingTask;
+                    return {
+                      ...prev,
+                      subagentActivities: [
+                        ...prev.subagentActivities,
+                        {
+                          agentId: event.agentId,
+                          agentType: event.agentType,
+                          status: "running" as const,
+                          startedAt: Date.now(),
+                          isBackground: pending?.isBackground,
+                          prompt: pending?.prompt,
+                          description: pending?.description,
+                        },
+                      ],
+                    };
+                  }
+
+                  return {
+                    ...prev,
+                    subagentActivities: prev.subagentActivities.map((a) =>
+                      a.agentId === event.agentId
+                        ? { ...a, status: "stopped" as const, stoppedAt: Date.now() }
+                        : a,
+                    ),
+                  };
+                },
+                { touch: false },
+              );
+            },
+            onFinal: () => {
+              runtime.abortController = null;
+              updateSession(
+                sid,
+                (prev) => ({
+                  ...prev,
+                  isStreaming: false,
+                  items: prev.items.map((it) => {
+                    if (it.role !== "agent" || it.id !== agentId) return it;
+                    const blocks = it.blocks.map((b) => {
+                      if (b.kind === "tool" && (b as AgentToolBlock).status === "started") {
+                        return {
+                          ...b,
+                          status: "completed" as const,
+                          output: (b as AgentToolBlock).output,
+                        };
+                      }
+                      return b;
+                    });
+                    return { ...it, blocks };
+                  }),
+                }),
+                { touch: false },
+              );
+            },
+            onError: (err) => {
+              runtime.abortController = null;
+              updateSession(
+                sid,
+                (prev) => ({ ...prev, error: err.message, isStreaming: false }),
+                { touch: false },
+              );
+            },
+          },
+        });
+      } catch (e) {
+        if (abort.signal.aborted) return;
+        runtime.abortController = null;
+        updateSession(
+          sid,
+          (prev) => ({
+            ...prev,
+            error: e instanceof Error ? e.message : "Unknown error",
+            isStreaming: false,
+          }),
+          { touch: false },
+        );
+      }
+    },
+    [currentSessionId, sessions, startActivityStream, updateSession],
+  );
+
+  const value = useMemo(
+    () => {
+      const items = currentSession?.items ?? [];
+      const isStreaming = currentSession?.isStreaming ?? false;
+      const error = currentSession?.error ?? null;
+      const contextId = currentSession?.contextId;
+      const activeTaskId = currentSession?.activeTaskId;
+      const pendingQuestion = currentSession?.pendingQuestion ?? null;
+      const subagentActivities = currentSession?.subagentActivities ?? [];
+      const inputDraft = currentSession?.inputDraft ?? "";
+
+      return {
+        sessions,
+        currentSessionId,
+        currentSession,
+        items,
+        isStreaming,
+        error,
+        contextId,
+        activeTaskId,
+        pendingQuestion,
+        subagentActivities,
+        inputDraft,
+        send,
+        cancel,
+        newSession,
+        switchSession,
+        deleteSession,
+        setInputDraft,
+        submitAnswer,
+      };
+    },
+    [
+      cancel,
+      currentSession,
+      currentSessionId,
+      deleteSession,
+      newSession,
+      send,
+      sessions,
+      setInputDraft,
+      submitAnswer,
+      switchSession,
+    ],
+  );
+
+  return value;
+}