Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

Persist mobile composer selectors across drafts (#3496)

Julius Marminge37ac970e289f
diff --git a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
index 92c13c200..ce24198f5 100644
--- a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
+++ b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
@@ -30,7 +30,9 @@ import {
resolveProviderOptionDescriptors,
} from "../../lib/providerOptions";
import { buildThreadRoutePath } from "../../lib/routes";
+import { scopedProjectKey } from "../../lib/scopedEntities";
import { MOBILE_TYPOGRAPHY } from "../../lib/typography";
+import { getComposerDraftSnapshot } from "../../state/use-composer-drafts";
import { useProjects } from "../../state/entities";
import { branchBadgeLabel, useNewTaskFlow } from "./new-task-flow-provider";
import { useCreateProjectThread } from "./use-project-actions";
@@ -63,6 +65,7 @@ export function NewTaskDraftScreen(props: {
const controlsBottomPadding = isKeyboardVisible ? 8 : Math.max(insets.bottom, 10);
const { logicalProjects, selectedProject, setProject } = flow;
const promptInputRef = useRef<ComposerEditorHandle>(null);
+ const loadedBranchesProjectKeyRef = useRef<string | null>(null);
const borderColor = useThemeColor("--color-border");
const sheetFadeOpaque = colorScheme === "dark" ? "rgba(14,14,14,0.98)" : "rgba(242,242,247,0.98)";
@@ -78,6 +81,12 @@ export function NewTaskDraftScreen(props: {
) ?? null;
if (directProject) {
+ if (
+ selectedProject?.environmentId === directProject.environmentId &&
+ selectedProject.id === directProject.id
+ ) {
+ return;
+ }
setProject(directProject);
return;
}
@@ -105,10 +114,16 @@ export function NewTaskDraftScreen(props: {
useEffect(() => {
if (!selectedProject) {
+ loadedBranchesProjectKeyRef.current = null;
+ return;
+ }
+ const projectKey = `${selectedProject.environmentId}:${selectedProject.id}`;
+ if (loadedBranchesProjectKeyRef.current === projectKey) {
return;
}
+ loadedBranchesProjectKeyRef.current = projectKey;
void flow.loadBranches();
- }, [flow, selectedProject]);
+ }, [flow.loadBranches, selectedProject]);
useEffect(() => {
if (!selectedProject) {
@@ -292,11 +307,7 @@ export function NewTaskDraftScreen(props: {
if (!event.startsWith("model:")) {
return;
}
- // Defer state update so the native menu dismiss animation completes
- // before re-rendering the menu actions (prevents submenu jump).
- setTimeout(() => {
- flow.setSelectedModelKey(event.slice("model:".length));
- }, 150);
+ flow.setSelectedModelKey(event.slice("model:".length));
}
function handleEnvironmentMenuAction(event: string) {
@@ -366,27 +377,42 @@ export function NewTaskDraftScreen(props: {
);
async function handleStart(): Promise<void> {
+ const selectedProject = flow.selectedProject;
+ if (!selectedProject) {
+ return;
+ }
+ const draft = getComposerDraftSnapshot(
+ `new-task:${scopedProjectKey(selectedProject.environmentId, selectedProject.id)}`,
+ );
+ const modelSelection = draft.modelSelection ?? flow.selectedModel;
+ const workspaceMode = draft.workspaceSelection?.mode ?? flow.workspaceMode;
+ const selectedBranchName = draft.workspaceSelection?.branch ?? flow.selectedBranchName;
+ const selectedWorktreePath =
+ draft.workspaceSelection?.worktreePath ?? flow.selectedWorktreePath;
+ const runtimeMode = draft.runtimeMode ?? flow.runtimeMode;
+ const interactionMode = draft.interactionMode ?? flow.interactionMode;
+ const initialMessageText = draft.text.trim();
+
if (
- !flow.selectedProject ||
- !flow.selectedModel ||
- flow.prompt.trim().length === 0 ||
+ !modelSelection ||
+ initialMessageText.length === 0 ||
flow.submitting ||
- (flow.workspaceMode === "worktree" && !flow.selectedBranchName)
+ (workspaceMode === "worktree" && !selectedBranchName)
) {
return;
}
flow.setSubmitting(true);
const result = await createProjectThread({
- project: flow.selectedProject,
- modelSelection: flow.selectedModel,
- envMode: flow.workspaceMode,
- branch: flow.selectedBranchName,
- worktreePath: flow.workspaceMode === "worktree" ? null : flow.selectedWorktreePath,
- runtimeMode: flow.runtimeMode,
- interactionMode: flow.interactionMode,
- initialMessageText: flow.prompt.trim(),
- initialAttachments: flow.attachments,
+ project: selectedProject,
+ modelSelection,
+ envMode: workspaceMode,
+ branch: selectedBranchName,
+ worktreePath: workspaceMode === "worktree" ? null : selectedWorktreePath,
+ runtimeMode,
+ interactionMode,
+ initialMessageText,
+ initialAttachments: draft.attachments,
});
flow.setSubmitting(false);
diff --git a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
index 7bb74ae88..f8c916974 100644
--- a/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadRouteScreen.tsx
@@ -1,13 +1,7 @@
import { Stack, useLocalSearchParams, useRouter } from "expo-router";
import { useCallback, useMemo, useState } from "react";
import * as Option from "effect/Option";
-import {
- EnvironmentId,
- type ModelSelection,
- type ProjectScript,
- type ProviderInteractionMode,
- type RuntimeMode,
-} from "@t3tools/contracts";
+import { EnvironmentId, type ProjectScript } from "@t3tools/contracts";
import { projectScriptCwd, projectScriptRuntimeEnv } from "@t3tools/shared/projectScripts";
import { Pressable, ScrollView, Text as RNText, View } from "react-native";
import { useWorkspaceState } from "../../state/workspace";
@@ -79,18 +73,6 @@ export function ThreadRouteScreen() {
const gitState = useSelectedThreadGitState();
const gitActions = useSelectedThreadGitActions();
const requests = useSelectedThreadRequests();
- const updateThreadMetadata = useAtomCommand(
- threadEnvironment.updateMetadata,
- "thread metadata update",
- );
- const setThreadRuntimeMode = useAtomCommand(
- threadEnvironment.setRuntimeMode,
- "thread runtime mode",
- );
- const setThreadInteractionMode = useAtomCommand(
- threadEnvironment.setInteractionMode,
- "thread interaction mode",
- );
const interruptThreadTurn = useAtomCommand(threadEnvironment.interruptTurn, "thread interrupt");
const router = useRouter();
const params = useLocalSearchParams<{
@@ -105,6 +87,18 @@ export function ThreadRouteScreen() {
const routeConnectionState =
routeEnvironmentRuntime?.connectionState ?? (environmentId ? "available" : connectionState);
const routeConnectionError = routeEnvironmentRuntime?.connectionError ?? null;
+ const selectedThreadWithDraftSettings = useMemo(
+ () =>
+ selectedThread
+ ? {
+ ...selectedThread,
+ modelSelection: composer.modelSelection ?? selectedThread.modelSelection,
+ runtimeMode: composer.runtimeMode ?? selectedThread.runtimeMode,
+ interactionMode: composer.interactionMode ?? selectedThread.interactionMode,
+ }
+ : null,
+ [composer.interactionMode, composer.modelSelection, composer.runtimeMode, selectedThread],
+ );
/* ─── Native header theming ──────────────────────────────────────── */
const iconColor = String(useThemeColor("--color-icon"));
@@ -157,51 +151,6 @@ export function ThreadRouteScreen() {
const handleOpenConnectionEditor = useCallback(() => {
void router.push("/connections");
}, [router]);
- const handleUpdateThreadModelSelection = useCallback(
- (modelSelection: ModelSelection) => {
- if (!selectedThread) {
- return;
- }
- return updateThreadMetadata({
- environmentId: selectedThread.environmentId,
- input: {
- threadId: selectedThread.id,
- modelSelection,
- },
- });
- },
- [selectedThread, updateThreadMetadata],
- );
- const handleUpdateThreadRuntimeMode = useCallback(
- (runtimeMode: RuntimeMode) => {
- if (!selectedThread) {
- return;
- }
- return setThreadRuntimeMode({
- environmentId: selectedThread.environmentId,
- input: {
- threadId: selectedThread.id,
- runtimeMode,
- },
- });
- },
- [selectedThread, setThreadRuntimeMode],
- );
- const handleUpdateThreadInteractionMode = useCallback(
- (interactionMode: ProviderInteractionMode) => {
- if (!selectedThread) {
- return;
- }
- return setThreadInteractionMode({
- environmentId: selectedThread.environmentId,
- input: {
- threadId: selectedThread.id,
- interactionMode,
- },
- });
- },
- [selectedThread, setThreadInteractionMode],
- );
const handleStopThread = useCallback(() => {
if (
!selectedThread ||
@@ -435,7 +384,7 @@ export function ThreadRouteScreen() {
<View className="flex-1 bg-screen">
<ThreadDetailScreen
- selectedThread={selectedThread}
+ selectedThread={selectedThreadWithDraftSettings ?? selectedThread}
contentPresentation={contentPresentation}
screenTone={connectionTone(routeConnectionState)}
connectionError={routeConnectionError}
@@ -466,9 +415,9 @@ export function ThreadRouteScreen() {
onStopThread={handleStopThread}
onSendMessage={composer.onSendMessage}
onReconnectEnvironment={handleReconnectEnvironment}
- onUpdateThreadModelSelection={handleUpdateThreadModelSelection}
- onUpdateThreadRuntimeMode={handleUpdateThreadRuntimeMode}
- onUpdateThreadInteractionMode={handleUpdateThreadInteractionMode}
+ onUpdateThreadModelSelection={composer.onUpdateModelSelection}
+ onUpdateThreadRuntimeMode={composer.onUpdateRuntimeMode}
+ onUpdateThreadInteractionMode={composer.onUpdateInteractionMode}
onRespondToApproval={requests.onRespondToApproval}
onSelectUserInputOption={requests.onSelectUserInputOption}
onChangeUserInputCustomAnswer={requests.onChangeUserInputCustomAnswer}
diff --git a/apps/mobile/src/features/threads/new-task-flow-provider.tsx b/apps/mobile/src/features/threads/new-task-flow-provider.tsx
index 3e95a039c..9a8dde342 100644
--- a/apps/mobile/src/features/threads/new-task-flow-provider.tsx
+++ b/apps/mobile/src/features/threads/new-task-flow-provider.tsx
@@ -1,4 +1,4 @@
-import React, { useCallback, useMemo, useRef, useState } from "react";
+import React, { useCallback, useEffect, useMemo, useState } from "react";
import type {
EnvironmentId,
@@ -23,6 +23,7 @@ import {
removeComposerDraftAttachment,
replaceComposerDraftAttachments,
setComposerDraftText,
+ updateComposerDraftSettings,
useComposerDraft,
} from "../../state/use-composer-drafts";
import { useBranches } from "../../state/queries";
@@ -158,34 +159,15 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {
? selectedEnvironmentIdOverride
: (projects[0]?.environmentId ?? null);
const [selectedProjectKey, setSelectedProjectKey] = useState<string | null>(null);
- const [selectedModelKey, setSelectedModelKey] = useState<string | null>(null);
- const [workspaceMode, setWorkspaceMode] = useState<WorkspaceMode>("local");
- const [selectedBranchName, setSelectedBranchName] = useState<string | null>(null);
- const [selectedWorktreePath, setSelectedWorktreePath] = useState<string | null>(null);
- const branchLoadVersionRef = useRef(0);
const [submitting, setSubmitting] = useState(false);
const [branchQuery, setBranchQuery] = useState("");
- const [runtimeMode, setRuntimeMode] = useState<RuntimeMode>(DEFAULT_RUNTIME_MODE);
- const [interactionMode, setInteractionMode] = useState<ProviderInteractionMode>(
- DEFAULT_PROVIDER_INTERACTION_MODE,
- );
- const [modelSelectionOverrides, setModelSelectionOverrides] = useState<
- Record<string, ModelSelection>
- >({});
const [expandedProvider, setExpandedProvider] = useState<string | null>(null);
const reset = useCallback(() => {
setSelectedEnvironmentId(null);
setSelectedProjectKey(null);
- setSelectedModelKey(null);
- setWorkspaceMode("local");
- setSelectedBranchName(null);
- setSelectedWorktreePath(null);
setSubmitting(false);
setBranchQuery("");
- setRuntimeMode(DEFAULT_RUNTIME_MODE);
- setInteractionMode(DEFAULT_PROVIDER_INTERACTION_MODE);
- setModelSelectionOverrides({});
setExpandedProvider(null);
}, []);
@@ -247,33 +229,33 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {
const selectedProjectDraft = useComposerDraft(selectedProjectDraftKey);
const prompt = selectedProjectDraft.text;
const attachments = selectedProjectDraft.attachments;
+ const workspaceMode = selectedProjectDraft.workspaceSelection?.mode ?? "local";
+ const selectedBranchName = selectedProjectDraft.workspaceSelection?.branch ?? null;
+ const selectedWorktreePath = selectedProjectDraft.workspaceSelection?.worktreePath ?? null;
+ const runtimeMode = selectedProjectDraft.runtimeMode ?? DEFAULT_RUNTIME_MODE;
+ const interactionMode = selectedProjectDraft.interactionMode ?? DEFAULT_PROVIDER_INTERACTION_MODE;
const modelOptions = useMemo(
() =>
buildModelOptions(
selectedEnvironmentServerConfig,
- selectedProject?.defaultModelSelection ?? null,
+ selectedProjectDraft.modelSelection ?? selectedProject?.defaultModelSelection ?? null,
),
- [selectedEnvironmentServerConfig, selectedProject?.defaultModelSelection],
+ [
+ selectedEnvironmentServerConfig,
+ selectedProject?.defaultModelSelection,
+ selectedProjectDraft.modelSelection,
+ ],
);
- const defaultModelKey = selectedProject?.defaultModelSelection
- ? `${selectedProject.defaultModelSelection.instanceId}:${selectedProject.defaultModelSelection.model}`
- : null;
- const baseSelectedModel =
- modelOptions.find((option) => option.key === selectedModelKey)?.selection ??
- (defaultModelKey
- ? modelOptions.find((option) => option.key === defaultModelKey)?.selection
- : null) ??
+ const selectedModel =
+ selectedProjectDraft.modelSelection ??
selectedProject?.defaultModelSelection ??
modelOptions[0]?.selection ??
null;
- const selectedModelIdentity = baseSelectedModel
- ? `${baseSelectedModel.instanceId}:${baseSelectedModel.model}`
+ const selectedModelKey = selectedModel
+ ? `${selectedModel.instanceId}:${selectedModel.model}`
: null;
- const selectedModel =
- (selectedModelIdentity ? modelSelectionOverrides[selectedModelIdentity] : null) ??
- baseSelectedModel;
const selectedModelOption =
modelOptions.find(
@@ -282,13 +264,31 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {
option.selection.instanceId === selectedModel.instanceId &&
option.selection.model === selectedModel.model,
) ?? null;
- const selectedProviderSkills =
- selectedEnvironmentServerConfig?.providers.find(
- (provider) => provider.instanceId === selectedModel?.instanceId,
- )?.skills ?? [];
+ const selectedProviderSkills = useMemo(
+ () =>
+ selectedEnvironmentServerConfig?.providers.find(
+ (provider) => provider.instanceId === selectedModel?.instanceId,
+ )?.skills ?? [],
+ [selectedEnvironmentServerConfig, selectedModel?.instanceId],
+ );
+ const setSelectedModelKey = useCallback(
+ (key: string | null) => {
+ if (!key || !selectedProjectDraftKey) {
+ return;
+ }
+ const option = modelOptions.find((candidate) => candidate.key === key);
+ if (!option) {
+ return;
+ }
+ updateComposerDraftSettings(selectedProjectDraftKey, {
+ modelSelection: option.selection,
+ });
+ },
+ [modelOptions, selectedProjectDraftKey],
+ );
const setSelectedModelOptions = useCallback(
(options: ReadonlyArray<ProviderOptionSelection> | undefined) => {
- if (!selectedModel || !selectedModelIdentity) {
+ if (!selectedModel || !selectedProjectDraftKey) {
return;
}
const nextSelection: ModelSelection = options
@@ -297,12 +297,11 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {
instanceId: selectedModel.instanceId,
model: selectedModel.model,
};
- setModelSelectionOverrides((current) => ({
- ...current,
- [selectedModelIdentity]: nextSelection,
- }));
+ updateComposerDraftSettings(selectedProjectDraftKey, {
+ modelSelection: nextSelection,
+ });
},
- [selectedModel, selectedModelIdentity],
+ [selectedModel, selectedProjectDraftKey],
);
const providerGroups = useMemo(() => groupByProvider(modelOptions), [modelOptions]);
@@ -381,62 +380,85 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {
const setProject = useCallback((project: EnvironmentProject) => {
const nextProjectKey = scopedProjectKey(project.environmentId, project.id);
- branchLoadVersionRef.current += 1;
setSelectedEnvironmentId(project.environmentId);
setSelectedProjectKey(nextProjectKey);
- setSelectedBranchName(null);
- setSelectedWorktreePath(null);
- setModelSelectionOverrides({});
}, []);
const selectEnvironment = useCallback((environmentId: EnvironmentId) => {
- branchLoadVersionRef.current += 1;
setSelectedEnvironmentId(environmentId);
setSelectedProjectKey(null);
- setSelectedBranchName(null);
- setSelectedWorktreePath(null);
- setModelSelectionOverrides({});
}, []);
+ const setWorkspaceMode = useCallback(
+ (mode: WorkspaceMode) => {
+ if (!selectedProjectDraftKey) {
+ return;
+ }
+ updateComposerDraftSettings(selectedProjectDraftKey, {
+ workspaceSelection: {
+ mode,
+ branch: selectedBranchName,
+ worktreePath: selectedWorktreePath,
+ },
+ });
+ },
+ [selectedBranchName, selectedProjectDraftKey, selectedWorktreePath],
+ );
+
const selectBranch = useCallback(
(branch: VcsRef) => {
- setSelectedBranchName(branch.name);
- setSelectedWorktreePath(
- selectedProject ? normalizeSelectedWorktreePath(selectedProject, branch) : null,
- );
+ if (!selectedProject || !selectedProjectDraftKey) {
+ return;
+ }
+ updateComposerDraftSettings(selectedProjectDraftKey, {
+ workspaceSelection: {
+ mode: workspaceMode,
+ branch: branch.name,
+ worktreePath: normalizeSelectedWorktreePath(selectedProject, branch),
+ },
+ });
},
- [selectedProject],
+ [selectedProject, selectedProjectDraftKey, workspaceMode],
);
+ const refreshBranches = branchState.refresh;
const loadBranches = useCallback(async () => {
if (!selectedProject) {
return;
}
+ setPendingConnectionError(null);
+ refreshBranches();
+ }, [refreshBranches, selectedProject]);
- const loadVersion = ++branchLoadVersionRef.current;
- const projectKey = scopedProjectKey(selectedProject.environmentId, selectedProject.id);
- branchState.refresh();
- if (loadVersion !== branchLoadVersionRef.current || selectedProjectKey !== projectKey) {
+ useEffect(() => {
+ if (workspaceMode !== "worktree" || selectedBranchName !== null) {
return;
}
- setPendingConnectionError(null);
- if (workspaceMode === "worktree" && !selectedBranchName) {
- const preferredBranch =
- availableBranches.find((branch) => branch.current)?.name ??
- availableBranches.find((branch) => branch.isDefault)?.name ??
- null;
- if (preferredBranch) {
- setSelectedBranchName(preferredBranch);
- }
+ const preferredBranch =
+ availableBranches.find((branch) => branch.current) ??
+ availableBranches.find((branch) => branch.isDefault) ??
+ null;
+ if (preferredBranch) {
+ selectBranch(preferredBranch);
}
- }, [
- availableBranches,
- branchState,
- selectedBranchName,
- selectedProject,
- selectedProjectKey,
- workspaceMode,
- ]);
+ }, [availableBranches, selectBranch, selectedBranchName, workspaceMode]);
+
+ const setRuntimeMode = useCallback(
+ (value: RuntimeMode) => {
+ if (selectedProjectDraftKey) {
+ updateComposerDraftSettings(selectedProjectDraftKey, { runtimeMode: value });
+ }
+ },
+ [selectedProjectDraftKey],
+ );
+ const setInteractionMode = useCallback(
+ (value: ProviderInteractionMode) => {
+ if (selectedProjectDraftKey) {
+ updateComposerDraftSettings(selectedProjectDraftKey, { interactionMode: value });
+ }
+ },
+ [selectedProjectDraftKey],
+ );
const value = useMemo<NewTaskFlowContextValue>(
() => ({
@@ -513,6 +535,11 @@ export function NewTaskFlowProvider(props: React.PropsWithChildren) {
setProject,
selectBranch,
selectEnvironment,
+ setInteractionMode,
+ setPrompt,
+ setRuntimeMode,
+ setSelectedModelKey,
+ setWorkspaceMode,
submitting,
workspaceMode,
appendAttachments,
diff --git a/apps/mobile/src/lib/composer-image-schema.ts b/apps/mobile/src/lib/composer-image-schema.ts
new file mode 100644
index 000000000..a121b70dd
--- /dev/null
+++ b/apps/mobile/src/lib/composer-image-schema.ts
@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+
+export const DraftComposerImageAttachmentSchema = Schema.Struct({
+ id: Schema.String,
+ previewUri: Schema.String,
+ type: Schema.Literal("image"),
+ name: Schema.String,
+ mimeType: Schema.String,
+ sizeBytes: Schema.Number,
+ dataUrl: Schema.String,
+});
diff --git a/apps/mobile/src/state/thread-outbox-model.ts b/apps/mobile/src/state/thread-outbox-model.ts
index aa7a10551..ed0c06ba3 100644
--- a/apps/mobile/src/state/thread-outbox-model.ts
+++ b/apps/mobile/src/state/thread-outbox-model.ts
@@ -1,32 +1,38 @@
import { isTransportConnectionErrorMessage } from "@t3tools/client-runtime/errors";
import type { EnvironmentShellStatus } from "@t3tools/client-runtime/state/shell";
-import { CommandId, EnvironmentId, IsoDateTime, MessageId, ThreadId } from "@t3tools/contracts";
+import {
+ CommandId,
+ EnvironmentId,
+ IsoDateTime,
+ MessageId,
+ ModelSelection,
+ ProviderInteractionMode,
+ RuntimeMode,
+ ThreadId,
+ type ModelSelection as ModelSelectionType,
+ type ProviderInteractionMode as ProviderInteractionModeType,
+ type RuntimeMode as RuntimeModeType,
+} from "@t3tools/contracts";
import * as Schema from "effect/Schema";
+import { DraftComposerImageAttachmentSchema } from "../lib/composer-image-schema";
import type { DraftComposerImageAttachment } from "../lib/composerImages";
import { scopedThreadKey } from "../lib/scopedEntities";
-const THREAD_OUTBOX_SCHEMA_VERSION = 1;
+const THREAD_OUTBOX_SCHEMA_VERSION = 2;
const THREAD_OUTBOX_MAX_RETRY_DELAY_MS = 16_000;
-const DraftComposerImageAttachmentSchema = Schema.Struct({
- id: Schema.String,
- previewUri: Schema.String,
- type: Schema.Literal("image"),
- name: Schema.String,
- mimeType: Schema.String,
- sizeBytes: Schema.Number,
- dataUrl: Schema.String,
-});
-
export const QueuedThreadMessageSchema = Schema.Struct({
- schemaVersion: Schema.Literal(THREAD_OUTBOX_SCHEMA_VERSION),
+ schemaVersion: Schema.Literals([1, THREAD_OUTBOX_SCHEMA_VERSION]),
environmentId: EnvironmentId,
threadId: ThreadId,
messageId: MessageId,
commandId: CommandId,
text: Schema.String,
attachments: Schema.Array(DraftComposerImageAttachmentSchema),
+ modelSelection: Schema.optional(ModelSelection),
+ runtimeMode: Schema.optional(RuntimeMode),
+ interactionMode: Schema.optional(ProviderInteractionMode),
createdAt: IsoDateTime,
});
@@ -40,9 +46,37 @@ export interface QueuedThreadMessage {
readonly commandId: CommandId;
readonly text: string;
readonly attachments: ReadonlyArray<DraftComposerImageAttachment>;
+ readonly modelSelection?: ModelSelectionType;
+ readonly runtimeMode?: RuntimeModeType;
+ readonly interactionMode?: ProviderInteractionModeType;
readonly createdAt: string;
}
+export interface ThreadSettingsSnapshot {
+ readonly modelSelection: ModelSelectionType;
+ readonly runtimeMode: RuntimeModeType;
+ readonly interactionMode: ProviderInteractionModeType;
+}
+
+export function resolveQueuedThreadSettings(
+ message: QueuedThreadMessage,
+ thread: ThreadSettingsSnapshot,
+): ThreadSettingsSnapshot {
+ return {
+ modelSelection: message.modelSelection ?? thread.modelSelection,
+ runtimeMode: message.runtimeMode ?? thread.runtimeMode,
+ interactionMode: message.interactionMode ?? thread.interactionMode,
+ };
+}
+
+export function modelSelectionsEqual(left: ModelSelectionType, right: ModelSelectionType): boolean {
+ return (
+ left.instanceId === right.instanceId &&
+ left.model === right.model &&
+ JSON.stringify(left.options ?? null) === JSON.stringify(right.options ?? null)
+ );
+}
+
export function encodeQueuedThreadMessage(message: QueuedThreadMessage): unknown {
return encodeStoredQueuedThreadMessage({
schemaVersion: THREAD_OUTBOX_SCHEMA_VERSION,
@@ -119,3 +153,21 @@ export function shouldRetryThreadOutboxDelivery(error: unknown): boolean {
}
return isTransportConnectionErrorMessage(errorMessage(error));
}
+
+export type ThreadOutboxCommandStage = "settings-sync" | "start-turn";
+export type ThreadOutboxFailureAction = "retry" | "discard";
+
+export function resolveThreadOutboxFailureAction(input: {
+ readonly stage: ThreadOutboxCommandStage;
+ readonly error: unknown;
+ readonly interrupted: boolean;
+}): ThreadOutboxFailureAction {
+ if (
+ input.stage === "settings-sync" ||
+ input.interrupted ||
+ shouldRetryThreadOutboxDelivery(input.error)
+ ) {
+ return "retry";
+ }
+ return "discard";
+}
diff --git a/apps/mobile/src/state/thread-outbox.test.ts b/apps/mobile/src/state/thread-outbox.test.ts
index d6b91c1c4..68d06d2e4 100644
--- a/apps/mobile/src/state/thread-outbox.test.ts
+++ b/apps/mobile/src/state/thread-outbox.test.ts
@@ -1,11 +1,21 @@
import { describe, expect, it } from "@effect/vitest";
-import { CommandId, EnvironmentId, MessageId, ThreadId } from "@t3tools/contracts";
+import {
+ CommandId,
+ EnvironmentId,
+ MessageId,
+ ProviderInstanceId,
+ ThreadId,
+} from "@t3tools/contracts";
import { AtomRegistry } from "effect/unstable/reactivity";
import {
decodeQueuedThreadMessage,
+ encodeQueuedThreadMessage,
groupQueuedThreadMessages,
+ modelSelectionsEqual,
resolveThreadOutboxDeliveryAction,
+ resolveThreadOutboxFailureAction,
+ resolveQueuedThreadSettings,
shouldRetryThreadOutboxDelivery,
threadOutboxRetryDelayMs,
type QueuedThreadMessage,
@@ -66,6 +76,54 @@ describe("thread outbox", () => {
).toThrow();
});
+ it("persists the exact selector snapshot while remaining compatible with v1 messages", () => {
+ const legacyMessage = queuedMessage({
+ messageId: "message-1",
+ createdAt: "2026-06-08T10:00:01.000Z",
+ });
+ const selectedMessage = {
+ ...legacyMessage,
+ modelSelection: {
+ instanceId: ProviderInstanceId.make("codex"),
+ model: "gpt-5.4",
+ options: [{ id: "reasoningEffort", value: "xhigh" }],
+ },
+ runtimeMode: "approval-required",
+ interactionMode: "plan",
+ } satisfies QueuedThreadMessage;
+
+ expect(decodeQueuedThreadMessage(encodeQueuedThreadMessage(selectedMessage))).toEqual(
+ selectedMessage,
+ );
+ expect(
+ resolveQueuedThreadSettings(legacyMessage, {
+ modelSelection: selectedMessage.modelSelection,
+ runtimeMode: selectedMessage.runtimeMode,
+ interactionMode: selectedMessage.interactionMode,
+ }),
+ ).toEqual({
+ modelSelection: selectedMessage.modelSelection,
+ runtimeMode: selectedMessage.runtimeMode,
+ interactionMode: selectedMessage.interactionMode,
+ });
+ });
+
+ it("compares model options as part of the queued settings change", () => {
+ const base = {
+ instanceId: ProviderInstanceId.make("codex"),
+ model: "gpt-5.4",
+ options: [{ id: "reasoningEffort", value: "medium" }],
+ } as const;
+
+ expect(modelSelectionsEqual(base, base)).toBe(true);
+ expect(
+ modelSelectionsEqual(base, {
+ ...base,
+ options: [{ id: "reasoningEffort", value: "xhigh" }],
+ }),
+ ).toBe(false);
+ });
+
it("backs off queued delivery retries and caps them at sixteen seconds", () => {
expect([1, 2, 3, 4, 5, 6].map(threadOutboxRetryDelayMs)).toEqual([
1_000, 2_000, 4_000, 8_000, 16_000, 16_000,
@@ -271,4 +329,23 @@ describe("thread outbox", () => {
).toBe(true);
expect(shouldRetryThreadOutboxDelivery(new Error("Thread no longer exists"))).toBe(false);
});
+
+ it("retains queued messages when settings synchronization fails before startTurn", () => {
+ const deterministicFailure = new Error("Thread no longer exists");
+
+ expect(
+ resolveThreadOutboxFailureAction({
+ stage: "settings-sync",
+ error: deterministicFailure,
+ interrupted: false,
+ }),
+ ).toBe("retry");
+ expect(
+ resolveThreadOutboxFailureAction({
+ stage: "start-turn",
+ error: deterministicFailure,
+ interrupted: false,
+ }),
+ ).toBe("discard");
+ });
});
diff --git a/apps/mobile/src/state/use-composer-drafts.test.ts b/apps/mobile/src/state/use-composer-drafts.test.ts
index 48e4e8703..d02abb6a2 100644
--- a/apps/mobile/src/state/use-composer-drafts.test.ts
+++ b/apps/mobile/src/state/use-composer-drafts.test.ts
@@ -1,14 +1,136 @@
-import { describe, expect, it } from "@effect/vitest";
-import { EnvironmentId } from "@t3tools/contracts";
+import { afterEach, describe, expect, it } from "@effect/vitest";
+import { EnvironmentId, ProviderInstanceId } from "@t3tools/contracts";
-import { type ComposerDraft, removeComposerDraftsForEnvironment } from "./use-composer-drafts";
+import { appAtomRegistry } from "./atom-registry";
+import {
+ clearComposerDraftContentState,
+ composerDraftsAtom,
+ decodePersistedComposerDrafts,
+ type ComposerDraft,
+ getComposerDraftSnapshot,
+ removeComposerDraftsForEnvironment,
+} from "./use-composer-drafts";
const DRAFT: ComposerDraft = {
text: "hello",
attachments: [],
};
+afterEach(() => {
+ appAtomRegistry.set(composerDraftsAtom, {});
+});
+
describe("mobile composer drafts", () => {
+ it("hydrates selector state even when the message content is empty", () => {
+ expect(
+ decodePersistedComposerDrafts({
+ schemaVersion: 1,
+ drafts: {
+ "new-task:environment-1:project-1": {
+ text: "",
+ attachments: [],
+ modelSelection: {
+ instanceId: "codex",
+ model: "gpt-5.4",
+ options: [{ id: "reasoningEffort", value: "xhigh" }],
+ },
+ runtimeMode: "approval-required",
+ interactionMode: "plan",
+ workspaceSelection: {
+ mode: "worktree",
+ branch: "main",
+ worktreePath: null,
+ },
+ },
+ },
+ }),
+ ).toEqual({
+ "new-task:environment-1:project-1": {
+ text: "",
+ attachments: [],
+ modelSelection: {
+ instanceId: "codex",
+ model: "gpt-5.4",
+ options: [{ id: "reasoningEffort", value: "xhigh" }],
+ },
+ runtimeMode: "approval-required",
+ interactionMode: "plan",
+ workspaceSelection: {
+ mode: "worktree",
+ branch: "main",
+ worktreePath: null,
+ },
+ },
+ });
+ });
+
+ it("keeps legacy content-only drafts and rejects invalid selector state", () => {
+ expect(
+ decodePersistedComposerDrafts({
+ schemaVersion: 1,
+ drafts: {
+ "environment-1:thread-1": DRAFT,
+ },
+ }),
+ ).toEqual({
+ "environment-1:thread-1": DRAFT,
+ });
+
+ expect(() =>
+ decodePersistedComposerDrafts({
+ schemaVersion: 1,
+ drafts: {
+ "environment-1:thread-1": {
+ ...DRAFT,
+ runtimeMode: "sometimes-safe",
+ },
+ },
+ }),
+ ).toThrow();
+ });
+
+ it("clears sent content without clearing the selected model or workspace", () => {
+ const draftKey = "environment-1:thread-1";
+ const draft: ComposerDraft = {
+ text: "send this",
+ attachments: [],
+ modelSelection: {
+ instanceId: ProviderInstanceId.make("codex"),
+ model: "gpt-5.4",
+ options: [{ id: "reasoningEffort", value: "xhigh" }],
+ },
+ workspaceSelection: {
+ mode: "worktree",
+ branch: "main",
+ worktreePath: null,
+ },
+ };
+
+ expect(clearComposerDraftContentState({ [draftKey]: draft }, draftKey)).toEqual({
+ [draftKey]: {
+ ...draft,
+ text: "",
+ attachments: [],
+ },
+ });
+ });
+
+ it("reads the latest selector state synchronously for send", () => {
+ const draftKey = "environment-1:thread-1";
+ const selectedDraft: ComposerDraft = {
+ text: "send this",
+ attachments: [],
+ modelSelection: {
+ instanceId: ProviderInstanceId.make("codex"),
+ model: "gpt-5.4",
+ options: [{ id: "reasoningEffort", value: "xhigh" }],
+ },
+ };
+ appAtomRegistry.set(composerDraftsAtom, { [draftKey]: selectedDraft });
+
+ expect(getComposerDraftSnapshot(draftKey)).toEqual(selectedDraft);
+ });
+
it("removes only drafts owned by the selected environment", () => {
const environmentId = EnvironmentId.make("environment-cloud");
const retainedEnvironmentId = EnvironmentId.make("environment-local");
@@ -17,12 +139,15 @@ describe("mobile composer drafts", () => {
removeComposerDraftsForEnvironment(
{
[`${environmentId}:thread-cloud`]: DRAFT,
+ [`new-task:${environmentId}:project-cloud`]: DRAFT,
[`${retainedEnvironmentId}:thread-local`]: DRAFT,
+ [`new-task:${retainedEnvironmentId}:project-local`]: DRAFT,
},
environmentId,
),
).toEqual({
[`${retainedEnvironmentId}:thread-local`]: DRAFT,
+ [`new-task:${retainedEnvironmentId}:project-local`]: DRAFT,
});
});
});
diff --git a/apps/mobile/src/state/use-composer-drafts.ts b/apps/mobile/src/state/use-composer-drafts.ts
index d0329ad25..9e2c15661 100644
--- a/apps/mobile/src/state/use-composer-drafts.ts
+++ b/apps/mobile/src/state/use-composer-drafts.ts
@@ -1,9 +1,18 @@
import { useAtomValue } from "@effect/atom-react";
-import type { EnvironmentId } from "@t3tools/contracts";
+import {
+ ModelSelection as ModelSelectionSchema,
+ ProviderInteractionMode as ProviderInteractionModeSchema,
+ RuntimeMode as RuntimeModeSchema,
+ type EnvironmentId,
+ type ModelSelection,
+ type ProviderInteractionMode,
+ type RuntimeMode,
+} from "@t3tools/contracts";
import * as Schema from "effect/Schema";
import { useEffect } from "react";
import { Atom } from "effect/unstable/reactivity";
+import { DraftComposerImageAttachmentSchema } from "../lib/composer-image-schema";
import type { DraftComposerImageAttachment } from "../lib/composerImages";
import { appAtomRegistry } from "./atom-registry";
@@ -29,13 +38,47 @@ export class ComposerDraftPersistenceError extends Schema.TaggedErrorClass<Compo
export interface ComposerDraft {
readonly text: string;
readonly attachments: ReadonlyArray<DraftComposerImageAttachment>;
+ readonly modelSelection?: ModelSelection;
+ readonly runtimeMode?: RuntimeMode;
+ readonly interactionMode?: ProviderInteractionMode;
+ readonly workspaceSelection?: ComposerDraftWorkspaceSelection;
}
-interface PersistedComposerDrafts {
- readonly schemaVersion: typeof COMPOSER_DRAFTS_SCHEMA_VERSION;
- readonly drafts: Record<string, ComposerDraft>;
+export interface ComposerDraftWorkspaceSelection {
+ readonly mode: "local" | "worktree";
+ readonly branch: string | null;
+ readonly worktreePath: string | null;
}
+export type ComposerDraftSettingsUpdate = Pick<
+ ComposerDraft,
+ "modelSelection" | "runtimeMode" | "interactionMode" | "workspaceSelection"
+>;
+
+const ComposerDraftWorkspaceSelectionSchema = Schema.Struct({
+ mode: Schema.Literals(["local", "worktree"]),
+ branch: Schema.NullOr(Schema.String),
+ worktreePath: Schema.NullOr(Schema.String),
+});
+
+const ComposerDraftSchema = Schema.Struct({
+ text: Schema.String,
+ attachments: Schema.Array(DraftComposerImageAttachmentSchema),
+ modelSelection: Schema.optional(ModelSelectionSchema),
+ runtimeMode: Schema.optional(RuntimeModeSchema),
+ interactionMode: Schema.optional(ProviderInteractionModeSchema),
+ workspaceSelection: Schema.optional(ComposerDraftWorkspaceSelectionSchema),
+});
+
+const PersistedComposerDraftsSchema = Schema.Struct({
+ schemaVersion: Schema.Literal(COMPOSER_DRAFTS_SCHEMA_VERSION),
+ drafts: Schema.Record(Schema.String, ComposerDraftSchema),
+});
+
+const decodePersistedComposerDraftsDocument = Schema.decodeUnknownSync(
+ PersistedComposerDraftsSchema,
+);
+
const EMPTY_DRAFT: ComposerDraft = {
text: "",
attachments: [],
@@ -54,13 +97,32 @@ function normalizeDraft(draft: ComposerDraft | undefined): ComposerDraft {
return EMPTY_DRAFT;
}
return {
+ ...draft,
text: draft.text,
attachments: draft.attachments,
};
}
+export function getComposerDraftSnapshot(draftKey: string): ComposerDraft {
+ return normalizeDraft(appAtomRegistry.get(composerDraftsAtom)[draftKey]);
+}
+
function isEmptyDraft(draft: ComposerDraft): boolean {
- return draft.text.length === 0 && draft.attachments.length === 0;
+ return (
+ draft.text.length === 0 &&
+ draft.attachments.length === 0 &&
+ draft.modelSelection === undefined &&
+ draft.runtimeMode === undefined &&
+ draft.interactionMode === undefined &&
+ draft.workspaceSelection === undefined
+ );
+}
+
+export function decodePersistedComposerDrafts(value: unknown): Record<string, ComposerDraft> {
+ const parsed = decodePersistedComposerDraftsDocument(value);
+ return Object.fromEntries(
+ Object.entries(parsed.drafts).filter(([, draft]) => !isEmptyDraft(draft)),
+ );
}
async function getComposerDraftsFile() {
@@ -80,20 +142,7 @@ async function loadPersistedComposerDrafts(): Promise<Record<string, ComposerDra
operation = "read";
const raw = await file.text();
operation = "decode";
- const parsed = JSON.parse(raw) as Partial<PersistedComposerDrafts>;
- if (parsed.schemaVersion !== COMPOSER_DRAFTS_SCHEMA_VERSION || !parsed.drafts) {
- return {};
- }
- return Object.fromEntries(
- Object.entries(parsed.drafts).filter((entry): entry is [string, ComposerDraft] => {
- const draft = entry[1];
- return (
- typeof draft?.text === "string" &&
- Array.isArray(draft.attachments) &&
- !isEmptyDraft(draft)
- );
- }),
- );
+ return decodePersistedComposerDrafts(JSON.parse(raw) as unknown);
} catch (cause) {
console.warn(
"[composer-drafts] ignored persisted draft failure",
@@ -116,10 +165,10 @@ async function writePersistedComposerDrafts(drafts: Record<string, ComposerDraft
const nonEmptyDrafts = Object.fromEntries(
Object.entries(drafts).filter(([, draft]) => !isEmptyDraft(draft)),
);
- const document: PersistedComposerDrafts = {
+ const document = {
schemaVersion: COMPOSER_DRAFTS_SCHEMA_VERSION,
drafts: nonEmptyDrafts,
- };
+ } as const;
const encoded = JSON.stringify(document);
operation = "write";
if (!file.exists) {
@@ -282,6 +331,55 @@ export function removeComposerDraftAttachment(draftKey: string, imageId: string)
});
}
+export function updateComposerDraftSettings(
+ draftKey: string,
+ settings: Partial<ComposerDraftSettingsUpdate>,
+): void {
+ updateComposerDrafts((current) => {
+ const draft = {
+ ...normalizeDraft(current[draftKey]),
+ ...settings,
+ };
+ if (isEmptyDraft(draft)) {
+ const next = { ...current };
+ delete next[draftKey];
+ return next;
+ }
+ return {
+ ...current,
+ [draftKey]: draft,
+ };
+ });
+}
+
+export function clearComposerDraftContentState(
+ current: Record<string, ComposerDraft>,
+ draftKey: string,
+): Record<string, ComposerDraft> {
+ const existing = current[draftKey];
+ if (!existing) {
+ return current;
+ }
+ const draft = {
+ ...existing,
+ text: "",
+ attachments: [],
+ };
+ if (isEmptyDraft(draft)) {
+ const next = { ...current };
+ delete next[draftKey];
+ return next;
+ }
+ return {
+ ...current,
+ [draftKey]: draft,
+ };
+}
+
+export function clearComposerDraftContent(draftKey: string): void {
+ updateComposerDrafts((current) => clearComposerDraftContentState(current, draftKey));
+}
+
export function clearComposerDraft(draftKey: string): void {
updateComposerDrafts((current) => {
if (!current[draftKey]) {
@@ -298,8 +396,12 @@ export function removeComposerDraftsForEnvironment(
environmentId: EnvironmentId,
): Record<string, ComposerDraft> {
const environmentPrefix = `${environmentId}:`;
+ const newTaskPrefix = `new-task:${environmentId}:`;
return Object.fromEntries(
- Object.entries(drafts).filter(([draftKey]) => !draftKey.startsWith(environmentPrefix)),
+ Object.entries(drafts).filter(
+ ([draftKey]) =>
+ !draftKey.startsWith(environmentPrefix) && !draftKey.startsWith(newTaskPrefix),
+ ),
);
}
diff --git a/apps/mobile/src/state/use-thread-composer-state.ts b/apps/mobile/src/state/use-thread-composer-state.ts
index 60970b32a..0b8cba16e 100644
--- a/apps/mobile/src/state/use-thread-composer-state.ts
+++ b/apps/mobile/src/state/use-thread-composer-state.ts
@@ -1,7 +1,15 @@
import { useAtomValue } from "@effect/atom-react";
import { useCallback, useEffect, useMemo } from "react";
-import { CommandId, MessageId, type EnvironmentId, type ThreadId } from "@t3tools/contracts";
+import {
+ CommandId,
+ MessageId,
+ type EnvironmentId,
+ type ModelSelection,
+ type ProviderInteractionMode,
+ type RuntimeMode,
+ type ThreadId,
+} from "@t3tools/contracts";
import { safeErrorLogAttributes } from "@t3tools/client-runtime/errors";
import { deriveActiveWorkStartedAt } from "@t3tools/shared/orchestrationTiming";
@@ -18,11 +26,13 @@ import { appAtomRegistry } from "../state/atom-registry";
import {
appendComposerDraftAttachments,
appendComposerDraftText,
- clearComposerDraft,
+ clearComposerDraftContent,
composerDraftsAtom,
ensureComposerDraftsLoaded,
+ getComposerDraftSnapshot,
removeComposerDraftAttachment,
setComposerDraftText,
+ updateComposerDraftSettings,
useComposerDraft,
} from "./use-composer-drafts";
import { setPendingConnectionError } from "../state/use-remote-environment-registry";
@@ -98,6 +108,10 @@ export function useThreadComposerState() {
const draftMessage = selectedDraft?.text ?? "";
const draftAttachments = selectedDraft?.attachments ?? [];
const selectedThreadQueueCount = selectedThreadQueuedMessages.length;
+ const selectedThread = selectedThreadDetail ?? selectedThreadShell;
+ const modelSelection = selectedDraft?.modelSelection ?? selectedThread?.modelSelection ?? null;
+ const runtimeMode = selectedDraft?.runtimeMode ?? selectedThread?.runtimeMode ?? null;
+ const interactionMode = selectedDraft?.interactionMode ?? selectedThread?.interactionMode ?? null;
const selectedThreadSessionActivity = useMemo(() => {
const selectedThread = selectedThreadDetail ?? selectedThreadShell;
@@ -130,7 +144,6 @@ export function useThreadComposerState() {
selectedThreadShell,
]);
- const selectedThread = selectedThreadDetail ?? selectedThreadShell;
const activeThreadBusy =
!!selectedThread &&
(selectedThread.session?.status === "running" || selectedThread.session?.status === "starting");
@@ -141,9 +154,10 @@ export function useThreadComposerState() {
}
const threadKey = scopedThreadKey(selectedThreadShell.environmentId, selectedThreadShell.id);
- const draft = composerDrafts[threadKey];
- const text = (draft?.text ?? "").trim();
- const attachments = draft?.attachments ?? [];
+ const draft = getComposerDraftSnapshot(threadKey);
+ const thread = selectedThreadDetail ?? selectedThreadShell;
+ const text = draft.text.trim();
+ const attachments = draft.attachments;
if (text.length === 0 && attachments.length === 0) {
return;
}
@@ -157,15 +171,18 @@ export function useThreadComposerState() {
commandId: CommandId.make(metadata.commandId),
text,
attachments,
+ modelSelection: draft.modelSelection ?? thread.modelSelection,
+ runtimeMode: draft.runtimeMode ?? thread.runtimeMode,
+ interactionMode: draft.interactionMode ?? thread.interactionMode,
createdAt: metadata.createdAt,
});
- clearComposerDraft(threadKey);
+ clearComposerDraftContent(threadKey);
} catch (error) {
setPendingConnectionError(
error instanceof Error ? error.message : "Failed to save the queued message.",
);
}
- }, [composerDrafts, selectedThreadShell]);
+ }, [selectedThreadDetail, selectedThreadShell]);
const onChangeDraftMessage = useCallback(
(value: string) => {
@@ -255,12 +272,45 @@ export function useThreadComposerState() {
[selectedThreadShell],
);
+ const onUpdateModelSelection = useCallback(
+ (value: ModelSelection) => {
+ if (!selectedThreadKey) {
+ return;
+ }
+ updateComposerDraftSettings(selectedThreadKey, { modelSelection: value });
+ },
+ [selectedThreadKey],
+ );
+
+ const onUpdateRuntimeMode = useCallback(
+ (value: RuntimeMode) => {
+ if (!selectedThreadKey) {
+ return;
+ }
+ updateComposerDraftSettings(selectedThreadKey, { runtimeMode: value });
+ },
+ [selectedThreadKey],
+ );
+
+ const onUpdateInteractionMode = useCallback(
+ (value: ProviderInteractionMode) => {
+ if (!selectedThreadKey) {
+ return;
+ }
+ updateComposerDraftSettings(selectedThreadKey, { interactionMode: value });
+ },
+ [selectedThreadKey],
+ );
+
return {
selectedThreadFeed,
selectedThreadQueueCount,
activeWorkStartedAt,
draftMessage,
draftAttachments,
+ modelSelection,
+ runtimeMode,
+ interactionMode,
activeThreadBusy,
onChangeDraftMessage,
onPickDraftImages,
@@ -268,5 +318,8 @@ export function useThreadComposerState() {
onNativePasteImages,
onRemoveDraftImage,
onSendMessage,
+ onUpdateModelSelection,
+ onUpdateRuntimeMode,
+ onUpdateInteractionMode,
};
}
diff --git a/apps/mobile/src/state/use-thread-outbox-drain.ts b/apps/mobile/src/state/use-thread-outbox-drain.ts
index 840456e2d..e912d6366 100644
--- a/apps/mobile/src/state/use-thread-outbox-drain.ts
+++ b/apps/mobile/src/state/use-thread-outbox-drain.ts
@@ -1,6 +1,7 @@
import { useAtomValue } from "@effect/atom-react";
import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
-import { type MessageId } from "@t3tools/contracts";
+import type { AtomCommandResult } from "@t3tools/client-runtime/state/runtime";
+import { CommandId, type MessageId } from "@t3tools/contracts";
import * as Cause from "effect/Cause";
import { AsyncResult, Atom } from "effect/unstable/reactivity";
import { useCallback, useEffect, useRef, useState } from "react";
@@ -10,10 +11,13 @@ import { appAtomRegistry } from "./atom-registry";
import { useThreadShells } from "./entities";
import { ensureThreadOutboxLoaded, removeThreadOutboxMessage } from "./thread-outbox";
import {
+ modelSelectionsEqual,
resolveThreadOutboxDeliveryAction,
- shouldRetryThreadOutboxDelivery,
+ resolveThreadOutboxFailureAction,
+ resolveQueuedThreadSettings,
threadOutboxRetryDelayMs,
type QueuedThreadMessage,
+ type ThreadOutboxCommandStage,
} from "./thread-outbox-model";
import { threadEnvironment } from "./threads";
import { useAtomCommand } from "./use-atom-command";
@@ -44,8 +48,21 @@ function findThread(
);
}
+function settingsCommandId(message: QueuedThreadMessage, setting: string): CommandId {
+ return CommandId.make(`${message.commandId}:${setting}`);
+}
+
export function useThreadOutboxDrain(): void {
const startTurn = useAtomCommand(threadEnvironment.startTurn, { reportFailure: false });
+ const updateThreadMetadata = useAtomCommand(threadEnvironment.updateMetadata, {
+ reportFailure: false,
+ });
+ const setThreadRuntimeMode = useAtomCommand(threadEnvironment.setRuntimeMode, {
+ reportFailure: false,
+ });
+ const setThreadInteractionMode = useAtomCommand(threadEnvironment.setInteractionMode, {
+ reportFailure: false,
+ });
const dispatchingQueuedMessageId = useAtomValue(dispatchingQueuedMessageIdAtom);
const queuedMessagesByThreadKey = useThreadOutboxMessages();
const shellStatuses = useThreadOutboxShellStatuses();
@@ -68,6 +85,98 @@ export function useThreadOutboxDrain(): void {
const sendQueuedMessage = useCallback(
async (queuedMessage: QueuedThreadMessage, thread: EnvironmentThreadShell) => {
+ const settings = resolveQueuedThreadSettings(queuedMessage, thread);
+ const reportFailure = (
+ commandResult: AtomCommandResult<unknown, unknown>,
+ stage: ThreadOutboxCommandStage,
+ ): boolean => {
+ if (!AsyncResult.isFailure(commandResult)) {
+ return false;
+ }
+ const action = resolveThreadOutboxFailureAction({
+ stage,
+ error: Cause.squash(commandResult.cause),
+ interrupted: Cause.hasInterruptsOnly(commandResult.cause),
+ });
+ const retry = action === "retry";
+ console.warn("[thread-outbox] queued message delivery failed", {
+ environmentId: queuedMessage.environmentId,
+ threadId: queuedMessage.threadId,
+ messageId: queuedMessage.messageId,
+ stage,
+ cause: commandResult.cause,
+ retry,
+ });
+ return retry;
+ };
+ const completeDelivery = async (
+ deliveryResult: AtomCommandResult<unknown, unknown>,
+ ): Promise<boolean> => {
+ if (reportFailure(deliveryResult, "start-turn")) {
+ return false;
+ }
+
+ try {
+ await removeThreadOutboxMessage(queuedMessage);
+ return true;
+ } catch (error) {
+ console.warn("[thread-outbox] failed to remove delivered queued message", {
+ environmentId: queuedMessage.environmentId,
+ threadId: queuedMessage.threadId,
+ messageId: queuedMessage.messageId,
+ error,
+ });
+ return false;
+ }
+ };
+
+ if (!modelSelectionsEqual(settings.modelSelection, thread.modelSelection)) {
+ const updateResult = await updateThreadMetadata({
+ environmentId: queuedMessage.environmentId,
+ input: {
+ commandId: settingsCommandId(queuedMessage, "model-selection"),
+ threadId: queuedMessage.threadId,
+ modelSelection: settings.modelSelection,
+ },
+ });
+ if (AsyncResult.isFailure(updateResult)) {
+ reportFailure(updateResult, "settings-sync");
+ return false;
+ }
+ }
+
+ if (settings.runtimeMode !== thread.runtimeMode) {
+ const runtimeResult = await setThreadRuntimeMode({
+ environmentId: queuedMessage.environmentId,
+ input: {
+ commandId: settingsCommandId(queuedMessage, "runtime-mode"),
+ threadId: queuedMessage.threadId,
+ runtimeMode: settings.runtimeMode,
+ createdAt: queuedMessage.createdAt,
+ },
+ });
+ if (AsyncResult.isFailure(runtimeResult)) {
+ reportFailure(runtimeResult, "settings-sync");
+ return false;
+ }
+ }
+
+ if (settings.interactionMode !== thread.interactionMode) {
+ const interactionResult = await setThreadInteractionMode({
+ environmentId: queuedMessage.environmentId,
+ input: {
+ commandId: settingsCommandId(queuedMessage, "interaction-mode"),
+ threadId: queuedMessage.threadId,
+ interactionMode: settings.interactionMode,
+ createdAt: queuedMessage.createdAt,
+ },
+ });
+ if (AsyncResult.isFailure(interactionResult)) {
+ reportFailure(interactionResult, "settings-sync");
+ return false;
+ }
+ }
+
const deliveryResult = await startTurn({
environmentId: queuedMessage.environmentId,
input: {
@@ -79,41 +188,15 @@ export function useThreadOutboxDrain(): void {
text: queuedMessage.text,
attachments: queuedMessage.attachments,
},
- runtimeMode: thread.runtimeMode,
- interactionMode: thread.interactionMode,
+ modelSelection: settings.modelSelection,
+ runtimeMode: settings.runtimeMode,
+ interactionMode: settings.interactionMode,
createdAt: queuedMessage.createdAt,
},
});
- if (AsyncResult.isFailure(deliveryResult)) {
- const error = Cause.squash(deliveryResult.cause);
- const retry =
- Cause.hasInterruptsOnly(deliveryResult.cause) || shouldRetryThreadOutboxDelivery(error);
- console.warn("[thread-outbox] queued message delivery failed", {
- environmentId: queuedMessage.environmentId,
- threadId: queuedMessage.threadId,
- messageId: queuedMessage.messageId,
- cause: deliveryResult.cause,
- retry,
- });
- if (retry) {
- return false;
- }
- }
-
- try {
- await removeThreadOutboxMessage(queuedMessage);
- return true;
- } catch (error) {
- console.warn("[thread-outbox] failed to remove delivered queued message", {
- environmentId: queuedMessage.environmentId,
- threadId: queuedMessage.threadId,
- messageId: queuedMessage.messageId,
- error,
- });
- return false;
- }
+ return completeDelivery(deliveryResult);
},
- [startTurn],
+ [setThreadInteractionMode, setThreadRuntimeMode, startTurn, updateThreadMetadata],
);
useEffect(() => {