@agent-native/toolkit 0.209.1-nightly-20261015153252 → 0.209.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/toolkit",
-  "version": "0.209.1-nightly-20261015153252",
+  "version": "0.209.1",
   "description": "Reusable app-building UI and helpers for Agent-Native apps.",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -678,7 +678,7 @@
     "y-protocols": "^1.0.7",
     "yjs": "^13.6.33",
     "zod": "^4.3.6",
-    "@agent-native/agentkit": "^0.209.1-nightly-20261015153252"
+    "@agent-native/agentkit": "^0.209.1"
   },
   "devDependencies": {
     "@excalidraw/excalidraw": "0.18.1",
@@ -702,10 +702,10 @@
     "typescript-7": "npm:typescript@^7.0.2",
     "vite": "8.1.0",
     "vitest": "^4.1.5",
-    "@agent-native/core": "^0.209.1-nightly-20261015153252"
+    "@agent-native/core": "^0.209.1"
   },
   "peerDependencies": {
-    "@agent-native/core": "0.209.1-nightly-20261015153252",
+    "@agent-native/core": ">=0.205.1",
     "@excalidraw/excalidraw": ">=0.18",
     "@excalidraw/mermaid-to-excalidraw": ">=2",
     "@tanstack/react-query": "^5.99.2",

package/src/app/agentkit/react/styles.css

@@ -1974,7 +1974,7 @@ button.agentkit-object {
 }
 
 .agentkit-host-suggestions-slot {
-  block-size: 2rem;
+  block-size: 2.5rem;
   min-inline-size: 0;
 }
 

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

@@ -4,7 +4,10 @@ import {
   AgentKitClient,
   AgentKitUploadError,
 } from "@agent-native/agentkit/client";
-import { MAX_AGENT_REQUEST_ATTACHMENT_DATA_CHARS } from "@agent-native/agentkit/protocol";
+import {
+  AGENT_NATIVE_SUBMISSION_EXPIRES_AT_METADATA_KEY,
+  MAX_AGENT_REQUEST_ATTACHMENT_DATA_CHARS,
+} from "@agent-native/agentkit/protocol";
 import type {
   AgentInteraction,
   FilePart,
@@ -4597,6 +4600,7 @@ describe("AgentKitAssistantChat host behavior", () => {
 
   it("uploads inline images before storing a deferred submission", async () => {
     chatMocks.history = { isRestoring: true };
+    const submissionExpiresAt = Date.now() + 20_000;
     chatMocks.control.uploadFiles.mockResolvedValueOnce([
       {
         type: "file",
@@ -4609,18 +4613,112 @@ describe("AgentKitAssistantChat host behavior", () => {
     await mount(baseProps(), ref);
 
     await act(async () => {
-      await ref.current?.sendMessage("Use this image", [
-        "data:image/png;base64,aGVsbG8=",
-      ]);
+      await ref.current?.sendMessage(
+        "Use this image",
+        ["data:image/png;base64,aGVsbG8="],
+        { submissionExpiresAt },
+      );
     });
 
     const stored = JSON.stringify([...chatMocks.appState.values()]);
     expect(chatMocks.control.uploadFiles).toHaveBeenCalledOnce();
     expect(stored).toContain("https://files.example.test/image.png");
+    expect(stored).toContain(String(submissionExpiresAt));
     expect(stored).not.toContain("base64,");
     expect(stored).not.toContain("data:image");
   });
 
+  it("does not report a deferred retry as submitted if saving passes its deadline", async () => {
+    chatMocks.history = { isRestoring: true };
+    const threadId = chatMocks.threadId;
+    const encodedThreadId = Array.from(threadId, (character) =>
+      character.codePointAt(0)!.toString(16),
+    ).join("-");
+    const stateKey = `agentkit-deferred-provider-submissions:${encodedThreadId}`;
+    const now = vi.spyOn(Date, "now").mockReturnValue(1_000);
+    const compareAndSet = vi.mocked(compareAndSetClientAppState);
+    const originalCompareAndSet = compareAndSet.getMockImplementation();
+    if (!originalCompareAndSet) {
+      throw new Error("Expected the app-state compare-and-set mock.");
+    }
+    let advancedDeadline = false;
+    compareAndSet.mockImplementation(async (...args) => {
+      const saved = await originalCompareAndSet(...args);
+      if (args[0] === stateKey && args[2] !== null && !advancedDeadline) {
+        advancedDeadline = true;
+        now.mockReturnValue(1_001);
+      }
+      return saved;
+    });
+    const results: CustomEvent[] = [];
+    const listener = (event: Event) => results.push(event as CustomEvent);
+    window.addEventListener(AGENT_CHAT_SUBMIT_RESULT_EVENT, listener);
+    const ref = createRef<AssistantChatHandle>();
+
+    try {
+      await mount(baseProps(), ref);
+      await expect(
+        ref.current?.sendMessage("Retry the same deck prompt", undefined, {
+          submissionExpiresAt: 1_001,
+          submitMessageId: "deadline-during-save",
+        }),
+      ).resolves.toEqual({
+        status: "rejected",
+        reason: "submission-expired",
+      });
+      expect(chatMocks.appState.has(stateKey)).toBe(false);
+      expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
+      expect(results.map((event) => event.detail)).toContainEqual({
+        submitMessageId: "deadline-during-save",
+        delivered: false,
+        reason: "submission-expired",
+      });
+    } finally {
+      window.removeEventListener(AGENT_CHAT_SUBMIT_RESULT_EVENT, listener);
+      compareAndSet.mockImplementation(originalCompareAndSet);
+      now.mockRestore();
+    }
+  });
+
+  it("removes an expired deferred submission without dispatching it", async () => {
+    const threadId = chatMocks.threadId;
+    const encodedThreadId = Array.from(threadId, (character) =>
+      character.codePointAt(0)!.toString(16),
+    ).join("-");
+    const stateKey = `agentkit-deferred-provider-submissions:${encodedThreadId}`;
+    chatMocks.appState.set(stateKey, {
+      version: 1,
+      threadId,
+      submissions: [
+        {
+          id: "expired-deferred-submit",
+          threadId,
+          text: "Create a deck",
+          submissionExpiresAt: Date.now() - 1,
+          fileParts: [],
+          references: [],
+          composerOptions: {},
+          options: {},
+        },
+      ],
+    });
+    const results: CustomEvent[] = [];
+    const listener = (event: Event) => results.push(event as CustomEvent);
+    window.addEventListener(AGENT_CHAT_SUBMIT_RESULT_EVENT, listener);
+
+    await mount(baseProps());
+    await flush();
+    window.removeEventListener(AGENT_CHAT_SUBMIT_RESULT_EVENT, listener);
+
+    expect(chatMocks.control.sendMessage).not.toHaveBeenCalled();
+    expect(chatMocks.appState.has(stateKey)).toBe(false);
+    expect(results.map((event) => event.detail)).toContainEqual({
+      submitMessageId: "expired-deferred-submit",
+      delivered: false,
+      reason: "submission-expired",
+    });
+  });
+
   it("rechecks only submission scope after upload and reports its reason", async () => {
     const uploading = Promise.withResolvers<FilePart[]>();
     chatMocks.control.uploadFiles.mockReturnValueOnce(uploading.promise);
@@ -6042,6 +6140,41 @@ describe("AgentKitAssistantChat host behavior", () => {
     expect(chatMocks.control.queueMessage).not.toHaveBeenCalled();
   });
 
+  it("keeps a deadline-bound retry out of the queue and forwards its expiry", async () => {
+    chatMocks.thread.activeRunIds = ["run-1"];
+    const ref = createRef<AssistantChatHandle>();
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+    await act(async () => {
+      root.render(<AgentKitAssistantChat ref={ref} {...baseProps()} />);
+    });
+    const submissionExpiresAt = Date.now() + 20_000;
+
+    await act(async () => {
+      await expect(
+        ref.current?.sendMessage("Retry the same deck prompt", undefined, {
+          submissionExpiresAt,
+          submitMessageId: "slides-retry",
+        }),
+      ).resolves.toEqual({ status: "submitted" });
+    });
+
+    expect(chatMocks.control.sendMessage).toHaveBeenCalledOnce();
+    expect(chatMocks.control.sendMessage.mock.calls[0]?.[0]).toMatchObject({
+      text: "Retry the same deck prompt",
+      queuedWhileRunActive: true,
+      queueWhileRunning: false,
+      metadata: {
+        custom: {
+          [AGENT_NATIVE_SUBMISSION_EXPIRES_AT_METADATA_KEY]:
+            submissionExpiresAt,
+        },
+      },
+    });
+    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 }));

package/src/app/chat/AgentKitAssistantChat.tsx

@@ -3,6 +3,7 @@ import {
   hasActiveAgentRuns,
   selectAgentSuggestions,
   isCurrentAgentSuggestion,
+  AGENT_NATIVE_SUBMISSION_EXPIRES_AT_METADATA_KEY,
   splitAgentKitMessageContext,
   type AgentKitUploadDriver,
   type AgentThreadState,
@@ -643,10 +644,22 @@ type AgentKitInternalSendOptions = AssistantChatSendOptions & {
   deferredSubmissionId?: string;
 };
 
+function isSubmissionExpired(submissionExpiresAt: number | undefined): boolean {
+  return (
+    submissionExpiresAt !== undefined &&
+    (!Number.isFinite(submissionExpiresAt) || submissionExpiresAt <= Date.now())
+  );
+}
+
+function isSubmissionExpiredError(error: unknown): boolean {
+  return asRecord(error)?.code === "submission_expired";
+}
+
 interface PendingProviderSubmission {
   id: string;
   threadId: string;
   text: string;
+  submissionExpiresAt?: number;
   fileParts: FilePart[];
   requestAttachments?: AgentRequestAttachment[];
   references: Reference[];
@@ -931,6 +944,9 @@ function parseDeferredProviderSubmissions(
       !Array.isArray(submission.references) ||
       !composerOptions ||
       !options ||
+      (submission.submissionExpiresAt !== undefined &&
+        (typeof submission.submissionExpiresAt !== "number" ||
+          !Number.isFinite(submission.submissionExpiresAt))) ||
       (submission.attempts !== undefined &&
         (!Number.isSafeInteger(submission.attempts) ||
           (submission.attempts as number) < 0)) ||
@@ -950,6 +966,9 @@ function parseDeferredProviderSubmissions(
       id: submission.id,
       threadId,
       text: submission.text,
+      ...(typeof submission.submissionExpiresAt === "number"
+        ? { submissionExpiresAt: submission.submissionExpiresAt }
+        : {}),
       fileParts: fileParts as FilePart[],
       ...(Array.isArray(requestAttachments)
         ? {
@@ -3536,6 +3555,12 @@ const AgentKitAssistantChatBody = forwardRef<
             : props.selectedAgent;
         const actionScope = options.actionScope ?? contextScope;
         const customMetadata = {
+          ...(typeof options.submissionExpiresAt === "number"
+            ? {
+                [AGENT_NATIVE_SUBMISSION_EXPIRES_AT_METADATA_KEY]:
+                  options.submissionExpiresAt,
+              }
+            : {}),
           ...(options.recoveryAction
             ? { agentNativeRecoveryAction: options.recoveryAction }
             : {}),
@@ -3596,6 +3621,12 @@ const AgentKitAssistantChatBody = forwardRef<
           requestMode,
         };
         if (!queuedMessageReservationId) localSubmissionRef.current = true;
+        if (isSubmissionExpired(options.submissionExpiresAt)) {
+          throw Object.assign(
+            new Error("The prompt expired before it could be sent."),
+            { code: "submission_expired", retryable: false },
+          );
+        }
         await control.sendMessage({
           text: message,
           attachments: fileParts,
@@ -3603,6 +3634,9 @@ const AgentKitAssistantChatBody = forwardRef<
           queuedWhileRunActive:
             composerOptions.queuedWhileRunActive ||
             composerOptions.intent === "queued",
+          ...(options.submissionExpiresAt !== undefined
+            ? { queueWhileRunning: false }
+            : {}),
           interruptActiveRun: composerOptions.steer,
           options: {
             model,
@@ -3684,12 +3718,28 @@ const AgentKitAssistantChatBody = forwardRef<
       composerOptions: AgentKitSuggestionSubmitOptions,
       options: AgentKitInternalSendOptions = {},
     ): Promise<AssistantChatSubmitResult> => {
+      if (isSubmissionExpired(options.submissionExpiresAt)) {
+        reportAgentChatSubmitResult(
+          options.submitMessageId,
+          false,
+          "submission-expired",
+        );
+        return { status: "rejected", reason: "submission-expired" };
+      }
       const submittedComposerOptions = captureQueuedRunState(
         composerOptions,
         isThreadRunning(),
       );
       const release = await acquireSubmission();
       if (!release) {
+        if (isSubmissionExpired(options.submissionExpiresAt)) {
+          reportAgentChatSubmitResult(
+            options.submitMessageId,
+            false,
+            "submission-expired",
+          );
+          return { status: "rejected", reason: "submission-expired" };
+        }
         if (isRestoring) {
           try {
             const selectedEngine =
@@ -3738,6 +3788,14 @@ const AgentKitAssistantChatBody = forwardRef<
             ) {
               throw new Error(t("onboarding.fileStorage.title"));
             }
+            if (isSubmissionExpired(options.submissionExpiresAt)) {
+              reportAgentChatSubmitResult(
+                options.submitMessageId,
+                false,
+                "submission-expired",
+              );
+              return { status: "rejected", reason: "submission-expired" };
+            }
             const requestAttachments = normalizeRequestAttachmentReferences(
               options.deferredRequestAttachments ??
                 (await uploadRequestAttachments(
@@ -3746,6 +3804,14 @@ const AgentKitAssistantChatBody = forwardRef<
                 )),
             );
             submittedComposerOptions.validateSubmissionScope?.();
+            if (isSubmissionExpired(options.submissionExpiresAt)) {
+              reportAgentChatSubmitResult(
+                options.submitMessageId,
+                false,
+                "submission-expired",
+              );
+              return { status: "rejected", reason: "submission-expired" };
+            }
             const selectionChangedDuringUpload =
               selectionRevision !== selectionRevisionRef.current;
             const context = options.recoveryAction
@@ -3794,12 +3860,23 @@ const AgentKitAssistantChatBody = forwardRef<
               id: deferredOptions.deferredSubmissionId,
               threadId,
               text: appendAgentChatContextToMessage(text, context),
+              ...(typeof options.submissionExpiresAt === "number"
+                ? { submissionExpiresAt: options.submissionExpiresAt }
+                : {}),
               fileParts,
               ...(requestAttachments.length ? { requestAttachments } : {}),
               references: [...references],
               composerOptions: deferredComposerOptions,
               options: deferredOptions,
             };
+            if (isSubmissionExpired(options.submissionExpiresAt)) {
+              reportAgentChatSubmitResult(
+                submitMessageId,
+                false,
+                "submission-expired",
+              );
+              return { status: "rejected", reason: "submission-expired" };
+            }
             const submissions = await updateDeferredProviderSubmissions(
               threadId,
               (current) =>
@@ -3807,11 +3884,32 @@ const AgentKitAssistantChatBody = forwardRef<
                   ? current
                   : [...current, submission],
             );
+            if (isSubmissionExpired(options.submissionExpiresAt)) {
+              pendingProviderSubmissionsRef.current =
+                await updateDeferredProviderSubmissions(threadId, (current) =>
+                  current.filter(({ id }) => id !== submission.id),
+                );
+              setPendingProviderSubmissionVersion((version) => version + 1);
+              reportAgentChatSubmitResult(
+                submitMessageId,
+                false,
+                "submission-expired",
+              );
+              return { status: "rejected", reason: "submission-expired" };
+            }
             pendingProviderSubmissionsRef.current = submissions;
             setDeferredSubmissionsLoadedThread(threadId);
             reportAgentChatSubmitResult(submitMessageId, true);
             return { status: "submitted" };
           } catch (error) {
+            if (isSubmissionExpiredError(error)) {
+              reportAgentChatSubmitResult(
+                options.submitMessageId,
+                false,
+                "submission-expired",
+              );
+              return { status: "rejected", reason: "submission-expired" };
+            }
             reportAgentChatSubmitResult(
               options.submitMessageId,
               false,
@@ -3841,6 +3939,14 @@ const AgentKitAssistantChatBody = forwardRef<
         }
       }
       try {
+        if (isSubmissionExpired(options.submissionExpiresAt)) {
+          reportAgentChatSubmitResult(
+            options.submitMessageId,
+            false,
+            "submission-expired",
+          );
+          return { status: "rejected", reason: "submission-expired" };
+        }
         await dispatch(
           text,
           files,
@@ -3850,6 +3956,14 @@ const AgentKitAssistantChatBody = forwardRef<
         );
         return { status: "submitted" };
       } catch (error) {
+        if (isSubmissionExpiredError(error)) {
+          reportAgentChatSubmitResult(
+            options.submitMessageId,
+            false,
+            "submission-expired",
+          );
+          return { status: "rejected", reason: "submission-expired" };
+        }
         reportAgentChatSubmitResult(
           options.submitMessageId,
           false,
@@ -4232,6 +4346,20 @@ const AgentKitAssistantChatBody = forwardRef<
       let claimToken: string | undefined;
       let claimRenewalTimer: number | undefined;
       try {
+        if (isSubmissionExpired(submission.submissionExpiresAt)) {
+          const submissions = await updateDeferredProviderSubmissions(
+            threadId,
+            (current) => current.filter(({ id }) => id !== submission.id),
+          );
+          pendingProviderSubmissionsRef.current = submissions;
+          reportAgentChatSubmitResult(
+            submission.id,
+            false,
+            "submission-expired",
+          );
+          setPendingProviderSubmissionVersion((version) => version + 1);
+          return;
+        }
         release = await acquireSubmission();
         if (!release) {
           if (active) scheduleProviderSubmissionRetry();
@@ -4301,6 +4429,20 @@ const AgentKitAssistantChatBody = forwardRef<
           );
           return;
         }
+        if (isSubmissionExpired(currentSubmission.submissionExpiresAt)) {
+          const submissions = await updateDeferredProviderSubmissions(
+            threadId,
+            (current) => current.filter(({ id }) => id !== submission.id),
+          );
+          pendingProviderSubmissionsRef.current = submissions;
+          reportAgentChatSubmitResult(
+            submission.id,
+            false,
+            "submission-expired",
+          );
+          setPendingProviderSubmissionVersion((version) => version + 1);
+          return;
+        }
 
         claimRenewalTimer = window.setInterval(() => {
           void updateDeferredProviderSubmissions(threadId, (current) =>
@@ -4345,6 +4487,29 @@ const AgentKitAssistantChatBody = forwardRef<
         setDeferredProviderSubmissionFailureId(null);
         setPendingProviderSubmissionVersion((version) => version + 1);
       } catch (error) {
+        if (isSubmissionExpiredError(error)) {
+          const submissions = await updateDeferredProviderSubmissions(
+            threadId,
+            (current) =>
+              current.filter(
+                (candidate) =>
+                  candidate.id !== submission.id ||
+                  !claimToken ||
+                  candidate.claim?.token !== claimToken,
+              ),
+          );
+          pendingProviderSubmissionsRef.current = submissions;
+          reportAgentChatSubmitResult(
+            submission.id,
+            false,
+            "submission-expired",
+          );
+          if (active) {
+            setDeferredProviderSubmissionFailureId(null);
+            setPendingProviderSubmissionVersion((version) => version + 1);
+          }
+          return;
+        }
         let snapshotReadFailed = false;
         const latestThread = await props
           .getThreadSnapshot(threadId)
@@ -7353,6 +7518,9 @@ const ATTACHMENT_UNREADABLE_SUBMIT_REASON = "attachment-unreadable";
 
 function submitFailureReason(error: unknown): string {
   const record = asRecord(error);
+  if (record?.code === "submission_expired") {
+    return "submission-expired";
+  }
   if (record?.code === ATTACHMENT_UNREADABLE_SUBMIT_REASON) {
     return ATTACHMENT_UNREADABLE_SUBMIT_REASON;
   }

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

@@ -6627,6 +6627,7 @@ describe("MultiTabAssistantChat cold-start delivery (Mode B)", () => {
       "fetch",
       vi.fn(async () => Response.json({ value: null })),
     );
+    ensureLocalStorage();
     window.localStorage.clear();
     window.localStorage.setItem(
       openTabsStorageKey("mode-b"),
@@ -6669,6 +6670,58 @@ describe("MultiTabAssistantChat cold-start delivery (Mode B)", () => {
     );
   });
 
+  it("rejects a submission whose retry window has expired", async () => {
+    const submissionExpiresAt = Date.now() - 1;
+    const results: unknown[] = [];
+    const onResult = (event: Event) =>
+      results.push((event as CustomEvent).detail);
+    window.addEventListener(AGENT_CHAT_SUBMIT_RESULT_EVENT, onResult);
+
+    try {
+      await act(async () => {
+        root.render(<MultiTabAssistantChat storageKey="mode-b" />);
+        await Promise.resolve();
+      });
+      dispatchSubmitChat({
+        message: "Create a deck",
+        submissionExpiresAt,
+        submitMessageId: "expired-submit",
+      });
+
+      expect(chatHandleMocks.sendMessage).not.toHaveBeenCalled();
+      expect(results).toContainEqual({
+        submitMessageId: "expired-submit",
+        delivered: false,
+        reason: "submission-expired",
+      });
+    } finally {
+      window.removeEventListener(AGENT_CHAT_SUBMIT_RESULT_EVENT, onResult);
+    }
+  });
+
+  it("passes a submission expiry to the chat that receives the message", async () => {
+    const submissionExpiresAt = Date.now() + 20_000;
+    await act(async () => {
+      root.render(<MultiTabAssistantChat storageKey="mode-b" />);
+      await Promise.resolve();
+    });
+
+    dispatchSubmitChat({
+      message: "Create a deck",
+      submissionExpiresAt,
+      submitMessageId: "deadline-submit",
+    });
+
+    expect(chatHandleMocks.sendMessage).toHaveBeenCalledWith(
+      "Create a deck",
+      undefined,
+      {
+        submitMessageId: "deadline-submit",
+        submissionExpiresAt,
+      },
+    );
+  });
+
   it("ignores a duplicate submit with the same submitMessageId", async () => {
     await act(async () => {
       root.render(<MultiTabAssistantChat storageKey="mode-b" />);

package/src/app/chat/MultiTabAssistantChat.tsx

@@ -121,6 +121,7 @@ interface PendingSend {
   requestMode?: "act" | "plan";
   /** Correlates with `AGENT_CHAT_SUBMIT_RESULT_EVENT` — see agent-chat.ts. */
   submitMessageId?: string;
+  submissionExpiresAt?: number;
   /** See `AgentChatMessage.usageLabel`. */
   usageLabel?: string;
   actionScope?: AgentActionScope;
@@ -227,6 +228,18 @@ function deliverPendingSend(
   onHandoff: (delivered: boolean) => boolean,
 ): void | Promise<void> {
   if (isAgentChatSubmitCancelled(send.submitMessageId)) return;
+  if (
+    send.submissionExpiresAt !== undefined &&
+    send.submissionExpiresAt <= Date.now()
+  ) {
+    if (onHandoff(false))
+      reportAgentChatSubmitResult(
+        send.submitMessageId,
+        false,
+        "submission-expired",
+      );
+    return;
+  }
   if (!send.submit) {
     return deliverPendingPrefill(ref, send, isCurrent, onHandoff).catch(
       (error: unknown) => {
@@ -250,6 +263,9 @@ function deliverPendingSend(
     ...(send.requestMode ? { requestMode: send.requestMode } : {}),
     ...(send.attachments ? { attachments: send.attachments } : {}),
     ...(send.submitMessageId ? { submitMessageId: send.submitMessageId } : {}),
+    ...(send.submissionExpiresAt !== undefined
+      ? { submissionExpiresAt: send.submissionExpiresAt }
+      : {}),
     ...(send.usageLabel ? { usageLabel: send.usageLabel } : {}),
     ...(send.actionScope ? { actionScope: send.actionScope } : {}),
     // An approval resume is a protocol continuation, not a visible prompt.
@@ -2259,6 +2275,23 @@ export function MultiTabAssistantChat({
     (onlyThreadId?: string, immediate?: boolean) => void
   >(
     (onlyThreadId, immediate = false) => {
+      for (const delivery of [...pendingDeliveries.current]) {
+        if (
+          delivery.send.submissionExpiresAt === undefined ||
+          delivery.send.submissionExpiresAt > Date.now()
+        ) {
+          continue;
+        }
+        pendingDeliveries.current = pendingDeliveries.current.filter(
+          (pending) => pending !== delivery,
+        );
+        reportAgentChatSubmitResult(
+          delivery.send.submitMessageId,
+          false,
+          "submission-expired",
+        );
+        cancelAgentChatSubmit(delivery.send.submitMessageId);
+      }
       const active = activeThreadIdRef.current;
       for (const delivery of pendingDeliveries.current) {
         if (delivery.threadId === null && active) delivery.threadId = active;
@@ -2524,9 +2557,11 @@ export function MultiTabAssistantChat({
         ...(submitMessageId ? { submitMessageId } : {}),
         ...(usageLabel ? { usageLabel } : {}),
         ...(actionScope ? { actionScope } : {}),
+        ...(typeof parsed.submissionExpiresAt === "number"
+          ? { submissionExpiresAt: parsed.submissionExpiresAt }
+          : {}),
         ...(approvedToolCalls ? { approvedToolCalls } : {}),
       };
-
       // Resolved once, up front, and carried with the send until a thread
       // exists to key it by. Applying it only when `model` matched
       // `availableModels` dropped every override that arrived before the

package/src/app/chat/chat/surface-types.ts

@@ -46,6 +46,8 @@ export interface AssistantChatSendOptions {
   attachments?: AgentChatAttachment[];
   /** Correlates with `AGENT_CHAT_SUBMIT_RESULT_EVENT` — see agent-chat.ts. */
   submitMessageId?: string;
+  /** Drop a queued submit instead of handing it to chat after this time. */
+  submissionExpiresAt?: number;
   /** See `AgentChatMessage.usageLabel`. */
   usageLabel?: string;
   actionScope?: AgentActionScope;
@@ -59,7 +61,10 @@ export type AssistantChatSubmitResult =
   | { status: "submitted" }
   | {
       status: "rejected";
-      reason: "engine-not-configured" | "submission-unavailable";
+      reason:
+        | "engine-not-configured"
+        | "submission-unavailable"
+        | "submission-expired";
     };
 
 export interface AssistantChatHandle {