@agent-native/toolkit 0.198.3 → 0.198.5

package/src/app/agentkit/react/lifecycle.spec.tsx

@@ -21,6 +21,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { AgentChat } from "./chat.js";
 import {
   AgentActivityGroup,
+  AgentConnectionRequestCard,
   AgentKitChat,
   AgentMessageActions,
   formatAgentKitDuration,
@@ -3160,6 +3161,47 @@ describe("AgentKit subscriptions and recovery", () => {
     });
   });
 
+  it("leaves a workspace request pending while its connection callback redirects", async () => {
+    const threadId = "thread-workspace-connection";
+    const store = observableController({
+      connection: "connected",
+      capabilities: { connectionRequests: true },
+      capabilitiesStatus: "ready",
+      threads: { [threadId]: createAgentThreadState(threadId) },
+      revision: 1,
+    });
+    const request = {
+      id: "connection-google-drive",
+      provider: "google_drive",
+      reason: "connect" as const,
+      status: "requested" as const,
+    };
+    const onConnect = vi.fn(async () => undefined);
+    const tree = mount();
+
+    await tree.render(
+      <AgentKitProvider controller={store.controller} threadId={threadId}>
+        <AgentConnectionRequestCard
+          request={request}
+          runId="run-1"
+          providerLabel="Google Drive"
+          onConnect={onConnect}
+        />
+      </AgentKitProvider>,
+    );
+    const button = Array.from(tree.container.querySelectorAll("button")).find(
+      (candidate) => candidate.textContent === "Connect",
+    );
+    await act(async () => {
+      button?.click();
+      await Promise.resolve();
+    });
+
+    expect(tree.container.textContent).toContain("Connect Google Drive");
+    expect(onConnect).toHaveBeenCalledWith(request);
+    expect(store.controller.resolveConnectionRequest).not.toHaveBeenCalled();
+  });
+
   it("renders a pre-connection-request controller projection", async () => {
     const legacyThread = createAgentThreadState("thread-legacy") as ReturnType<
       typeof createAgentThreadState

package/src/app/chat/AgentKitAssistantChat.spec.tsx

@@ -234,6 +234,18 @@ vi.mock("../agentkit/react/root.js", async () => {
   return {
     AgentKitRoot: (props: any) => {
       chatMocks.rootProps = props;
+      if (chatMocks.useRealRoot) {
+        return React.createElement(actual.AgentKitRoot, {
+          ...props,
+          ...(chatMocks.realComposerController
+            ? {
+                controller: chatMocks.realComposerController,
+                transport: undefined,
+                endpoint: undefined,
+              }
+            : {}),
+        });
+      }
       if (chatMocks.realComposerController) {
         return React.createElement(AgentKitProvider, {
           ...props,
@@ -747,6 +759,29 @@ afterEach(async () => {
 });
 
 describe("AgentKitAssistantChat host behavior", () => {
+  it("shows a retry when chat history fails to load", async () => {
+    const retryHistory = vi.fn();
+    chatMocks.history = {
+      historyLoadFailed: true,
+      isRetryingHistory: false,
+      retryHistory,
+    };
+
+    await mount(baseProps());
+
+    expect(container.querySelector('[role="alert"]')?.textContent).toContain(
+      "agentChat.message.historyUnavailable",
+    );
+    const retry = [...container.querySelectorAll("button")].find(
+      (button) => button.textContent === "agentChat.common.retry",
+    );
+    expect(retry).toBeDefined();
+
+    await act(async () => retry?.click());
+
+    expect(retryHistory).toHaveBeenCalledOnce();
+  });
+
   it("shows Thinking in the transcript while a submitted user message is pending", async () => {
     chatMocks.history = { isSubmissionInFlight: true };
     chatMocks.thread.messages = [
@@ -759,11 +794,29 @@ describe("AgentKitAssistantChat host behavior", () => {
     ];
     await mount(baseProps());
 
+    expect(chatMocks.composerProps.disabled).toBe(false);
+    expect(chatMocks.composerProps.submissionDisabled).toBe(true);
+    expect(chatMocks.composerProps.announcePendingSubmission).toBe(false);
     expect(container.querySelector('[role="status"]')?.textContent).toBe(
       "agentChat.status.thinking",
     );
   });
 
+  it("keeps the pending announcement when the transcript has no visible user message", async () => {
+    chatMocks.history = { isSubmissionInFlight: true };
+    chatMocks.thread.messages = [
+      {
+        id: "assistant-last",
+        role: "assistant",
+        parts: [{ type: "text", text: "Earlier response" }],
+      },
+    ];
+    await mount(baseProps());
+
+    expect(chatMocks.composerProps.announcePendingSubmission).toBe(true);
+    expect(container.querySelector('[role="status"]')).toBeNull();
+  });
+
   it("gives JS callers a migration error for the removed createAdapter prop", async () => {
     const errors: Error[] = [];
     container = document.createElement("div");
@@ -847,6 +900,29 @@ describe("AgentKitAssistantChat host behavior", () => {
     return client;
   }
 
+  it("keeps the real editor editable while a submission is in flight", async () => {
+    chatMocks.useRealChat = true;
+    chatMocks.history = { isSubmissionInFlight: true };
+    await useRealComposer();
+    await mount(baseProps({ showModelSelector: false }));
+
+    const editor = container.querySelector<HTMLElement>(
+      '[contenteditable="true"]',
+    );
+    expect(editor).not.toBeNull();
+    expect(chatMocks.composerProps.submissionDisabled).toBe(true);
+
+    await act(async () =>
+      chatMocks.composerProps.composerRef.current.setText("Keep this draft"),
+    );
+    expect(editor?.textContent).toBe("Keep this draft");
+    expect(
+      container.querySelector<HTMLButtonElement>(
+        '[data-agent-composer-slot="send-button"]',
+      )?.disabled,
+    ).toBe(true);
+  });
+
   it.each(["default", "compact"] as const)(
     "clears the real %s composer before startRun resolves and preserves the next draft",
     async (composerLayoutVariant) => {
@@ -855,12 +931,13 @@ describe("AgentKitAssistantChat host behavior", () => {
       chatMocks.useRealChat = true;
       const client = await useRealComposer(startRun);
       try {
-        await mount(
-          baseProps({
-            composerLayoutVariant,
-            showModelSelector: false,
-          }),
-        );
+        const props = baseProps({
+          composerLayoutVariant,
+          showModelSelector: false,
+        });
+        const openThread = vi.spyOn(client, "openThread");
+        chatMocks.useRealRoot = true;
+        await mount(props);
         container.style.width =
           composerLayoutVariant === "compact" ? "320px" : "960px";
         const composer = chatMocks.composerProps.composerRef.current;
@@ -884,6 +961,18 @@ describe("AgentKitAssistantChat host behavior", () => {
         expect(client.getThread(chatMocks.threadId).activeRunIds).toEqual([]);
         expect(editor.textContent).toBe("");
 
+        await act(async () =>
+          root.render(<AgentKitAssistantChat {...props} isNewThread={false} />),
+        );
+        await flush();
+
+        expect(chatMocks.rootProps.load).toBe("manual");
+        expect(openThread).not.toHaveBeenCalled();
+        expect(
+          container
+            .querySelector<HTMLElement>("[contenteditable]")
+            ?.getAttribute("contenteditable"),
+        ).toBe("true");
         await act(async () => composer.setText("Next draft"));
         await act(async () => started.resolve({ runId: "run-latency" }));
 
@@ -933,6 +1022,28 @@ describe("AgentKitAssistantChat host behavior", () => {
     },
   );
 
+  it("disables host suggestions while async submission is pending", async () => {
+    const suggestion = seedFollowup();
+    await mount(baseProps());
+    const chips = () =>
+      [...container.querySelectorAll("button")].filter(
+        (button) => button.textContent === suggestion.label,
+      );
+    expect(chips().length).toBeGreaterThan(0);
+    expect(chips().some((button) => button.disabled)).toBe(false);
+
+    await act(async () => {
+      chatMocks.composerProps.onSubmissionPendingChange(true);
+    });
+
+    expect(chips().every((button) => button.disabled)).toBe(true);
+
+    await act(async () => {
+      chatMocks.composerProps.onSubmissionPendingChange(false);
+    });
+    expect(chips().every((button) => !button.disabled)).toBe(true);
+  });
+
   it.each([undefined, "context-chips", "after-composer", "hidden"] as const)(
     "preserves initial starters with the real composer (placement: %s)",
     async (suggestionPlacement) => {
@@ -1585,7 +1696,7 @@ describe("AgentKitAssistantChat host behavior", () => {
     expect(chatMocks.appState.has(stateKey!)).toBe(false);
   });
 
-  it("keeps a queued follow-up queued if its run finishes during provider discovery", async () => {
+  it("preserves queued intent when its run finishes during provider discovery", async () => {
     chatMocks.readiness = {
       canChat: false,
       missing: false,
@@ -1611,12 +1722,27 @@ describe("AgentKitAssistantChat host behavior", () => {
         [],
         [],
         { intent: "queued" },
+        async () => ({}),
       );
     });
 
     expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
     expect(chatMocks.control.queueMessage).not.toHaveBeenCalled();
 
+    const stateKey = [...chatMocks.appState.keys()].find((key) =>
+      key.startsWith("agentkit-deferred-provider-submissions:"),
+    );
+    expect(chatMocks.appState.get(stateKey!)).toMatchObject({
+      submissions: [
+        {
+          composerOptions: {
+            intent: "queued",
+            queuedWhileRunActive: true,
+          },
+        },
+      ],
+    });
+
     chatMocks.thread.activeRunIds = [];
     chatMocks.thread.runs["analytics-run"].status = "completed";
     chatMocks.readiness = {
@@ -1640,6 +1766,7 @@ describe("AgentKitAssistantChat host behavior", () => {
       }),
     );
     expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
+    expect(chatMocks.appState.has(stateKey!)).toBe(false);
   });
 
   it("keeps the draft rejected if provider status becomes missing before submit", async () => {
@@ -3338,11 +3465,11 @@ describe("AgentKitAssistantChat host behavior", () => {
     chatMocks.thread.activeRunIds = ["run-1"];
     await mount(baseProps());
 
-    await act(async () => {
-      await chatMocks.resumeProps.onMessageResume({
-        message: "Continue after connecting the integration.",
-      });
+    const resume = chatMocks.resumeProps.onMessageResume({
+      message: "Continue after connecting the integration.",
     });
+    expect(resume).toBeInstanceOf(Promise);
+    await act(async () => resume);
     expect(chatMocks.control.queueMessage).toHaveBeenCalledWith(
       expect.objectContaining({
         text: "Continue after connecting the integration.",
@@ -3382,6 +3509,19 @@ describe("AgentKitAssistantChat host behavior", () => {
     expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
   });
 
+  it("keeps failed integration prompt submissions resumable", async () => {
+    chatMocks.thread.activeRunIds = ["run-1"];
+    const submissionError = new Error("Temporary send failure");
+    chatMocks.control.queueMessage.mockRejectedValueOnce(submissionError);
+    await mount(baseProps());
+
+    await expect(
+      chatMocks.resumeProps.onMessageResume({
+        message: "Continue after OAuth.",
+      }),
+    ).rejects.toBe(submissionError);
+  });
+
   it("shows the missing-final-response warning from recovered run metadata", async () => {
     chatMocks.thread.messages = [
       {

package/src/app/chat/AgentKitAssistantChat.tsx

@@ -460,6 +460,15 @@ type AgentKitSuggestionSubmitOptions = PromptComposerSubmitOptions & {
   queuedWhileRunActive?: boolean;
 };
 
+function preserveQueuedIntent(
+  preparedOptions: PromptComposerSubmitOptions,
+  originalOptions: PromptComposerSubmitOptions,
+): PromptComposerSubmitOptions {
+  return originalOptions.intent === "queued"
+    ? { ...preparedOptions, intent: "queued" }
+    : preparedOptions;
+}
+
 function captureQueuedRunState(
   options: PromptComposerSubmitOptions,
   runWasActive: boolean,
@@ -502,6 +511,9 @@ interface AgentKitSurfaceContextValue {
   setupBouncePulse: number;
   bounceSetupCard: () => void;
   isSubmissionInFlight: boolean;
+  composerSubmissionPending: boolean;
+  onComposerSubmissionPendingChange: (pending: boolean) => void;
+  isThinkingVisibleInTranscript: boolean;
   contextItems: AgentChatContextItem[];
   suggestions: AgentSuggestionInput[];
   showSuggestions: boolean;
@@ -594,8 +606,13 @@ export const AgentKitAssistantChat = forwardRef<
       : readAgentKitThreadHandoffSnapshot(
           createAgentKitThreadHandoffKey(props, threadId),
         );
+  const [manualLoadThreadId, setManualLoadThreadId] = useState<string | null>(
+    () => (props.isNewThread ? threadId : null),
+  );
+  const hasManualLoadForCurrentThread =
+    props.isNewThread || manualLoadThreadId === threadId;
   const [threadRestore, setThreadRestore] = useState<ThreadRestoreState>(() =>
-    props.isThreadStateLoading || !props.isNewThread
+    props.isThreadStateLoading || !hasManualLoadForCurrentThread
       ? { status: "loading" }
       : { status: "ready" },
   );
@@ -611,15 +628,25 @@ export const AgentKitAssistantChat = forwardRef<
     setRestoreRetryLoadPhase("idle");
     setRestoreRetryThreadId(null);
   }, []);
+  useEffect(() => {
+    setManualLoadThreadId((current) =>
+      props.isNewThread ? threadId : current === threadId ? current : null,
+    );
+  }, [props.isNewThread, threadId]);
   useEffect(() => {
     setThreadRestore(
-      props.isThreadStateLoading || !props.isNewThread
+      props.isThreadStateLoading || !hasManualLoadForCurrentThread
         ? { status: "loading" }
         : { status: "ready" },
     );
     setRestoreRetryLoadPhase("idle");
     setRestoreRetryThreadId(null);
-  }, [props.isNewThread, props.isThreadStateLoading, threadId]);
+  }, [
+    hasManualLoadForCurrentThread,
+    props.isNewThread,
+    props.isThreadStateLoading,
+    threadId,
+  ]);
   const onThreadRestoreLoadError = useCallback(
     (error: unknown) => {
       const record = asRecord(error);
@@ -989,7 +1016,7 @@ export const AgentKitAssistantChat = forwardRef<
   ]);
   const agentKitLoad =
     props.isThreadStateLoading ||
-    props.isNewThread ||
+    hasManualLoadForCurrentThread ||
     (restoreRetryThreadId === threadId && restoreRetryLoadPhase === "release")
       ? "manual"
       : "auto";
@@ -1125,6 +1152,8 @@ const AgentKitAssistantChatBody = forwardRef<
   const isRestoring =
     history?.isRestoring === true || props.threadRestore.status === "loading";
   const isSubmissionInFlight = history?.isSubmissionInFlight === true;
+  const [composerSubmissionPending, setComposerSubmissionPending] =
+    useState(false);
   const [authError, setAuthError] = useState<{
     sessionExpired?: boolean;
   } | null>(null);
@@ -1271,6 +1300,11 @@ const AgentKitAssistantChatBody = forwardRef<
     [thread.messages],
   );
   const isRunning = hasActiveAgentRuns(thread);
+  const lastMessage = thread.messages.at(-1);
+  const isThinkingVisibleInTranscript =
+    (isRunning || isSubmissionInFlight) &&
+    lastMessage?.role === "user" &&
+    lastMessage.metadata?.hideUserMessage !== true;
   const isThreadRunning = useCallback(
     () => hasActiveAgentRuns(controller.getThread(threadId)),
     [controller, threadId],
@@ -2204,7 +2238,7 @@ const AgentKitAssistantChatBody = forwardRef<
           try {
             const preparedOptions = prepare ? await prepare() : composerOptions;
             const submittedOptions = captureQueuedRunState(
-              preparedOptions,
+              preserveQueuedIntent(preparedOptions, composerOptions),
               runWasActiveAtSubmit,
             );
             const result = await submit(
@@ -2231,7 +2265,10 @@ const AgentKitAssistantChatBody = forwardRef<
           text,
           files,
           references,
-          captureQueuedRunState(preparedOptions, runWasActiveAtSubmit),
+          captureQueuedRunState(
+            preserveQueuedIntent(preparedOptions, composerOptions),
+            runWasActiveAtSubmit,
+          ),
         );
       } catch (error) {
         dispatchSetupRequiredEvent(error, props.tabId, threadId);
@@ -2552,23 +2589,32 @@ const AgentKitAssistantChatBody = forwardRef<
     [isThreadRunning, submit],
   );
   const resumeIntegrationPrompt = useCallback(
-    (message: string) => {
-      if (props.isActiveComposer === false) return;
-      void send(message).catch((error) => {
+    async (message: string) => {
+      if (props.isActiveComposer === false) {
+        throw new Error("Cannot resume a request in an inactive chat.");
+      }
+      try {
+        const result = await send(message);
+        if (result.status === "rejected") {
+          throw new Error(`Chat resume was rejected: ${result.reason}.`);
+        }
+      } catch (error) {
         dispatchSetupRequiredEvent(error, props.tabId, threadId);
-      });
+        throw error;
+      }
     },
     [props.isActiveComposer, props.tabId, send, threadId],
   );
   const submitSuggestion = useCallback(
     (suggestion: AgentSuggestionInput) => {
+      if (composerSubmissionPending) return;
       const handler = suggestionSubmitRef.current;
       if (!handler || handler.threadId !== threadId) return;
       void handler.submit(suggestion).catch((error) => {
         dispatchSetupRequiredEvent(error, props.tabId, threadId);
       });
     },
-    [props.tabId, threadId],
+    [composerSubmissionPending, props.tabId, threadId],
   );
   const retryDeferredSubmission = useCallback(async () => {
     if (!deferredProviderSubmissionFailureId) return;
@@ -2748,6 +2794,9 @@ const AgentKitAssistantChatBody = forwardRef<
     setupBouncePulse,
     bounceSetupCard,
     isSubmissionInFlight,
+    composerSubmissionPending,
+    onComposerSubmissionPendingChange: setComposerSubmissionPending,
+    isThinkingVisibleInTranscript,
     contextItems,
     voiceTranscriptMessages,
     selectionLength,
@@ -2775,15 +2824,19 @@ const AgentKitAssistantChatBody = forwardRef<
             { threadId: targetThreadId, runId, requestId },
             request,
           ) => {
-            if (targetThreadId !== threadId) return;
+            if (targetThreadId !== threadId) {
+              throw new Error(
+                "Cannot resume a connection request in another chat.",
+              );
+            }
             return control.resolveConnectionRequest(runId, requestId, {
               status: "connected",
               message: request.message,
             });
           }}
-          onMessageResume={(request) => {
-            resumeIntegrationPrompt(request.message);
-          }}
+          onMessageResume={(request) =>
+            resumeIntegrationPrompt(request.message)
+          }
         />
       )}
       <RunStuckBanner
@@ -2805,6 +2858,24 @@ const AgentKitAssistantChatBody = forwardRef<
           void sendRecoveryMessage(RECOVERY_CONTINUE_PROMPT, "continue")
         }
       />
+      {history?.historyLoadFailed ? (
+        <div
+          role="alert"
+          className="mx-3 mb-2 flex items-center justify-between gap-3 rounded-md border border-border px-3 py-2 text-xs"
+        >
+          <span className="text-muted-foreground">
+            {t("agentChat.message.historyUnavailable")}
+          </span>
+          <button
+            type="button"
+            onClick={history.retryHistory}
+            disabled={history.isRetryingHistory}
+            className="shrink-0 font-medium text-foreground hover:underline disabled:cursor-not-allowed disabled:opacity-50"
+          >
+            {t("agentChat.common.retry")}
+          </button>
+        </div>
+      ) : null}
       <AgentKitChat
         className={props.className}
         composerProps={{ attachmentsEnabled: fileStorageConfigured }}
@@ -2910,7 +2981,8 @@ function AgentKitEmptyState({ threadId }: { threadId: string }) {
                     disabled={
                       !surface.canChat ||
                       surface.props.composerDisabled ||
-                      surface.props.composerSubmissionDisabled
+                      surface.props.composerSubmissionDisabled ||
+                      surface.composerSubmissionPending
                     }
                     onClick={() => surface.submitSuggestion(suggestion)}
                     className="w-full rounded-xl border border-border/70 bg-card/60 px-3 py-2.5 text-left text-[13px] text-muted-foreground shadow-sm transition-colors hover:border-border hover:bg-card hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
@@ -3008,11 +3080,6 @@ function AgentKitTranscript({ children, threadId }: AgentKitRegionRenderProps) {
   const threadMessageIds = new Set(
     thread.messages.map((message) => message.id),
   );
-  const lastMessage = thread.messages.at(-1);
-  const showThinking =
-    (surface.isRunning || surface.isSubmissionInFlight) &&
-    lastMessage?.role === "user" &&
-    lastMessage.metadata?.hideUserMessage !== true;
   const pendingVoiceMessages = surface.voiceTranscriptMessages.filter(
     (message) => !threadMessageIds.has(message.id),
   );
@@ -3033,7 +3100,8 @@ function AgentKitTranscript({ children, threadId }: AgentKitRegionRenderProps) {
           !surface.canChat ||
           surface.props.composerDisabled ||
           surface.props.composerSubmissionDisabled ||
-          surface.isSubmissionInFlight
+          surface.isSubmissionInFlight ||
+          surface.composerSubmissionPending
         }
         onSelect={surface.submitSuggestion}
         className="agentkit-host-suggestions"
@@ -3189,7 +3257,7 @@ function AgentKitTranscript({ children, threadId }: AgentKitRegionRenderProps) {
           threadId={threadId}
         />
       ))}
-      {showThinking ? (
+      {surface.isThinkingVisibleInTranscript ? (
         <div
           role="status"
           aria-live="polite"
@@ -3338,6 +3406,9 @@ function AgentKitComposerSurface({
   isRunning,
   isRestoring,
   isSubmissionInFlight,
+  composerSubmissionPending,
+  onComposerSubmissionPendingChange,
+  isThinkingVisibleInTranscript,
   hasRenderedMessages,
   threadRestore,
   suggestions,
@@ -3373,6 +3444,9 @@ function AgentKitComposerSurface({
   isRunning: boolean;
   isRestoring: boolean;
   isSubmissionInFlight: boolean;
+  composerSubmissionPending: boolean;
+  onComposerSubmissionPendingChange: (pending: boolean) => void;
+  isThinkingVisibleInTranscript: boolean;
   hasRenderedMessages: boolean;
   setupBouncePulse: number;
   bounceSetupCard: () => void;
@@ -3618,7 +3692,8 @@ function AgentKitComposerSurface({
             !canChat ||
             props.composerDisabled ||
             props.composerSubmissionDisabled ||
-            isSubmissionInFlight
+            isSubmissionInFlight ||
+            composerSubmissionPending
           }
           onSelect={submitSuggestion}
           className="agentkit-home-suggestions"
@@ -3668,12 +3743,12 @@ function AgentKitComposerSurface({
           disabled={
             (!canChat && !providerSubmissionPending) ||
             props.composerDisabled ||
-            isRestoring ||
-            isSubmissionInFlight
+            isRestoring
           }
           submissionDisabled={
             (!canChat && !providerSubmissionPending) ||
-            props.composerSubmissionDisabled === true
+            props.composerSubmissionDisabled === true ||
+            isSubmissionInFlight
           }
           onDisabledClick={
             props.composerDisabled || !setupMissing
@@ -3692,6 +3767,8 @@ function AgentKitComposerSurface({
           requireAgentEngine={false}
           onTextChange={onTextChange}
           onBeforeSubmit={onBeforeSubmit}
+          announcePendingSubmission={!isThinkingVisibleInTranscript}
+          onSubmissionPendingChange={onComposerSubmissionPendingChange}
           contextItems={visibleContextItems}
           contextMenuItems={composerContext?.menuItems}
           onRemoveContextItem={(key) => {
@@ -3835,7 +3912,8 @@ function AgentKitComposerSurface({
             !canChat ||
             props.composerDisabled ||
             props.composerSubmissionDisabled ||
-            isSubmissionInFlight
+            isSubmissionInFlight ||
+            composerSubmissionPending
           }
           onSelect={submitSuggestion}
           className="agentkit-home-suggestions"
@@ -4128,6 +4206,10 @@ function AgentKitConnectionRequest({
     <McpAgentKitConnectionRequestCard
       provider={value.provider}
       detail={value.detail}
+      reason={value.reason}
+      status={value.status}
+      appId={value.appId}
+      source={value.source}
       target={{ threadId, runId, requestId: value.id }}
       onConnected={() =>
         control.resolveConnectionRequest(runId, value.id, {