@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 326 lines 11.7 KB
Raw
1 import { isTransportConnectionErrorMessage } from "@t3tools/client-runtime/errors";
2 import { msg } from "gt-react-native";
3 import { m } from "../i18n/messages";
4 import {
5 clampFileAttachmentUploadBytes,
6 fileAttachmentTooLargeMessage,
7 } from "@t3tools/client-runtime/state/attachments";
8 import type { EnvironmentShellStatus } from "@t3tools/client-runtime/state/shell";
9 import type { ThreadFamilyRead } from "@t3tools/client-runtime/state/threads";
10 import {
11 CommandId,
12 DEFAULT_PROVIDER_INTERACTION_MODE,
13 EnvironmentId,
14 IsoDateTime,
15 MessageId,
16 ModelSelection,
17 OrchestrationMessageContext,
18 ProjectId,
19 ProviderInteractionMode,
20 RuntimeMode,
21 ThreadId,
22 type ModelSelection as ModelSelectionType,
23 type ProjectId as ProjectIdType,
24 type ProviderInteractionMode as ProviderInteractionModeType,
25 type RuntimeMode as RuntimeModeType,
26 type ServerProvider,
27 type ServerProviderModel,
28 } from "@t3tools/contracts";
29 import * as Schema from "effect/Schema";
30
31 import { DraftComposerAttachmentSchema } from "../lib/composer-image-schema";
32 import { withImplicitFastModeSelection } from "../lib/providerOptions";
33 import type { ComposerDispatchMode } from "@t3tools/client-runtime/state/composer-dispatch";
34 import type { DraftComposerAttachment } from "../lib/composerImages";
35 import { scopedThreadKey } from "../lib/scopedEntities";
36
37 // Keep current writes until a compatible native baseline includes the v4 reader.
38 const THREAD_OUTBOX_SCHEMA_VERSION = 3;
39 const THREAD_OUTBOX_MAX_RETRY_DELAY_MS = 16_000;
40
41 const QueuedThreadCreationSchema = Schema.Struct({
42 projectId: ProjectId,
43 projectTitle: Schema.optional(Schema.String),
44 projectCwd: Schema.optional(Schema.String),
45 workspaceMode: Schema.Literals(["local", "worktree"]),
46 branch: Schema.NullOr(Schema.String),
47 worktreePath: Schema.NullOr(Schema.String),
48 startFromOrigin: Schema.optional(Schema.Boolean),
49 pullRequestReference: Schema.optional(Schema.String),
50 });
51
52 export const QueuedThreadMessageSchema = Schema.Struct({
53 schemaVersion: Schema.Literals([1, 2, THREAD_OUTBOX_SCHEMA_VERSION, 4]),
54 environmentId: EnvironmentId,
55 threadId: ThreadId,
56 messageId: MessageId,
57 commandId: CommandId,
58 text: Schema.String,
59 restoreToDraft: Schema.optional(Schema.Boolean),
60 context: Schema.optional(OrchestrationMessageContext),
61 attachments: Schema.Array(DraftComposerAttachmentSchema),
62 modelSelection: Schema.optional(ModelSelection),
63 dispatchMode: Schema.optional(Schema.Literals(["auto", "queue", "steer", "restart"])),
64 compactBeforeSend: Schema.optional(Schema.Boolean),
65 freshContext: Schema.optional(Schema.Boolean),
66 runtimeMode: Schema.optional(RuntimeMode),
67 interactionMode: Schema.optional(ProviderInteractionMode),
68 creation: Schema.optional(QueuedThreadCreationSchema),
69 createdAt: IsoDateTime,
70 });
71
72 const decodeStoredQueuedThreadMessage = Schema.decodeUnknownSync(QueuedThreadMessageSchema);
73 const encodeStoredQueuedThreadMessage = Schema.encodeUnknownSync(QueuedThreadMessageSchema);
74
75 export interface QueuedThreadCreation {
76 readonly projectId: ProjectIdType;
77 readonly projectTitle?: string;
78 readonly projectCwd?: string;
79 readonly workspaceMode: "local" | "worktree";
80 readonly branch: string | null;
81 readonly worktreePath: string | null;
82 readonly startFromOrigin?: boolean;
83 readonly pullRequestReference?: string;
84 }
85
86 export interface QueuedThreadMessage {
87 readonly environmentId: EnvironmentId;
88 readonly threadId: ThreadId;
89 readonly messageId: MessageId;
90 readonly commandId: CommandId;
91 readonly text: string;
92 readonly restoreToDraft?: boolean;
93 readonly context?: OrchestrationMessageContext;
94 readonly attachments: ReadonlyArray<DraftComposerAttachment>;
95 readonly modelSelection?: ModelSelectionType;
96 readonly runtimeMode?: RuntimeModeType;
97 readonly interactionMode?: ProviderInteractionModeType;
98 /** Captured at enqueue because draining may occur long after the tap. */
99 readonly dispatchMode?: ComposerDispatchMode;
100 /** Sends "When you return"'s `/compact` ahead of the message, which queues behind it. */
101 readonly compactBeforeSend?: boolean;
102 /** Starts a new provider session (`/clear`). */
103 readonly freshContext?: boolean;
104 readonly creation?: QueuedThreadCreation;
105 readonly createdAt: string;
106 }
107
108 export interface ThreadSettingsSnapshot {
109 readonly modelSelection: ModelSelectionType;
110 readonly runtimeMode: RuntimeModeType;
111 readonly interactionMode: ProviderInteractionModeType;
112 }
113
114 // Providers without a Build/Plan toggle always run in build mode.
115 function resolveProviderInteractionMode(
116 provider: Pick<ServerProvider, "showInteractionModeToggle"> | undefined,
117 interactionMode: ProviderInteractionModeType,
118 ): ProviderInteractionModeType {
119 return provider?.showInteractionModeToggle === false
120 ? DEFAULT_PROVIDER_INTERACTION_MODE
121 : interactionMode;
122 }
123
124 export function resolveQueuedThreadSettings(
125 message: QueuedThreadMessage,
126 thread: ThreadSettingsSnapshot,
127 providers: ReadonlyArray<
128 Pick<ServerProvider, "instanceId" | "showInteractionModeToggle"> & {
129 readonly models: ReadonlyArray<Pick<ServerProviderModel, "slug" | "capabilities">>;
130 }
131 > = [],
132 ): ThreadSettingsSnapshot {
133 const modelSelection = withImplicitFastModeSelection(
134 message.modelSelection ?? thread.modelSelection,
135 providers,
136 );
137 const provider = providers.find(
138 (candidate) => candidate.instanceId === modelSelection.instanceId,
139 );
140 return {
141 modelSelection,
142 runtimeMode: message.runtimeMode ?? thread.runtimeMode,
143 interactionMode: resolveProviderInteractionMode(
144 provider,
145 message.interactionMode ?? thread.interactionMode,
146 ),
147 };
148 }
149
150 export function modelSelectionsEqual(left: ModelSelectionType, right: ModelSelectionType): boolean {
151 return (
152 left.instanceId === right.instanceId &&
153 left.model === right.model &&
154 JSON.stringify(left.options ?? null) === JSON.stringify(right.options ?? null)
155 );
156 }
157
158 export function encodeQueuedThreadMessage(message: QueuedThreadMessage): unknown {
159 return encodeStoredQueuedThreadMessage({
160 schemaVersion: THREAD_OUTBOX_SCHEMA_VERSION,
161 ...message,
162 });
163 }
164
165 export function decodeQueuedThreadMessage(value: unknown): QueuedThreadMessage {
166 const { schemaVersion: _, ...message } = decodeStoredQueuedThreadMessage(value);
167 return message;
168 }
169
170 export function groupQueuedThreadMessages(
171 messages: ReadonlyArray<QueuedThreadMessage>,
172 ): Record<string, ReadonlyArray<QueuedThreadMessage>> {
173 const deduplicated = new Map<MessageId, QueuedThreadMessage>();
174 for (const message of messages) {
175 deduplicated.set(message.messageId, message);
176 }
177
178 const grouped: Record<string, Array<QueuedThreadMessage>> = {};
179 for (const message of deduplicated.values()) {
180 const threadKey = scopedThreadKey(message.environmentId, message.threadId);
181 (grouped[threadKey] ??= []).push(message);
182 }
183 for (const queue of Object.values(grouped)) {
184 queue.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
185 }
186 return grouped;
187 }
188
189 export function flattenQueuedThreadMessages(
190 queues: Record<string, ReadonlyArray<QueuedThreadMessage>>,
191 ): ReadonlyArray<QueuedThreadMessage> {
192 return Object.values(queues).flat();
193 }
194
195 export function threadOutboxRetryDelayMs(attempt: number): number {
196 return Math.min(1_000 * 2 ** Math.max(0, attempt - 1), THREAD_OUTBOX_MAX_RETRY_DELAY_MS);
197 }
198
199 export type ThreadOutboxDeliveryAction = "wait" | "remove" | "send";
200
201 export function resolveThreadOutboxDeliveryAction(input: {
202 readonly isCreation: boolean;
203 readonly threadExists: boolean;
204 readonly shellStatus: EnvironmentShellStatus;
205 readonly environmentConnected: boolean;
206 /**
207 * Set when the shell can leave idle subagent children out: absence alone is not deletion there,
208 * only a settled family read without the row is.
209 */
210 readonly familyRead?: ThreadFamilyRead;
211 }): ThreadOutboxDeliveryAction {
212 if (input.isCreation) {
213 if (input.threadExists) {
214 return "remove";
215 }
216 // Wait for live shells; an unsynchronized list can hide delivered creations and cause duplicate re-issuance.
217 return input.environmentConnected && input.shellStatus === "live" ? "send" : "wait";
218 }
219 if (!input.threadExists) {
220 return input.shellStatus === "live" &&
221 (input.familyRead === undefined || input.familyRead === "settled")
222 ? "remove"
223 : "wait";
224 }
225 return input.environmentConnected ? "send" : "wait";
226 }
227
228 export type ThreadOutboxDispatchStep =
229 | { readonly step: "wait" }
230 | { readonly step: "remove" }
231 | { readonly step: "retry" }
232 | { readonly step: "restore"; readonly reason: string }
233 | { readonly step: "send" };
234
235 export function resolveThreadOutboxDispatchStep(input: {
236 readonly deliveryAction: ThreadOutboxDeliveryAction;
237 readonly fileAttachments: ReadonlyArray<{ readonly name: string; readonly sizeBytes: number }>;
238 readonly serverConfig: { readonly maxFileUploadBytes: number | undefined } | null;
239 }): ThreadOutboxDispatchStep {
240 if (input.deliveryAction !== "send") {
241 return { step: input.deliveryAction };
242 }
243 if (input.serverConfig === null) {
244 return { step: "retry" };
245 }
246 if (input.fileAttachments.length === 0) {
247 return { step: "send" };
248 }
249 const maxBytes = input.serverConfig.maxFileUploadBytes;
250 if (maxBytes === undefined) {
251 return { step: "restore", reason: m(msg("This server does not support file attachments.")) };
252 }
253 const effectiveMaxBytes = clampFileAttachmentUploadBytes(maxBytes);
254 const oversized = input.fileAttachments.find(
255 (attachment) => attachment.sizeBytes > effectiveMaxBytes,
256 );
257 return oversized
258 ? { step: "restore", reason: fileAttachmentTooLargeMessage(oversized.name, effectiveMaxBytes) }
259 : { step: "send" };
260 }
261
262 export function isQueuedThreadCreationSendable(message: QueuedThreadMessage): boolean {
263 if (!message.creation) {
264 return false;
265 }
266 const hasContent = message.text.trim().length > 0 || message.attachments.length > 0;
267 if (!hasContent || message.modelSelection === undefined) {
268 return false;
269 }
270 return message.creation.workspaceMode !== "worktree" || Boolean(message.creation.branch);
271 }
272
273 function errorMessage(error: unknown): string | null {
274 if (error instanceof Error) {
275 return error.message;
276 }
277 if (typeof error === "object" && error !== null && "message" in error) {
278 return typeof error.message === "string" ? error.message : null;
279 }
280 return typeof error === "string" ? error : null;
281 }
282
283 /** Dispatch/auth rejections invalidate payloads; other typed failures may be disconnected transports and must retry. */
284 export function shouldRetryThreadOutboxDelivery(error: unknown): boolean {
285 if (typeof error === "object" && error !== null && "_tag" in error) {
286 switch (error._tag) {
287 case "OrchestrationDispatchCommandError":
288 case "EnvironmentAuthorizationError":
289 return false;
290 case "ConnectionTransientError":
291 case "RpcClientError":
292 case "EnvironmentRpcUnavailableError":
293 case "EnvironmentNotRegisteredError":
294 return true;
295 // A shared upload's failure decides by what made the upload fail.
296 case "AttachmentUploadError":
297 return "cause" in error && shouldRetryThreadOutboxDelivery(error.cause);
298 default:
299 break;
300 }
301 }
302 return isTransportConnectionErrorMessage(errorMessage(error));
303 }
304
305 export type ThreadOutboxCommandStage = "settings-sync" | "start-turn";
306 export type ThreadOutboxFailureAction = "retry" | "restore";
307
308 export function resolveThreadOutboxFailureAction(input: {
309 readonly stage: ThreadOutboxCommandStage;
310 readonly error: unknown;
311 readonly interrupted: boolean;
312 }): ThreadOutboxFailureAction {
313 if (
314 input.stage === "settings-sync" ||
315 input.interrupted ||
316 shouldRetryThreadOutboxDelivery(input.error)
317 ) {
318 return "retry";
319 }
320 return "restore";
321 }
322
323 export type AcknowledgedThreadMessage = QueuedThreadMessage & {
324 /** The server sequence that committed the message; older servers do not report it. */
325 readonly sequence?: number;
326 };