@agent-native/toolkit 0.201.1 → 0.202.0-nightly-20261006033736

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

@@ -53,6 +53,7 @@ const chatMocks = vi.hoisted(() => ({
   thinkingDisplay: null as any,
   requestComposerFocus: vi.fn(),
   readiness: { canChat: true, missing: false, state: "configured" },
+  fetchProviderState: vi.fn(async () => chatMocks.readiness.state),
   fileUploadStatus: {
     data: { configured: true },
     isError: false,
@@ -207,9 +208,13 @@ vi.mock("../agentkit/react/index.js", async () => {
       if (chatMocks.realComposerController) {
         return React.createElement(AgentKitComposer, props);
       }
-      return React.createElement("div", {
-        "data-testid": "agentkit-composer",
-      });
+      return React.createElement(
+        "div",
+        {
+          "data-testid": "agentkit-composer",
+        },
+        props.extraActionButton,
+      );
     },
     AgentApprovalPrompt: () => null,
     AgentMessageView: ({ value }: any) => {
@@ -352,6 +357,7 @@ vi.mock("@tabler/icons-react", async (importOriginal) => ({
       "IconAlertTriangle",
       "IconCheck",
       "IconChevronDown",
+      "IconLoader2",
       "IconMessage",
       "IconPlayerStopFilled",
       "IconQuote",
@@ -479,6 +485,7 @@ vi.mock("@agent-native/core/client/agent-chat", async (importOriginal) => {
     ExternalAgentNudge: () => null,
     useDevMode: () => ({ isDevMode: true }),
     useAgentEngineConfigured: () => chatMocks.readiness,
+    fetchAgentEngineConfiguredState: chatMocks.fetchProviderState,
     filterAgentChatContextItems: (items: unknown[]) => items,
     formatAgentChatContextItemsForPrompt:
       actual.formatAgentChatContextItemsForPrompt,
@@ -753,6 +760,9 @@ beforeEach(() => {
     missing: false,
     state: "configured",
   };
+  chatMocks.fetchProviderState
+    .mockReset()
+    .mockImplementation(async () => chatMocks.readiness.state);
   chatMocks.fileUploadStatus = {
     data: { configured: true },
     isError: false,
@@ -1872,7 +1882,7 @@ describe("AgentKitAssistantChat host behavior", () => {
     expect(chatMocks.composerProps.modelStatusChecksEnabled).toBe(false);
   });
 
-  it("shows a model catalog retry instead of missing-provider setup", async () => {
+  it("shows missing-provider setup when the model catalog is unavailable", async () => {
     const onRetryModelList = vi.fn();
     chatMocks.readiness = {
       canChat: false,
@@ -1887,6 +1897,30 @@ describe("AgentKitAssistantChat host behavior", () => {
       }),
     );
 
+    expect(chatMocks.setupCardProps).toMatchObject({ attached: true });
+    expect(chatMocks.providerGateProps).toBeNull();
+    expect(container.textContent).not.toContain(
+      "agentChat.setup.modelListUnavailable",
+    );
+
+    expect(onRetryModelList).not.toHaveBeenCalled();
+  });
+
+  it("offers a model catalog retry when AI is configured", async () => {
+    const onRetryModelList = vi.fn();
+    chatMocks.readiness = {
+      canChat: true,
+      missing: false,
+      state: "configured",
+    };
+    await mount(
+      baseProps({
+        providerStatusChecksEnabled: true,
+        modelListError: true,
+        onRetryModelList,
+      }),
+    );
+
     expect(chatMocks.setupCardProps).toBeNull();
     expect(chatMocks.providerGateProps).toMatchObject({
       modelListUnavailable: true,
@@ -1905,224 +1939,291 @@ describe("AgentKitAssistantChat host behavior", () => {
     dispatchEvent.mockRestore();
   });
 
-  it("keeps the composer editable while provider readiness is checked", async () => {
+  it("keeps typing available and shows a busy send state during fresh readiness checks", async () => {
     chatMocks.readiness = {
       canChat: false,
       missing: false,
       state: "unknown",
     };
+    let resolveReadiness!: (state: "configured" | "missing") => void;
+    const pendingReadiness = new Promise<"configured" | "missing">(
+      (resolve) => {
+        resolveReadiness = resolve;
+      },
+    );
+    chatMocks.fetchProviderState.mockReturnValueOnce(pendingReadiness);
     await mount(baseProps({ providerStatusChecksEnabled: true }));
 
     expect(chatMocks.composerProps.disabled).toBe(false);
     expect(chatMocks.composerProps.submissionDisabled).toBe(false);
     expect(chatMocks.composerProps.requireAgentEngine).toBe(false);
-    await expect(chatMocks.composerProps.onBeforeSubmit()).resolves.toBe(true);
-    expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
-  });
+    await act(async () => {
+      chatMocks.composerProps.onTextChange("Draft while checking");
+    });
 
-  it("queues composer sends until provider readiness resolves", async () => {
-    chatMocks.readiness = {
-      canChat: false,
-      missing: false,
-      state: "unknown",
-    };
-    await mount(baseProps({ providerStatusChecksEnabled: true }));
-    await flush();
+    let preflight!: Promise<boolean>;
+    await act(async () => {
+      preflight = chatMocks.composerProps.onBeforeSubmit();
+      chatMocks.composerProps.onSubmissionPendingChange(true);
+      await Promise.resolve();
+    });
+    expect(chatMocks.fetchProviderState).toHaveBeenCalledOnce();
+    expect(chatMocks.fetchProviderState).toHaveBeenCalledWith(true, {
+      fresh: true,
+    });
+    expect(
+      container.querySelector('[data-testid="provider-preflight-pending"]'),
+    ).not.toBeNull();
+    expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
 
     await act(async () => {
-      await expect(chatMocks.composerProps.onBeforeSubmit()).resolves.toBe(
-        true,
-      );
+      resolveReadiness("configured");
+      await expect(preflight).resolves.toBe(true);
+      chatMocks.composerProps.onSubmissionPendingChange(false);
+    });
+    await act(async () => {
       await chatMocks.composerProps.onSubmit(
-        "Send after provider discovery",
+        "Draft while checking",
         [],
         [],
         {},
       );
     });
 
-    expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
-    const stateKey = [...chatMocks.appState.keys()].find((key) =>
-      key.startsWith("agentkit-deferred-provider-submissions:"),
+    expect(
+      container.querySelector('[data-testid="provider-preflight-pending"]'),
+    ).toBeNull();
+    expect(chatMocks.control.sendMessage).toHaveBeenCalledOnce();
+    expect(chatMocks.control.sendMessage.mock.calls[0]?.[0]?.text).toBe(
+      "Draft while checking",
     );
-    expect(stateKey).toBeDefined();
-    expect(chatMocks.appState.get(stateKey!)).toMatchObject({
-      submissions: [{ text: "Send after provider discovery" }],
+    expect(
+      [...chatMocks.appState.keys()].some((key) =>
+        key.startsWith("agentkit-deferred-provider-submissions:"),
+      ),
+    ).toBe(false);
+  });
+
+  it("blocks stale configured readiness and retains the draft when fresh status is missing", async () => {
+    chatMocks.readiness = {
+      canChat: true,
+      missing: false,
+      state: "configured",
+    };
+    chatMocks.fetchProviderState.mockResolvedValue("missing");
+    await mount(baseProps({ providerStatusChecksEnabled: true }));
+
+    await act(async () => {
+      chatMocks.composerProps.onTextChange("Keep this draft disconnected");
     });
+    expect(chatMocks.composerProps.disabled).toBe(false);
 
     await act(async () => {
-      chatMocks.readiness = {
-        canChat: true,
-        missing: false,
-        state: "configured",
-      };
-      root.render(
-        <AgentKitAssistantChat
-          {...baseProps({ providerStatusChecksEnabled: true })}
-        />,
+      await expect(chatMocks.composerProps.onBeforeSubmit()).resolves.toBe(
+        false,
       );
     });
-    await flush();
 
-    expect(chatMocks.control.sendMessage).toHaveBeenCalledOnce();
-    expect(chatMocks.control.sendMessage.mock.calls[0]?.[0]?.text).toBe(
-      "Send after provider discovery",
+    expect(chatMocks.composerProps.disabled).toBe(true);
+    expect(chatMocks.composerProps.submissionDisabled).toBe(true);
+    expect(chatMocks.setupCardProps).toMatchObject({ attached: true });
+    expect(
+      container.querySelector('[data-testid="builder-setup-card"]'),
+    ).not.toBeNull();
+    expect(chatMocks.composerDrafts.get("thread-1")).toBe(
+      "Keep this draft disconnected",
     );
-    expect(chatMocks.appState.has(stateKey!)).toBe(false);
+    expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
+    expect(
+      [...chatMocks.appState.keys()].some((key) =>
+        key.startsWith("agentkit-deferred-provider-submissions:"),
+      ),
+    ).toBe(false);
   });
 
-  it("preserves queued intent when its run finishes during provider discovery", async () => {
+  it("submits when the fresh result is configured even if passive readiness is unknown", async () => {
     chatMocks.readiness = {
       canChat: false,
       missing: false,
       state: "unknown",
     };
-    chatMocks.thread.activeRunIds = ["analytics-run"];
-    chatMocks.thread.runs = {
-      "analytics-run": {
-        id: "analytics-run",
-        status: "running",
-        lastSequence: 1,
-      },
-    };
+    chatMocks.fetchProviderState.mockResolvedValue("configured");
     await mount(baseProps({ providerStatusChecksEnabled: true }));
-    await flush();
 
     await act(async () => {
       await expect(chatMocks.composerProps.onBeforeSubmit()).resolves.toBe(
         true,
       );
+    });
+    await act(async () => {
       await chatMocks.composerProps.onSubmit(
-        "Follow up after Analytics Add Panel",
+        "Send after discovery",
         [],
         [],
-        { 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.control.sendMessage).toHaveBeenCalledOnce();
+    expect(chatMocks.control.sendMessage.mock.calls[0]?.[0]?.text).toBe(
+      "Send after discovery",
     );
-    expect(chatMocks.appState.get(stateKey!)).toMatchObject({
-      submissions: [
-        {
-          composerOptions: {
-            intent: "queued",
-            queuedWhileRunActive: true,
-          },
-        },
-      ],
+    expect(
+      [...chatMocks.appState.keys()].some((key) =>
+        key.startsWith("agentkit-deferred-provider-submissions:"),
+      ),
+    ).toBe(false);
+  });
+
+  it("clears a stale missing submission result after passive readiness confirms reconnection", async () => {
+    chatMocks.readiness = {
+      canChat: false,
+      missing: false,
+      state: "unknown",
+    };
+    chatMocks.fetchProviderState.mockResolvedValue("missing");
+    const props = baseProps({ providerStatusChecksEnabled: true });
+    await mount(props);
+
+    await act(async () => {
+      await expect(chatMocks.composerProps.onBeforeSubmit()).resolves.toBe(
+        false,
+      );
     });
+    expect(chatMocks.composerProps.disabled).toBe(true);
+    expect(chatMocks.setupCardProps).not.toBeNull();
 
-    chatMocks.thread.activeRunIds = [];
-    chatMocks.thread.runs["analytics-run"].status = "completed";
     chatMocks.readiness = {
       canChat: true,
       missing: false,
       state: "configured",
     };
     await act(async () => {
-      root.render(
-        <AgentKitAssistantChat
-          {...baseProps({ providerStatusChecksEnabled: true })}
-        />,
-      );
+      root.render(<AgentKitAssistantChat {...props} />);
     });
-    await flush();
 
-    expect(chatMocks.control.sendMessage).toHaveBeenCalledExactlyOnceWith(
-      expect.objectContaining({
-        text: "Follow up after Analytics Add Panel",
-        queuedWhileRunActive: true,
-      }),
+    expect(chatMocks.composerProps.disabled).toBe(false);
+    expect(chatMocks.composerProps.submissionDisabled).toBe(false);
+    expect(container.querySelector('[data-testid="builder-setup-card"]')).toBe(
+      null,
     );
-    expect(chatMocks.control.queueMessage).not.toHaveBeenCalled();
-    expect(chatMocks.appState.has(stateKey!)).toBe(false);
   });
 
-  it("keeps the draft rejected if provider status becomes missing before submit", async () => {
+  it("waits for the newest readiness result before authorizing a send", async () => {
     chatMocks.readiness = {
-      canChat: false,
+      canChat: true,
       missing: false,
-      state: "unknown",
+      state: "configured",
     };
+    let resolveFirst!: (state: "configured" | "missing") => void;
+    let resolveSecond!: (state: "configured" | "missing") => void;
+    chatMocks.fetchProviderState
+      .mockReturnValueOnce(
+        new Promise((resolve) => {
+          resolveFirst = resolve;
+        }),
+      )
+      .mockReturnValueOnce(
+        new Promise((resolve) => {
+          resolveSecond = resolve;
+        }),
+      );
     await mount(baseProps({ providerStatusChecksEnabled: true }));
-    await expect(chatMocks.composerProps.onBeforeSubmit()).resolves.toBe(true);
 
+    let firstPreflight!: Promise<boolean>;
+    let secondPreflight!: Promise<boolean>;
+    await act(async () => {
+      firstPreflight = chatMocks.composerProps.onBeforeSubmit();
+      await Promise.resolve();
+    });
+    chatMocks.readiness = {
+      canChat: false,
+      missing: true,
+      state: "missing",
+    };
     await act(async () => {
-      chatMocks.readiness = {
-        canChat: false,
-        missing: true,
-        state: "missing",
-      };
       root.render(
         <AgentKitAssistantChat
           {...baseProps({ providerStatusChecksEnabled: true })}
         />,
       );
     });
+    await act(async () => {
+      secondPreflight = chatMocks.composerProps.onBeforeSubmit();
+      await Promise.resolve();
+    });
+    expect(chatMocks.fetchProviderState).toHaveBeenCalledTimes(2);
 
-    await expect(
-      chatMocks.composerProps.onSubmit("Keep until connected", [], [], {}),
-    ).rejects.toThrow("agentChat.recovery.deferredSubmissionFailed");
+    await act(async () => {
+      resolveFirst("configured");
+      await Promise.resolve();
+    });
+    let firstSettled = false;
+    void firstPreflight.then(() => {
+      firstSettled = true;
+    });
+    await flush();
+    expect(firstSettled).toBe(false);
+    expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
+
+    await act(async () => {
+      resolveSecond("missing");
+      await expect(firstPreflight).resolves.toBe(false);
+      await expect(secondPreflight).resolves.toBe(false);
+    });
+
+    expect(chatMocks.composerProps.disabled).toBe(true);
+    expect(chatMocks.composerProps.submissionDisabled).toBe(true);
+    expect(chatMocks.setupCardProps).toMatchObject({ attached: true });
     expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
-    expect(
-      [...chatMocks.appState.keys()].some((key) =>
-        key.startsWith("agentkit-deferred-provider-submissions:"),
-      ),
-    ).toBe(false);
   });
 
-  it("sends a draft once provider readiness resolves", async () => {
+  it("keeps a successful submit preflight through a transient passive failure", async () => {
     chatMocks.readiness = {
-      canChat: false,
+      canChat: true,
       missing: false,
-      state: "unknown",
+      state: "configured",
     };
-    await mount(
-      baseProps({
-        providerStatusChecksEnabled: true,
-        composerSubmissionDisabled: true,
+    let resolveReadiness!: (state: "configured" | "missing") => void;
+    chatMocks.fetchProviderState.mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolveReadiness = resolve;
       }),
     );
+    const props = baseProps({ providerStatusChecksEnabled: true });
+    await mount(props);
 
-    expect(chatMocks.composerProps.submissionDisabled).toBe(true);
-    await expect(chatMocks.composerProps.onBeforeSubmit()).resolves.toBe(false);
+    let preflight!: Promise<boolean>;
+    await act(async () => {
+      preflight = chatMocks.composerProps.onBeforeSubmit();
+      await Promise.resolve();
+    });
+    expect(chatMocks.fetchProviderState).toHaveBeenCalledOnce();
 
     await act(async () => {
-      chatMocks.readiness = {
-        canChat: true,
-        missing: false,
-        state: "configured",
-      };
-      root.render(
-        <AgentKitAssistantChat
-          {...baseProps({
-            providerStatusChecksEnabled: true,
-            composerSubmissionDisabled: false,
-          })}
-        />,
-      );
+      resolveReadiness("configured");
+      await expect(preflight).resolves.toBe(true);
     });
 
-    expect(chatMocks.composerProps.submissionDisabled).toBe(false);
+    chatMocks.readiness = {
+      canChat: false,
+      missing: false,
+      state: "unavailable",
+    };
     await act(async () => {
-      await chatMocks.composerProps.onSubmit(
-        "Send after discovery",
-        [],
-        [],
-        {},
-      );
+      root.render(<AgentKitAssistantChat {...props} />);
     });
 
-    expect(chatMocks.control.sendMessage).toHaveBeenCalledOnce();
-    expect(chatMocks.control.sendMessage.mock.calls[0]?.[0]?.text).toBe(
-      "Send after discovery",
+    expect(chatMocks.composerProps.disabled).toBe(false);
+    expect(chatMocks.composerProps.submissionDisabled).toBe(false);
+
+    await act(async () =>
+      chatMocks.composerProps.onSubmit("Send", [], [], {
+        intent: "immediate",
+      }),
     );
+    expect(chatMocks.fetchProviderState).toHaveBeenCalledOnce();
+    expect(chatMocks.control.sendMessage).toHaveBeenCalledOnce();
   });
 
   it("keeps the composer editable when the host blocks submission", async () => {
@@ -2894,49 +2995,27 @@ describe("AgentKitAssistantChat host behavior", () => {
     });
   });
 
-  it("durably queues unresolved sends with files and references across remounts", async () => {
+  it("rejects unresolved sends before uploading or queueing their attachments", async () => {
     chatMocks.readiness = {
       canChat: false,
       missing: false,
       state: "unknown",
     };
-    const initialCapturedAt = Date.now();
-    chatMocks.appState.set("pending-selection-context", {
-      text: "Initial selection",
-      capturedAt: initialCapturedAt,
-    });
-    let resolveUpload!: (
-      parts: Awaited<ReturnType<typeof chatMocks.control.uploadFiles>>,
-    ) => void;
-    chatMocks.control.uploadFiles.mockImplementationOnce(
-      () => new Promise((resolve) => (resolveUpload = resolve)),
-    );
-    chatMocks.guidedQuestions = [{ id: "question-1" }];
     const ref = createRef<AssistantChatHandle>();
     container = document.createElement("div");
     document.body.appendChild(container);
     root = createRoot(container);
-    const props = baseProps({
-      providerStatusChecksEnabled: true,
-      tabId: "tab-1",
-    });
+    const props = baseProps({ providerStatusChecksEnabled: true });
     await act(async () => {
       root.render(<AgentKitAssistantChat ref={ref} {...props} />);
     });
     const results: CustomEvent[] = [];
     const listener = (event: Event) => results.push(event as CustomEvent);
     window.addEventListener(AGENT_CHAT_SUBMIT_RESULT_EVENT, listener);
-    const reference = {
-      type: "file",
-      path: "notes.txt",
-      name: "notes.txt",
-      source: "composer",
-    } as const;
-
-    let deferredSend!: Promise<AssistantChatSubmitResult>;
+    let sendResult!: AssistantChatSubmitResult;
     await act(async () => {
       ref.current?.prefillMessage("Visible composer draft");
-      deferredSend = ref.current!.sendMessage(
+      sendResult = await ref.current!.sendMessage(
         "Wait for the provider",
         undefined,
         {
@@ -2948,115 +3027,28 @@ describe("AgentKitAssistantChat host behavior", () => {
               text: "private attachment body",
             },
           ],
-          recoveryReferences: [reference],
-        } as AssistantChatSendOptions,
+        },
       );
-      await new Promise((resolve) => setTimeout(resolve, 0));
     });
-    const nextCapturedAt = initialCapturedAt + 1;
-    await act(async () => {
-      window.dispatchEvent(
-        new CustomEvent("agent-panel:selection-attached", {
-          detail: { text: "Selection for the next prompt" },
-        }),
-      );
-      chatMocks.appState.set("pending-selection-context", {
-        text: "Selection for the next prompt",
-        capturedAt: nextCapturedAt,
-      });
-      resolveUpload([
-        {
-          type: "file",
-          name: "notes.txt",
-          mediaType: "text/plain",
-          url: "https://files.example.test/notes.txt",
-        },
-      ]);
-      await deferredSend;
+    expect(sendResult).toEqual({
+      status: "rejected",
+      reason: "submission-unavailable",
     });
-
     expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
     expect(results.map((event) => event.detail)).toEqual([
-      { submitMessageId: "pending-provider-submit", delivered: true },
-    ]);
-    expect(chatMocks.composerProps.initialText).toBe("Visible composer draft");
-    expect(chatMocks.guidedFlowProps).toMatchObject({
-      isSubmissionBlocked: true,
-      providerStatus: "unknown",
-    });
-    const stateKey = [...chatMocks.appState.keys()].find((key) =>
-      key.startsWith("agentkit-deferred-provider-submissions:"),
-    );
-    expect(stateKey).toBeDefined();
-    const persisted = chatMocks.appState.get(stateKey!) as {
-      submissions: Array<{
-        fileParts: unknown[];
-        options: {
-          pendingSelectionCapturedAt: number | null;
-          recoveryReferences: unknown[];
-          skipAmbientSelectionContext: boolean;
-        };
-      }>;
-    };
-    expect(persisted.submissions[0]).toMatchObject({
-      fileParts: [
-        {
-          type: "file",
-          name: "notes.txt",
-          url: "https://files.example.test/notes.txt",
-        },
-      ],
-      options: {
-        pendingSelectionCapturedAt: initialCapturedAt,
-        recoveryReferences: [reference],
-        skipAmbientSelectionContext: true,
+      {
+        submitMessageId: "pending-provider-submit",
+        delivered: false,
+        reason: "submission-unavailable",
       },
-    });
-    expect(JSON.stringify(persisted)).not.toContain("private attachment body");
-
-    await unmount();
-    root = undefined as unknown as Root;
-
-    chatMocks.readiness = {
-      canChat: true,
-      missing: false,
-      state: "configured",
-    };
-    container = document.createElement("div");
-    document.body.appendChild(container);
-    root = createRoot(container);
-    await act(async () => {
-      root.render(<AgentKitAssistantChat ref={ref} {...props} />);
-    });
-    await flush();
-
+    ]);
     expect(chatMocks.composerProps.initialText).toBe("Visible composer draft");
-    expect(chatMocks.control.sendMessage).toHaveBeenCalledOnce();
-    const request = chatMocks.control.sendMessage.mock.calls[0]?.[0];
-    expect(request).toMatchObject({
-      attachments: [
-        {
-          type: "file",
-          name: "notes.txt",
-          url: "https://files.example.test/notes.txt",
-        },
-      ],
-      metadata: {
-        references: [reference],
-        custom: {
-          agentNativeDeferredSubmissionId: "pending-provider-submit",
-        },
-        agentNativeSkipPendingSelectionContext: true,
-      },
-    });
-    expect(request?.text).toContain("Initial selection");
-    expect(request?.text).not.toContain("Selection for the next prompt");
-    expect(results).toHaveLength(1);
-    expect(chatMocks.appState.has(stateKey!)).toBe(false);
-    expect(chatMocks.appState.get("pending-selection-context")).toEqual({
-      text: "Selection for the next prompt",
-      capturedAt: nextCapturedAt,
-    });
+    expect(chatMocks.control.uploadFiles).not.toHaveBeenCalled();
+    expect(
+      [...chatMocks.appState.keys()].some((key) =>
+        key.startsWith("agentkit-deferred-provider-submissions:"),
+      ),
+    ).toBe(false);
     window.removeEventListener(AGENT_CHAT_SUBMIT_RESULT_EVENT, listener);
   });
 
@@ -3461,22 +3453,24 @@ describe("AgentKitAssistantChat host behavior", () => {
         />,
       );
     });
-    await expect(
-      ref.current!.sendMessage("Try again", undefined, {
-        submitMessageId: "unavailable-submit",
-      }),
-    ).resolves.toEqual({ status: "submitted" });
+    await act(async () => {
+      await expect(
+        ref.current!.sendMessage("Try again", undefined, {
+          submitMessageId: "unavailable-submit",
+        }),
+      ).resolves.toEqual({
+        status: "rejected",
+        reason: "submission-unavailable",
+      });
+    });
     expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
     expect(results.at(-1)?.detail).toEqual({
       submitMessageId: "unavailable-submit",
-      delivered: true,
+      delivered: false,
+      reason: "submission-unavailable",
     });
 
-    chatMocks.readiness = {
-      canChat: true,
-      missing: false,
-      state: "configured",
-    };
+    chatMocks.fetchProviderState.mockResolvedValue("configured");
     await act(async () => {
       root.render(
         <AgentKitAssistantChat
@@ -3484,10 +3478,12 @@ describe("AgentKitAssistantChat host behavior", () => {
           {...baseProps({ providerStatusChecksEnabled: true })}
         />,
       );
-      await new Promise((resolve) => setTimeout(resolve, 0));
+      await expect(
+        ref.current!.sendMessage("Try again after fresh check"),
+      ).resolves.toEqual({ status: "submitted" });
     });
     expect(chatMocks.control.sendMessage).toHaveBeenCalledWith(
-      expect.objectContaining({ text: "Try again" }),
+      expect.objectContaining({ text: "Try again after fresh check" }),
     );
     window.removeEventListener(AGENT_CHAT_SUBMIT_RESULT_EVENT, listener);
   });
@@ -3536,6 +3532,14 @@ describe("AgentKitAssistantChat host behavior", () => {
     expect(chatMocks.control.queueMessage).not.toHaveBeenCalled();
   });
 
+  it("hides the shared guided-question card when the host owns that flow", async () => {
+    chatMocks.guidedQuestions = [{ id: "question-1", question: "Title?" }];
+    await mount(baseProps({ showGuidedQuestions: false }));
+
+    expect(chatMocks.guidedOptions).toMatchObject({ enabled: false });
+    expect(chatMocks.guidedFlowProps).toBeNull();
+  });
+
   it("sends directly when a stale composer render outlives the queued run", async () => {
     chatMocks.thread.activeRunIds = ["run-queued-follow-up"];
     chatMocks.thread.runs = {
@@ -4275,7 +4279,7 @@ describe("AgentKitAssistantChat host behavior", () => {
     expect(chatMocks.control.uploadFiles).not.toHaveBeenCalled();
   });
 
-  it("preserves saved file IDs when retrying while the provider is unavailable", async () => {
+  it("keeps saved file IDs when retrying while the provider is unavailable", async () => {
     chatMocks.readiness = {
       canChat: false,
       missing: false,
@@ -4309,24 +4313,17 @@ describe("AgentKitAssistantChat host behavior", () => {
       await new Promise((resolve) => setTimeout(resolve, 0));
     });
 
-    const stateKey = [...chatMocks.appState.keys()].find((key) =>
-      key.startsWith("agentkit-deferred-provider-submissions:"),
-    );
-    expect(stateKey).toBeDefined();
-    expect(chatMocks.appState.get(stateKey!)).toMatchObject({
-      submissions: [
-        {
-          fileParts: [
-            {
-              type: "file",
-              name: "source.csv",
-              mediaType: "text/csv",
-              fileId: "file-1",
-            },
-          ],
-        },
-      ],
+    expect(chatMocks.thread.messages[0]?.parts).toContainEqual({
+      type: "file",
+      name: "source.csv",
+      mediaType: "text/csv",
+      fileId: "file-1",
     });
+    expect(
+      [...chatMocks.appState.keys()].some((key) =>
+        key.startsWith("agentkit-deferred-provider-submissions:"),
+      ),
+    ).toBe(false);
     expect(chatMocks.control.uploadFiles).not.toHaveBeenCalled();
     expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
   });