@agent-native/core 0.207.0-nightly-20261011124220 → 0.207.0

package/dist/templates/chat/app/components/chat/ChatRouteContent.tsx

@@ -1,7 +1,11 @@
 import type {
   AgentConnectionRequest,
   AgentMessage,
+  AgentRunOptions,
+  FilePart,
 } from "@agent-native/agentkit";
+import { appendAgentChatContextToMessage } from "@agent-native/agentkit";
+import { hasActiveAgentRuns } from "@agent-native/agentkit/client";
 import { createAgentKitIntegrityReporter } from "@agent-native/core/client/agentkit-chat/integrity";
 import { createAgentNativeAgentKitTransport } from "@agent-native/core/client/agentkit-chat/transport";
 import {
@@ -41,15 +45,21 @@ import {
   BuilderSetupCard,
   isMissingLlmProviderRunError,
 } from "@agent-native/toolkit/app/chat/chat/run-recovery";
-import { IconLayoutSidebarRight } from "@tabler/icons-react";
+import type {
+  PromptComposerFile,
+  PromptComposerSubmitOptions,
+  Reference,
+} from "@agent-native/toolkit/composer";
+import { IconLayoutSidebarRight, IconX } from "@tabler/icons-react";
 import {
   useCallback,
   useEffect,
+  useMemo,
   useRef,
   useState,
   type ReactNode,
 } from "react";
-import { useNavigate, useParams } from "react-router";
+import { useLocation, useNavigate, useParams } from "react-router";
 import { toast } from "sonner";
 
 import { Button } from "@/components/ui/button";
@@ -60,16 +70,31 @@ import {
 } from "@/components/ui/tooltip";
 import { APP_TITLE } from "@/lib/app-config";
 import { consumeChatHomeThreadId } from "@/lib/chat-home-thread";
+import {
+  clearFailedChatHandoff,
+  chatThreadPath,
+  readFailedChatHandoff,
+  type ChatInitialComposerOptions,
+  type FailedChatHandoffClearResult,
+  type FailedChatHandoffEnvelope,
+  type FailedChatHandoffReadResult,
+  type FailedChatHandoffWriteResult,
+  initialComposerOptionsFromState,
+  initialMessageFromState,
+  writeFailedChatHandoff,
+} from "@/lib/chat-paths";
 import { TAB_ID } from "@/lib/tab-id";
 
-function chatThreadPath(threadId: string | null) {
-  return threadId ? `/chat/${encodeURIComponent(threadId)}` : "/home";
-}
-
 // Module scope on purpose: CoreAgentKitRoot memoizes the client on its options, so
 // a new callback each render would rebuild the client and drop the stream.
 const reportStreamIntegrity = createAgentKitIntegrityReporter("chat");
 
+type FailedInitialDraft = FailedChatHandoffEnvelope & {
+  attempt: number;
+  threadId: string;
+  unsaved: boolean;
+};
+
 export default function ChatRouteContent({
   initialThreadId,
 }: {
@@ -101,6 +126,186 @@ function ChatThreadRouteContent({
 }) {
   const t = useT();
   const [workspaceOpen, setWorkspaceOpen] = useState(false);
+  const [handoffStorageRevision, setHandoffStorageRevision] = useState(0);
+  const failedHandoffStorageFailureReportedRef = useRef(new Set<string>());
+  const reportHandoffStorageFailure = useCallback(
+    (
+      result:
+        | FailedChatHandoffReadResult
+        | FailedChatHandoffWriteResult
+        | FailedChatHandoffClearResult,
+      message: string,
+    ) => {
+      if (result.status !== "invalid" && result.status !== "unavailable") {
+        return;
+      }
+      if (
+        failedHandoffStorageFailureReportedRef.current.has(resolvedThreadId)
+      ) {
+        return;
+      }
+      failedHandoffStorageFailureReportedRef.current.add(resolvedThreadId);
+      captureException(
+        result.status === "unavailable"
+          ? result.cause
+          : new Error(`${message}: ${result.reason}`),
+        { tags: { area: "chat_handoff_storage" } },
+      );
+    },
+    [resolvedThreadId],
+  );
+  const restoredHandoffResult = useMemo(
+    () => readFailedChatHandoff(resolvedThreadId),
+    [handoffStorageRevision, resolvedThreadId],
+  );
+  const restoredHandoff =
+    restoredHandoffResult.status === "found"
+      ? restoredHandoffResult.handoff
+      : null;
+  const [failedInitialDrafts, setFailedInitialDrafts] = useState<
+    Map<string, FailedInitialDraft>
+  >(() => {
+    return restoredHandoff
+      ? new Map([
+          [
+            resolvedThreadId,
+            {
+              text: restoredHandoff.text,
+              options: restoredHandoff.options,
+              attempt: 0,
+              threadId: resolvedThreadId,
+              unsaved: false,
+            },
+          ],
+        ])
+      : new Map();
+  });
+  const failedInitialDraftsRef = useRef(failedInitialDrafts);
+  const restoredForRoute = restoredHandoff;
+  const failedDraftForRoute =
+    failedInitialDrafts.get(resolvedThreadId) ??
+    (restoredForRoute
+      ? {
+          text: restoredForRoute.text,
+          options: restoredForRoute.options,
+          attempt: 0,
+          threadId: resolvedThreadId,
+          unsaved: false,
+        }
+      : null);
+  const failedInitialDraftRef = useRef(failedDraftForRoute);
+  failedInitialDraftRef.current = failedDraftForRoute;
+  const failedInitialDraftAttemptRef = useRef(0);
+  const setFailedInitialDraftForThread = useCallback(
+    (threadId: string, draft: FailedInitialDraft | null) => {
+      const next = new Map(failedInitialDraftsRef.current);
+      if (draft) next.set(threadId, draft);
+      else next.delete(threadId);
+      failedInitialDraftsRef.current = next;
+      setFailedInitialDrafts(next);
+    },
+    [],
+  );
+  useEffect(() => {
+    reportHandoffStorageFailure(
+      restoredHandoffResult,
+      "Could not restore the failed Chat handoff",
+    );
+    if (failedInitialDraftsRef.current.has(resolvedThreadId)) return;
+    if (!restoredHandoff) return;
+    setFailedInitialDraftForThread(resolvedThreadId, {
+      text: restoredHandoff.text,
+      options: restoredHandoff.options,
+      attempt: 0,
+      threadId: resolvedThreadId,
+      unsaved: false,
+    });
+  }, [
+    reportHandoffStorageFailure,
+    resolvedThreadId,
+    restoredHandoff,
+    restoredHandoffResult,
+    setFailedInitialDraftForThread,
+  ]);
+  const handleInitialMessageFailure = useCallback(
+    (
+      text: string,
+      options: ChatInitialComposerOptions,
+      persistence = writeFailedChatHandoff(resolvedThreadId, text, options),
+    ) => {
+      failedInitialDraftAttemptRef.current += 1;
+      reportHandoffStorageFailure(
+        persistence,
+        "Could not save the failed Chat handoff",
+      );
+      const failedDraft = {
+        text,
+        options,
+        attempt: failedInitialDraftAttemptRef.current,
+        threadId: resolvedThreadId,
+        unsaved: persistence.status !== "stored",
+      };
+      failedInitialDraftRef.current = failedDraft;
+      setFailedInitialDraftForThread(resolvedThreadId, failedDraft);
+    },
+    [
+      reportHandoffStorageFailure,
+      resolvedThreadId,
+      setFailedInitialDraftForThread,
+    ],
+  );
+  const handleInitialMessageAccepted = useCallback(() => {
+    reportHandoffStorageFailure(
+      clearFailedChatHandoff(resolvedThreadId),
+      "Could not clear the accepted Chat handoff",
+    );
+    if (failedInitialDraftsRef.current.has(resolvedThreadId)) {
+      if (failedInitialDraftRef.current?.threadId === resolvedThreadId) {
+        failedInitialDraftRef.current = null;
+      }
+      setFailedInitialDraftForThread(resolvedThreadId, null);
+    }
+    setHandoffStorageRevision((revision) => revision + 1);
+  }, [
+    reportHandoffStorageFailure,
+    resolvedThreadId,
+    setFailedInitialDraftForThread,
+  ]);
+  const updateFailedInitialDraft = useCallback(
+    (
+      update: Partial<FailedChatHandoffEnvelope> & {
+        options?: Partial<ChatInitialComposerOptions>;
+      },
+    ) => {
+      const current = failedInitialDraftRef.current;
+      if (current?.threadId !== resolvedThreadId) return;
+      const next = {
+        ...current,
+        ...update,
+        options: { ...current.options, ...update.options },
+      };
+      const persistence = writeFailedChatHandoff(
+        next.threadId,
+        next.text,
+        next.options,
+      );
+      const nextDraft = {
+        ...next,
+        unsaved: persistence.status !== "stored",
+      };
+      failedInitialDraftRef.current = nextDraft;
+      reportHandoffStorageFailure(
+        persistence,
+        "Could not save the failed Chat handoff",
+      );
+      setFailedInitialDraftForThread(resolvedThreadId, nextDraft);
+    },
+    [
+      reportHandoffStorageFailure,
+      resolvedThreadId,
+      setFailedInitialDraftForThread,
+    ],
+  );
 
   const [transport] = useState(() =>
     createAgentNativeAgentKitTransport({
@@ -148,10 +353,33 @@ function ChatThreadRouteContent({
             onThreadForked={(thread) => navigate(chatThreadPath(thread.id))}
           >
             <ChatLifecycleTracking threadId={resolvedThreadId} />
+            <ChatInitialMessage
+              threadId={resolvedThreadId}
+              hasRestoredDraft={failedDraftForRoute !== null}
+              onFailure={handleInitialMessageFailure}
+              onAccepted={handleInitialMessageAccepted}
+            />
             <ChatMcpConnectionResume />
             <ChatCanvas
               workspaceOpen={workspaceOpen}
               setWorkspaceOpen={setWorkspaceOpen}
+              initialText={
+                failedDraftForRoute ? failedDraftForRoute.text : undefined
+              }
+              initialTextKey={
+                failedDraftForRoute
+                  ? `${resolvedThreadId}:${failedDraftForRoute.attempt}`
+                  : undefined
+              }
+              recoveryOptions={
+                failedDraftForRoute ? failedDraftForRoute.options : undefined
+              }
+              recoveryDraftUnsaved={failedDraftForRoute?.unsaved ?? false}
+              onRecoveryOptionsChange={(options) =>
+                updateFailedInitialDraft({ options })
+              }
+              onRecoveryDraftChange={updateFailedInitialDraft}
+              onRecoverySubmitAccepted={handleInitialMessageAccepted}
             />
           </CoreAgentKitRoot>
         </CoreComposerRuntimeProvider>
@@ -193,6 +421,74 @@ type ChatRetryError = {
   runId: string;
 };
 
+function RecoveryIncludedSources({
+  references,
+  attachments,
+  onRemoveReference,
+  onRemoveAttachment,
+}: {
+  references: readonly Reference[];
+  attachments: readonly FilePart[];
+  onRemoveReference: (index: number) => void;
+  onRemoveAttachment: (index: number) => void;
+}) {
+  const t = useT();
+  if (references.length === 0 && attachments.length === 0) return null;
+  return (
+    <div
+      className="flex max-w-full flex-wrap gap-1.5"
+      data-testid="recovery-included-sources"
+    >
+      {references.map((reference, index) => (
+        <span
+          key={`reference:${index}:${reference.path}`}
+          className="inline-flex min-w-0 items-center gap-1 rounded-md border border-border bg-muted/50 px-2 py-1 text-xs"
+          data-recovery-source="reference"
+        >
+          <span className="max-w-48 truncate">
+            {reference.name || reference.path}
+          </span>
+          <Button
+            type="button"
+            variant="ghost"
+            size="icon-xs"
+            className="-me-1"
+            aria-label={t("composer.removeReference", {
+              name: reference.name || reference.path,
+            })}
+            data-testid={`remove-recovery-reference-${index}`}
+            onClick={() => onRemoveReference(index)}
+          >
+            <IconX aria-hidden="true" className="size-3" />
+          </Button>
+        </span>
+      ))}
+      {attachments.map((attachment, index) => (
+        <span
+          key={`attachment:${index}:${attachment.name}`}
+          className="inline-flex min-w-0 items-center gap-1 rounded-md border border-border bg-muted/50 px-2 py-1 text-xs"
+          data-recovery-source="attachment"
+        >
+          <span className="max-w-48 truncate">{attachment.name}</span>
+          <Button
+            type="button"
+            variant="ghost"
+            size="icon-xs"
+            className="-me-1"
+            aria-label={t("composer.removeAttachment", {
+              name: attachment.name,
+            })}
+            data-testid={`remove-recovery-attachment-${index}`}
+            onClick={() => onRemoveAttachment(index)}
+          >
+            <IconX aria-hidden="true" className="size-3" />
+          </Button>
+        </span>
+      ))}
+    </div>
+  );
+}
+
 function ChatRunFailure({
   error,
   runId,
@@ -210,6 +506,9 @@ function ChatRunFailure({
             custom?: {
               agentNativeRecoveryAction?: unknown;
               agentNativeRecoveryOfRunId?: unknown;
+              agentNativeQueueWhileRunning?: unknown;
+              agentNativeQueuedWhileRunActive?: unknown;
+              agentNativeInterruptActiveRun?: unknown;
             };
           }
         | undefined
@@ -220,6 +519,96 @@ function ChatRunFailure({
     return action !== "continue" && action !== "retry";
   });
   const originalRequest = userRequests[0];
+  const originalMetadata =
+    originalRequest?.metadata &&
+    typeof originalRequest.metadata === "object" &&
+    !Array.isArray(originalRequest.metadata)
+      ? (originalRequest.metadata as Record<string, unknown>)
+      : {};
+  const originalMode =
+    originalMetadata.mode === "act" || originalMetadata.mode === "plan"
+      ? originalMetadata.mode
+      : originalMetadata.requestMode === "act" ||
+          originalMetadata.requestMode === "plan"
+        ? originalMetadata.requestMode
+        : undefined;
+  const originalComposerOptions = initialComposerOptionsFromState({
+    initialComposerOptions: {
+      ...(typeof originalMetadata.engine === "string"
+        ? { engine: originalMetadata.engine }
+        : {}),
+      ...(typeof originalMetadata.model === "string"
+        ? { model: originalMetadata.model }
+        : {}),
+      ...(typeof originalMetadata.effort === "string"
+        ? { effort: originalMetadata.effort }
+        : {}),
+      ...(originalMode ? { mode: originalMode } : {}),
+      ...(Array.isArray(originalMetadata.references)
+        ? { references: originalMetadata.references }
+        : {}),
+      ...(Array.isArray(originalMetadata.contextItems)
+        ? { contextItems: originalMetadata.contextItems }
+        : {}),
+    },
+  });
+  const originalComposerSettings: ChatInitialComposerOptions =
+    originalComposerOptions.status === "valid"
+      ? originalComposerOptions.options
+      : { mode: "act" };
+  const originalCustomMetadata = originalRequest
+    ? recoveryMetadata(originalRequest)
+    : undefined;
+  const queueWhileRunning =
+    typeof originalCustomMetadata?.agentNativeQueueWhileRunning === "boolean"
+      ? originalCustomMetadata.agentNativeQueueWhileRunning
+      : originalComposerSettings.intent !== "immediate";
+  const queuedWhileRunActive =
+    typeof originalCustomMetadata?.agentNativeQueuedWhileRunActive === "boolean"
+      ? originalCustomMetadata.agentNativeQueuedWhileRunActive
+      : originalComposerSettings.intent === "queued";
+  const interruptActiveRun =
+    typeof originalCustomMetadata?.agentNativeInterruptActiveRun === "boolean"
+      ? originalCustomMetadata.agentNativeInterruptActiveRun
+      : originalComposerSettings.steer === true;
+  const originalReferences = originalComposerSettings.references ?? [];
+  const hasOriginalExecutionSettings = Boolean(
+    originalMode ||
+    originalComposerSettings.engine ||
+    originalComposerSettings.model ||
+    originalComposerSettings.effort,
+  );
+  const originalAttachments =
+    originalRequest?.parts?.filter((part) => part.type === "file") ?? [];
+  const [retryItems, setRetryItems] = useState<{
+    runId: string;
+    references: Reference[];
+    attachments: FilePart[];
+  } | null>(null);
+  const visibleRetryItems =
+    retryItems?.runId === runId
+      ? retryItems
+      : {
+          runId,
+          references: originalReferences,
+          attachments: originalAttachments,
+        };
+  const updateRetryItems = (update: {
+    references?: Reference[];
+    attachments?: FilePart[];
+  }) => {
+    setRetryError(null);
+    setRetryItems((current) => ({
+      ...(current?.runId === runId
+        ? current
+        : {
+            runId,
+            references: [...originalReferences],
+            attachments: originalAttachments,
+          }),
+      ...update,
+    }));
+  };
   const hasRetryForThisRun = thread.messages.some(
     (message) =>
       recoveryMetadata(message)?.agentNativeRecoveryAction === "retry" &&
@@ -227,8 +616,7 @@ function ChatRunFailure({
   );
   const retryFirstMessage = useCallback(async () => {
     if (retryStartedForRunsRef.current.has(runId)) return;
-    const attachments =
-      originalRequest?.parts.filter((part) => part.type === "file") ?? [];
+    const attachments = visibleRetryItems.attachments;
     if (attachments.some((part) => part.fileId && !part.url)) {
       setRetryError({ code: "attachment_id_unavailable", runId });
       return;
@@ -240,18 +628,59 @@ function ChatRunFailure({
         .filter((part) => part.type === "text")
         .map((part) => part.text)
         .join("\n") ?? "";
+    const retryMetadata = {
+      ...(originalComposerSettings.engine
+        ? { engine: originalComposerSettings.engine }
+        : {}),
+      ...(originalComposerSettings.model
+        ? { model: originalComposerSettings.model }
+        : {}),
+      ...(originalComposerSettings.effort
+        ? { effort: originalComposerSettings.effort }
+        : {}),
+      ...(visibleRetryItems.references.length
+        ? { references: visibleRetryItems.references }
+        : {}),
+      ...(originalComposerSettings.contextItems === undefined
+        ? {}
+        : { contextItems: originalComposerSettings.contextItems }),
+      ...(originalMode
+        ? { mode: originalMode, requestMode: originalMode }
+        : {}),
+      custom: {
+        agentNativeRecoveryAction: "retry",
+        agentNativeRecoveryOfRunId: runId,
+        agentNativeQueueWhileRunning: queueWhileRunning,
+        agentNativeQueuedWhileRunActive: queuedWhileRunActive,
+        agentNativeInterruptActiveRun: interruptActiveRun,
+      },
+    };
+    const retryRunOptions: AgentRunOptions = {
+      ...(originalComposerSettings.model
+        ? { model: originalComposerSettings.model }
+        : {}),
+      ...(originalMode ? { mode: originalMode } : {}),
+      ...(originalComposerSettings.effort &&
+      !["auto", "max"].includes(originalComposerSettings.effort)
+        ? {
+            reasoningEffort: originalComposerSettings.effort as NonNullable<
+              AgentRunOptions["reasoningEffort"]
+            >,
+          }
+        : {}),
+      metadata: retryMetadata,
+    };
     let send: unknown;
     try {
       send = controller.sendMessage({
         threadId,
         text: prompt || t("chat.retryPreviousRequest"),
         ...(attachments.length ? { attachments } : {}),
-        metadata: {
-          custom: {
-            agentNativeRecoveryAction: "retry",
-            agentNativeRecoveryOfRunId: runId,
-          },
-        },
+        ...(hasOriginalExecutionSettings ? { options: retryRunOptions } : {}),
+        metadata: retryMetadata,
+        queueWhileRunning,
+        queuedWhileRunActive,
+        ...(interruptActiveRun ? { interruptActiveRun: true } : {}),
       });
     } catch (error) {
       retryStartedForRunsRef.current.delete(runId);
@@ -262,7 +691,19 @@ function ChatRunFailure({
       retryStartedForRunsRef.current.delete(runId);
       captureException(error, { tags: { area: "chat_retry" } });
     });
-  }, [controller, originalRequest, runId, t, threadId]);
+  }, [
+    controller,
+    originalComposerSettings,
+    queueWhileRunning,
+    queuedWhileRunActive,
+    interruptActiveRun,
+    originalMode,
+    originalRequest,
+    runId,
+    t,
+    threadId,
+    visibleRetryItems,
+  ]);
   const isFirstMessage = userRequests.length === 1 && !hasRetryForThisRun;
   if (
     isFirstMessage &&
@@ -279,6 +720,24 @@ function ChatRunFailure({
           layout="sidebar"
           onRetry={retryFirstMessage}
         />
+        <RecoveryIncludedSources
+          references={visibleRetryItems.references}
+          attachments={visibleRetryItems.attachments}
+          onRemoveReference={(index) =>
+            updateRetryItems({
+              references: visibleRetryItems.references.filter(
+                (_reference, candidate) => candidate !== index,
+              ),
+            })
+          }
+          onRemoveAttachment={(index) =>
+            updateRetryItems({
+              attachments: visibleRetryItems.attachments.filter(
+                (_attachment, candidate) => candidate !== index,
+              ),
+            })
+          }
+        />
         {retryError?.runId === runId &&
         retryError.code === "attachment_id_unavailable" ? (
           <p role="alert" className="mt-2 px-3 text-sm text-destructive">
@@ -291,6 +750,159 @@ function ChatRunFailure({
   return <AgentRunFailure error={error} runId={runId} threadId={threadId} />;
 }
 
+function ChatInitialMessage({
+  threadId,
+  hasRestoredDraft,
+  onFailure,
+  onAccepted,
+}: {
+  threadId: string;
+  hasRestoredDraft: boolean;
+  onFailure: (
+    text: string,
+    options: ChatInitialComposerOptions,
+    persistence?: FailedChatHandoffWriteResult,
+  ) => void;
+  onAccepted: () => void;
+}) {
+  const location = useLocation();
+  const navigate = useNavigate();
+  const t = useT();
+  const control = useAgentKitControl(threadId);
+  const thread = useAgentThread(threadId);
+  const sentRef = useRef(false);
+  const message = initialMessageFromState(location.state);
+  const composerOptionsResult = initialComposerOptionsFromState(location.state);
+  const invalidComposerOptions = composerOptionsResult.status === "invalid";
+  const composerOptions =
+    composerOptionsResult.status === "valid"
+      ? composerOptionsResult.options
+      : undefined;
+  const engine = composerOptions?.engine;
+  const model = composerOptions?.model;
+  const effort = composerOptions?.effort;
+  const mode = composerOptions?.mode ?? "act";
+  const references = composerOptions?.references ?? [];
+  const contextItems = composerOptions?.contextItems;
+  const activeAtSubmit = hasActiveAgentRuns(thread);
+
+  useEffect(() => {
+    if (!message || sentRef.current) return;
+    if (hasRestoredDraft) {
+      sentRef.current = true;
+      return;
+    }
+    sentRef.current = true;
+    const clearRouteState = () =>
+      navigate(
+        { pathname: location.pathname, search: location.search },
+        { replace: true, state: null },
+      );
+    if (invalidComposerOptions) {
+      clearRouteState();
+      onFailure(message, {});
+      toast.error(t("chat.invalidHandoffOptions"));
+      captureException(new Error("Invalid options in initial Chat handoff"), {
+        tags: { area: "chat_initial_message" },
+      });
+      return;
+    }
+    const options = composerOptions ?? {};
+    const persistence = writeFailedChatHandoff(threadId, message, options);
+    if (persistence.status !== "stored") {
+      clearRouteState();
+      onFailure(message, options, persistence);
+      if (
+        persistence.status !== "invalid" ||
+        persistence.reason !== "payload-too-large"
+      ) {
+        return;
+      }
+    } else {
+      // Router state survives a reload, so drop it before sending or a refresh
+      // cannot distinguish a pending send from a failed one.
+      clearRouteState();
+    }
+    const context = [
+      composerOptions?.composerModeContext,
+      contextItems?.map((item) => item.context).join("\n\n"),
+    ]
+      .filter(Boolean)
+      .join("\n\n");
+    const requestText = context
+      ? appendAgentChatContextToMessage(message, context)
+      : message;
+    const queuedIntent =
+      composerOptions?.intent === "queued" ||
+      (composerOptions?.intent !== "immediate" && activeAtSubmit);
+    const metadata = {
+      ...(engine ? { engine } : {}),
+      ...(model ? { model } : {}),
+      ...(effort ? { effort } : {}),
+      ...(references.length ? { references } : {}),
+      ...(contextItems === undefined ? {} : { contextItems }),
+      mode,
+      requestMode: mode,
+      custom: {
+        agentNativeQueueWhileRunning: composerOptions?.intent !== "immediate",
+        agentNativeQueuedWhileRunActive: queuedIntent,
+        agentNativeInterruptActiveRun: composerOptions?.steer === true,
+      },
+    };
+    const runOptions: AgentRunOptions = {
+      ...(model ? { model } : {}),
+      mode,
+      ...(effort && !["auto", "max"].includes(effort)
+        ? {
+            reasoningEffort: effort as NonNullable<
+              AgentRunOptions["reasoningEffort"]
+            >,
+          }
+        : {}),
+      metadata,
+    };
+    void Promise.resolve(
+      control.sendMessage({
+        text: requestText,
+        attachments: [...(composerOptions?.uploadedAttachments ?? [])],
+        options: runOptions,
+        metadata,
+        queueWhileRunning: metadata.custom.agentNativeQueueWhileRunning,
+        queuedWhileRunActive: queuedIntent,
+        ...(metadata.custom.agentNativeInterruptActiveRun
+          ? { interruptActiveRun: true }
+          : {}),
+      }),
+    )
+      .then(onAccepted)
+      .catch((error: unknown) => {
+        onFailure(message, composerOptions ?? {});
+        captureException(error, { tags: { area: "chat_initial_message" } });
+        toast.error(error instanceof Error ? error.message : String(error));
+      });
+  }, [
+    composerOptions,
+    control,
+    contextItems,
+    activeAtSubmit,
+    hasRestoredDraft,
+    invalidComposerOptions,
+    engine,
+    effort,
+    location.pathname,
+    location.search,
+    message,
+    model,
+    navigate,
+    onAccepted,
+    onFailure,
+    t,
+    threadId,
+  ]);
+
+  return null;
+}
+
 function ChatLifecycleTracking({ threadId }: { threadId: string }) {
   const thread = useAgentThread(threadId);
   const lifecycleRef = useRef({
@@ -520,17 +1132,160 @@ function ChatEmptyState() {
 function ChatCanvas({
   workspaceOpen,
   setWorkspaceOpen,
+  initialText,
+  initialTextKey,
+  recoveryOptions,
+  onRecoveryOptionsChange,
+  onRecoveryDraftChange,
+  onRecoverySubmitAccepted,
+  recoveryDraftUnsaved,
 }: {
   workspaceOpen: boolean;
   setWorkspaceOpen: (value: boolean | ((current: boolean) => boolean)) => void;
+  initialText?: string;
+  initialTextKey?: string;
+  recoveryOptions?: ChatInitialComposerOptions;
+  recoveryDraftUnsaved: boolean;
+  onRecoveryOptionsChange: (
+    options: Partial<ChatInitialComposerOptions>,
+  ) => void;
+  onRecoveryDraftChange: (
+    update: Partial<FailedChatHandoffEnvelope> & {
+      options?: Partial<ChatInitialComposerOptions>;
+    },
+  ) => void;
+  onRecoverySubmitAccepted: () => void;
 }) {
   const t = useT();
+  const { threadId } = useAgentKit();
   const thread = useAgentThread();
+  const control = useAgentKitControl(threadId);
   const stopButton = useAgentKitStopButton({
     label: t("agentChat.composer.stopResponse"), // i18n-key-ignore shared framework catalog
     onError: (error) => toast.error(error.message),
   });
   const hasConversation = thread.messages.length > 0;
+  const activeAtSubmit = hasActiveAgentRuns(thread);
+
+  const retryInitialDraft = useCallback(
+    async (
+      text: string,
+      files: PromptComposerFile[],
+      references: Reference[],
+      options: PromptComposerSubmitOptions,
+    ) => {
+      if (!recoveryOptions) return;
+      const contextItems = options.contextItems ?? recoveryOptions.contextItems;
+      const composerModeContext =
+        options.composerModeContext ?? recoveryOptions.composerModeContext;
+      const context = [
+        composerModeContext,
+        contextItems?.map((item) => item.context).join("\n\n"),
+      ]
+        .filter(Boolean)
+        .join("\n\n");
+      const requestText = context
+        ? appendAgentChatContextToMessage(text, context)
+        : text;
+      const runMode = recoveryOptions.mode ?? "act";
+      const model = options.model ?? recoveryOptions.model;
+      const engine = options.engine ?? recoveryOptions.engine;
+      const effort = options.effort ?? recoveryOptions.effort;
+      const mergedReferences = [
+        ...(recoveryOptions.references ?? []),
+        ...references,
+      ].filter(
+        (reference, index, all) =>
+          all.findIndex(
+            (candidate) =>
+              candidate.type === reference.type &&
+              candidate.source === reference.source &&
+              candidate.path === reference.path &&
+              candidate.refId === reference.refId,
+          ) === index,
+      );
+      const retryIntent = options.intent ?? recoveryOptions.intent;
+      const queuedIntent =
+        retryIntent === "queued" ||
+        (retryIntent === undefined && activeAtSubmit);
+      const retrySteer = options.steer ?? recoveryOptions.steer;
+      const retryOptions: ChatInitialComposerOptions = {
+        ...recoveryOptions,
+        mode: runMode,
+        ...(model ? { model } : {}),
+        ...(engine ? { engine } : {}),
+        ...(effort ? { effort } : {}),
+        ...(retryIntent === undefined ? {} : { intent: retryIntent }),
+        ...(retrySteer === undefined ? {} : { steer: retrySteer }),
+        ...(contextItems === undefined ? {} : { contextItems }),
+        ...(composerModeContext === undefined ? {} : { composerModeContext }),
+        references: mergedReferences,
+        uploadedAttachments: recoveryOptions.uploadedAttachments ?? [],
+      };
+      onRecoveryDraftChange({ text, options: retryOptions });
+      const uploadedAttachments = files.length
+        ? await control.uploadFiles(
+            files.map((file) => ({
+              name: file.name,
+              mediaType: file.type || "application/octet-stream",
+              size: file.size,
+              body: file,
+            })),
+          )
+        : [];
+      const acceptedOptions = {
+        ...retryOptions,
+        uploadedAttachments: [
+          ...(recoveryOptions.uploadedAttachments ?? []),
+          ...uploadedAttachments,
+        ],
+      };
+      onRecoveryDraftChange({ text, options: acceptedOptions });
+      const metadata = {
+        ...(engine ? { engine } : {}),
+        ...(model ? { model } : {}),
+        ...(effort ? { effort } : {}),
+        ...(mergedReferences.length ? { references: mergedReferences } : {}),
+        ...(contextItems === undefined ? {} : { contextItems }),
+        mode: runMode,
+        requestMode: runMode,
+      };
+      const runOptions: AgentRunOptions = {
+        ...(model ? { model } : {}),
+        mode: runMode,
+        ...(effort && !["auto", "max"].includes(effort)
+          ? {
+              reasoningEffort: effort as NonNullable<
+                AgentRunOptions["reasoningEffort"]
+              >,
+            }
+          : {}),
+        metadata,
+      };
+      await control.sendMessage({
+        text: requestText,
+        attachments: [
+          ...(recoveryOptions.uploadedAttachments ?? []),
+          ...uploadedAttachments,
+        ],
+        options: runOptions,
+        metadata,
+        queueWhileRunning: retryIntent !== "immediate",
+        queuedWhileRunActive: queuedIntent,
+        ...(retrySteer ? { interruptActiveRun: true } : {}),
+        onLocalSubmit: options.onLocalSubmit,
+      });
+      onRecoverySubmitAccepted();
+    },
+    [
+      activeAtSubmit,
+      control,
+      threadId,
+      onRecoveryDraftChange,
+      onRecoverySubmitAccepted,
+      recoveryOptions,
+    ],
+  );
 
   useEffect(() => {
     if (!hasConversation) setWorkspaceOpen(false);
@@ -563,6 +1318,64 @@ function ChatCanvas({
       emptyComposerPlacement="center"
       composerProps={{
         requireAgentEngine: true,
+        initialText,
+        initialTextKey,
+        ...(recoveryOptions
+          ? {
+              mode: recoveryOptions.mode ?? "act",
+              selectedModel: recoveryOptions.model,
+              selectedEngine: recoveryOptions.engine,
+              selectedEffort: recoveryOptions.effort,
+              contextItems: recoveryOptions.contextItems,
+              onModeChange: (mode: "act" | "plan") =>
+                onRecoveryOptionsChange({ mode }),
+              onModelChange: (model: string, engine: string) =>
+                onRecoveryOptionsChange({ model, engine }),
+              onEffortChange: (
+                effort: NonNullable<ChatInitialComposerOptions["effort"]>,
+              ) => onRecoveryOptionsChange({ effort }),
+              onRemoveContextItem: (key: string) =>
+                onRecoveryOptionsChange({
+                  contextItems: recoveryOptions.contextItems?.filter(
+                    (item) => item.key !== key,
+                  ),
+                }),
+              onTextChange: (text: string) => onRecoveryDraftChange({ text }),
+              toolbarSlot: (
+                <>
+                  {recoveryDraftUnsaved ? (
+                    <p
+                      className="px-2 text-xs text-destructive"
+                      data-testid="chat-recovery-draft-unsaved"
+                      role="status"
+                    >
+                      {t("chat.recoveryDraftUnsaved")}
+                    </p>
+                  ) : null}
+                  <RecoveryIncludedSources
+                    references={recoveryOptions.references ?? []}
+                    attachments={recoveryOptions.uploadedAttachments ?? []}
+                    onRemoveReference={(index) =>
+                      onRecoveryOptionsChange({
+                        references: recoveryOptions.references?.filter(
+                          (_reference, candidate) => candidate !== index,
+                        ),
+                      })
+                    }
+                    onRemoveAttachment={(index) =>
+                      onRecoveryOptionsChange({
+                        uploadedAttachments:
+                          recoveryOptions.uploadedAttachments?.filter(
+                            (_attachment, candidate) => candidate !== index,
+                          ),
+                      })
+                    }
+                  />
+                </>
+              ),
+              onSubmit: retryInitialDraft,
+            }
+          : {}),
         stopButton,
         queueWhileRunning: true,
         autoFocus: true,