import { stripInlineContextReferences } from "./lib/composerContextReferences";
import { composerFileAttachmentMimeType } from "./components/chat/composerAttachmentFiles";
import { elementContextToPreviewAnnotation } from "./lib/elementContext";
import {
ElementContextDetails,
DEFAULT_MODEL,
DEFAULT_MODEL_BY_PROVIDER,
defaultInstanceIdForDriver,
EnvironmentId,
ModelSelection,
ProjectId,
ProviderInstanceId,
ProviderInteractionMode,
ProviderDriverKind,
ProviderOptionSelection,
PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
ProviderOptionSelections,
PreviewAnnotationPayloadSchema,
PastedTextAttachmentSource,
type PreviewAnnotationPayload,
RuntimeMode,
ThreadContextRecord,
EnvironmentContextRecord,
type ServerProvider,
type ScopedProjectRef,
type ScopedThreadRef,
ThreadId,
SnapShotSource,
} from "@t3tools/contracts";
import {
parseScopedProjectKey,
parseScopedThreadKey,
scopedProjectKey,
scopeProjectRef,
scopedThreadKey,
scopeThreadRef,
} from "@t3tools/client-runtime/environment";
import * as Schema from "effect/Schema";
import * as Equal from "effect/Equal";
import * as Effect from "effect/Effect";
import { DeepMutable } from "effect/Types";
import {
createModelSelection,
draftModelPickMatchesThread,
normalizeCustomModelSlug,
normalizeModelSlug,
} from "@t3tools/shared/model";
import { AsyncResult, Atom, type AtomRegistry } from "effect/reactivity";
import * as Option from "effect/Option";
import type {
EnvironmentShellState,
EnvironmentThreadShell,
} from "@t3tools/client-runtime/state/shell";
import { waitForDraftHeroTransition } from "./components/chat/draftHeroTransition";
import { getLocalStorageItem } from "./hooks/useLocalStorage";
import { readThreadPreviewState } from "./previewStateStore";
import {
readInstanceCustomModels,
resolveAppModelSelection,
resolveAppModelSelectionForInstance,
} from "./modelSelection";
import {
DEFAULT_INTERACTION_MODE,
DEFAULT_RUNTIME_MODE,
type ChatFileAttachment,
type ChatImageAttachment,
videoMimeType,
} from "./types";
import {
type TerminalContextDraft,
migrateLegacyTerminalContextPlaceholders,
normalizeTerminalContextText,
} from "./lib/terminalContext";
import {
appendInlineContextReference,
type ComposerContextReference,
ensureInlineContextReferences,
formatInlineContextReference,
removeInlineContextReference,
} from "./lib/composerContextReferences";
import {
fileContextReference,
previewAnnotationContextId,
previewAnnotationContextReference,
reviewCommentContextId,
reviewCommentContextReference,
terminalContextReference,
threadContextReference,
environmentContextReference,
} from "./lib/composerContextRecords";
import { create } from "zustand";
import { persist, type PersistStorage, type StorageValue } from "zustand/middleware";
import { useShallow } from "zustand/react/shallow";
import { createDeferredStorage, createMemoryStorage } from "./lib/storage";
import { getDefaultServerModel } from "./providerModels";
import {
replaceComposerContextReferences,
toComposerContextId,
toKindScopedComposerContextId,
} from "@t3tools/shared/composerContextReferences";
import { UnifiedSettings } from "@t3tools/contracts/settings";
const isElementContextDetails = Schema.is(ElementContextDetails);
import { ReviewCommentContextSchema, type ReviewCommentContext } from "./reviewCommentContext";
const isRuntimeMode = Schema.is(RuntimeMode);
const isProviderDriverKind = Schema.is(ProviderDriverKind);
const isReviewCommentContext = Schema.is(ReviewCommentContextSchema);
const isThreadContextRecord = Schema.is(ThreadContextRecord);
const isEnvironmentContextRecord = Schema.is(EnvironmentContextRecord);
const isSnapShotSource = Schema.is(SnapShotSource);
const isPreviewAnnotationPayload = Schema.is(PreviewAnnotationPayloadSchema);
export const COMPOSER_DRAFT_STORAGE_KEY = "t3code:composer-drafts:v1";
const COMPOSER_DRAFT_STORAGE_VERSION = 9;
const DraftThreadEnvModeSchema = Schema.Literals(["local", "worktree"]);
export type DraftThreadEnvMode = typeof DraftThreadEnvModeSchema.Type;
export const DraftId = Schema.String.pipe(Schema.brand("DraftId"));
export type DraftId = typeof DraftId.Type;
const COMPOSER_PERSIST_DEBOUNCE_MS = 300;
type ComposerPersistState =
| { capturedState: ComposerDraftStoreState }
| PersistedComposerDraftStoreState;
const composerDebouncedStorage = createDeferredStorage<StorageValue<ComposerPersistState>>(
typeof localStorage !== "undefined" ? localStorage : createMemoryStorage(),
(value) =>
JSON.stringify({
state:
"capturedState" in value.state
? partializeComposerDraftStoreState(value.state.capturedState)
: value.state,
version: value.version,
}),
COMPOSER_PERSIST_DEBOUNCE_MS,
);
const composerPersistStorage: PersistStorage<ComposerPersistState> = {
getItem: (name) => {
const raw = composerDebouncedStorage.getItem(name);
if (typeof raw !== "string") {
return null;
}
return JSON.parse(raw) as StorageValue<ComposerPersistState>;
},
setItem: (name, value) => composerDebouncedStorage.setItem(name, value),
removeItem: (name) => composerDebouncedStorage.removeItem(name),
};
if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
window.addEventListener("beforeunload", () => {
composerDebouncedStorage.flush();
});
}
export const PersistedComposerImageAttachment = Schema.Struct({
id: Schema.String,
name: Schema.String,
mimeType: Schema.String,
sizeBytes: Schema.Number,
source: Schema.optional(SnapShotSource),
dataUrl: Schema.String,
});
export type PersistedComposerImageAttachment = typeof PersistedComposerImageAttachment.Type;
export interface ComposerImageAttachment extends Omit<ChatImageAttachment, "previewUrl"> {
previewUrl: string;
file: File;
}
export interface ComposerFileAttachment extends Omit<ChatFileAttachment, "previewUrl"> {
file: File | null;
uploadedAttachmentId?: string;
uploadEnvironmentId?: EnvironmentId;
}
export function composerFileNeedsReattach(file: ComposerFileAttachment): boolean {
return file.file === null && file.uploadedAttachmentId === undefined;
}
function clearStaleFileUploadMetadata(
draft: ComposerThreadDraftState,
environmentId: EnvironmentId,
): ComposerThreadDraftState {
let changed = false;
const files = draft.files.map((file) => {
if (
(file.uploadedAttachmentId === undefined && file.uploadEnvironmentId === undefined) ||
file.uploadEnvironmentId === environmentId
) {
return file;
}
changed = true;
const nextFile = { ...file };
delete nextFile.uploadedAttachmentId;
delete nextFile.uploadEnvironmentId;
return nextFile;
});
return changed ? { ...draft, files } : draft;
}
export const PersistedComposerFileAttachment = Schema.Struct({
id: Schema.String,
name: Schema.String,
mimeType: Schema.String,
sizeBytes: Schema.Number,
attachmentId: Schema.String,
environmentId: EnvironmentId,
source: Schema.optional(PastedTextAttachmentSource),
});
export type PersistedComposerFileAttachment = typeof PersistedComposerFileAttachment.Type;
/** File handles cannot serialize; metadata-only markers hydrate as needs-reattach rows. */
export const PersistedComposerDraftFileAttachment = Schema.Struct({
id: Schema.String,
name: Schema.String,
mimeType: Schema.String,
sizeBytes: Schema.Number,
attachmentId: Schema.optionalKey(Schema.String),
environmentId: Schema.optionalKey(EnvironmentId),
source: Schema.optional(PastedTextAttachmentSource),
});
export type PersistedComposerDraftFileAttachment = typeof PersistedComposerDraftFileAttachment.Type;
const isPersistedComposerDraftFileAttachment = Schema.is(PersistedComposerDraftFileAttachment);
const PersistedTerminalContextDraft = Schema.Struct({
id: Schema.String,
threadId: ThreadId,
createdAt: Schema.String,
terminalId: Schema.String,
terminalLabel: Schema.String,
lineStart: Schema.Number,
lineEnd: Schema.Number,
text: Schema.optionalKey(Schema.String),
});
type PersistedTerminalContextDraft = typeof PersistedTerminalContextDraft.Type;
const PersistedComposerThreadDraftState = Schema.Struct({
prompt: Schema.String,
attachments: Schema.Array(PersistedComposerImageAttachment),
files: Schema.optionalKey(Schema.Array(PersistedComposerDraftFileAttachment)),
terminalContexts: Schema.optionalKey(Schema.Array(PersistedTerminalContextDraft)),
previewAnnotations: Schema.optionalKey(Schema.Array(PreviewAnnotationPayloadSchema)),
reviewComments: Schema.optionalKey(Schema.Array(ReviewCommentContextSchema)),
threadContexts: Schema.optionalKey(Schema.Array(ThreadContextRecord)),
environmentContexts: Schema.optionalKey(Schema.Array(EnvironmentContextRecord)),
modelSelectionByProvider: Schema.optionalKey(Schema.Record(ProviderInstanceId, ModelSelection)),
activeProvider: Schema.optionalKey(Schema.NullOr(ProviderInstanceId)),
modelSelectionExplicit: Schema.optionalKey(Schema.Boolean),
runtimeMode: Schema.optionalKey(RuntimeMode),
interactionMode: Schema.optionalKey(ProviderInteractionMode),
});
type PersistedComposerThreadDraftState = typeof PersistedComposerThreadDraftState.Type;
type ProviderOptionSelectionsByProvider = Partial<
Record<string, ReadonlyArray<ProviderOptionSelection>>
>;
type LegacyCodexFields = {
effort?: unknown;
codexFastMode?: unknown;
serviceTier?: unknown;
};
type LegacyThreadModelFields = {
provider?: unknown;
model?: unknown;
modelOptions?: unknown;
};
type LegacyV2ThreadDraftFields = {
modelSelection?: ModelSelection | null;
modelOptions?: unknown;
};
type LegacyPersistedComposerThreadDraftState = PersistedComposerThreadDraftState &
LegacyCodexFields &
LegacyThreadModelFields &
LegacyV2ThreadDraftFields;
type LegacyStickyModelFields = {
stickyProvider?: unknown;
stickyModel?: unknown;
stickyModelOptions?: unknown;
};
type LegacyV2StoreFields = {
stickyModelSelection?: ModelSelection | null;
stickyModelOptions?: unknown;
projectDraftThreadIdByProjectId?: Record<string, string> | null;
draftsByThreadId?: Record<string, PersistedComposerThreadDraftState> | null;
draftThreadsByThreadId?: Record<string, PersistedDraftThreadState> | null;
projectDraftThreadIdByProjectKey?: Record<string, string> | null;
draftsByThreadKey?: Record<string, PersistedComposerThreadDraftState> | null;
draftThreadsByThreadKey?: Record<string, PersistedDraftThreadState> | null;
projectDraftThreadKeyByProjectKey?: Record<string, string> | null;
logicalProjectDraftThreadKeyByLogicalProjectKey?: Record<string, string> | null;
};
type LegacyPersistedComposerDraftStoreState = PersistedComposerDraftStoreState &
LegacyStickyModelFields &
LegacyV2StoreFields;
const PersistedDraftThreadState = Schema.Struct({
threadId: ThreadId,
environmentId: Schema.String,
projectId: ProjectId,
logicalProjectKey: Schema.optionalKey(Schema.String),
environmentSelection: Schema.optionalKey(Schema.Literals(["auto", "manual"])),
loadBalancedEnvironmentId: Schema.optionalKey(Schema.NullOr(Schema.String)),
createdAt: Schema.String,
runtimeMode: RuntimeMode,
interactionMode: ProviderInteractionMode,
branch: Schema.NullOr(Schema.String),
worktreePath: Schema.NullOr(Schema.String),
envMode: DraftThreadEnvModeSchema,
startFromOrigin: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),
promotedTo: Schema.optionalKey(
Schema.NullOr(
Schema.Struct({
environmentId: Schema.String,
threadId: Schema.String,
}),
),
),
});
type PersistedDraftThreadState = typeof PersistedDraftThreadState.Type;
const PersistedComposerDraftStoreState = Schema.Struct({
draftsByThreadKey: Schema.Record(Schema.String, PersistedComposerThreadDraftState),
draftThreadsByThreadKey: Schema.Record(Schema.String, PersistedDraftThreadState),
logicalProjectDraftThreadKeyByLogicalProjectKey: Schema.Record(Schema.String, Schema.String),
stickyModelSelectionByProvider: Schema.optionalKey(
Schema.Record(ProviderInstanceId, ModelSelection),
),
stickyOptionsByModelByProvider: Schema.optionalKey(
Schema.Record(ProviderInstanceId, Schema.Record(Schema.String, ProviderOptionSelections)),
),
stickyActiveProvider: Schema.optionalKey(Schema.NullOr(ProviderInstanceId)),
});
type PersistedComposerDraftStoreState = typeof PersistedComposerDraftStoreState.Type;
const PersistedComposerDraftStoreStorage = Schema.Struct({
version: Schema.Number,
state: PersistedComposerDraftStoreState,
});
export interface ComposerContextAddOptions {
appendReference?: boolean;
allowDuplicateReference?: boolean;
/** `false` to append synchronously instead of asking a mounted editor for its current caret. */
insertAtCaret?: boolean;
}
export type ComposerContextInsertionHandler = (
references: ReadonlyArray<ComposerContextReference>,
) => boolean;
const contextInsertionHandlers = new Map<string, ComposerContextInsertionHandler>();
export interface ComposerThreadDraftState {
prompt: string;
images: ComposerImageAttachment[];
files: ComposerFileAttachment[];
nonPersistedImageIds: string[];
persistedAttachments: PersistedComposerImageAttachment[];
terminalContexts: TerminalContextDraft[];
previewAnnotations: PreviewAnnotationPayload[];
reviewComments: ReviewCommentContext[];
threadContexts: ThreadContextRecord[];
environmentContexts: EnvironmentContextRecord[];
modelSelectionByProvider: Partial<Record<ProviderInstanceId, ModelSelection>>;
activeProvider: ProviderInstanceId | null;
modelSelectionExplicit?: boolean;
runtimeMode: RuntimeMode | null;
interactionMode: ProviderInteractionMode | null;
}
export function composerDraftHasUserContent(
draft: ComposerThreadDraftState | null | undefined,
): boolean {
if (!draft) {
return false;
}
return (
draft.prompt.trim().length > 0 ||
draft.images.length > 0 ||
draft.files.length > 0 ||
draft.persistedAttachments.length > 0 ||
draft.terminalContexts.length > 0 ||
draft.previewAnnotations.length > 0 ||
draft.reviewComments.length > 0 ||
draft.threadContexts.length > 0 ||
draft.environmentContexts.length > 0
);
}
export interface DraftSessionState {
threadId: ThreadId;
environmentId: EnvironmentId;
projectId: ProjectId;
logicalProjectKey: string;
environmentSelection?: "auto" | "manual";
loadBalancedEnvironmentId?: EnvironmentId | null;
createdAt: string;
runtimeMode: RuntimeMode;
interactionMode: ProviderInteractionMode;
branch: string | null;
worktreePath: string | null;
envMode: DraftThreadEnvMode;
startFromOrigin: boolean;
promotedTo?: ScopedThreadRef | null;
}
export type DraftThreadState = DraftSessionState;
interface ProjectDraftSession extends DraftSessionState {
draftId: DraftId;
}
export type ComposerThreadTarget = ScopedThreadRef | DraftId;
interface ComposerDraftStoreState {
draftsByThreadKey: Record<string, ComposerThreadDraftState>;
draftThreadsByThreadKey: Record<string, DraftThreadState>;
logicalProjectDraftThreadKeyByLogicalProjectKey: Record<string, string>;
backgroundSubmissionThreadKeys: Record<string, true>;
/**
* Where each finalized draft went, so `/draft/<id>` keeps leading to its thread (Back, an
* "Open draft" toast) after the draft is gone. In memory only, one small entry per sent draft.
*/
promotedDraftRedirects: Record<string, ScopedThreadRef>;
rewindingThreadKeys: ReadonlySet<string>;
stickyModelSelectionByProvider: Partial<Record<ProviderInstanceId, ModelSelection>>;
stickyOptionsByModelByProvider: Partial<
Record<ProviderInstanceId, Partial<Record<string, ReadonlyArray<ProviderOptionSelection>>>>
>;
stickyActiveProvider: ProviderInstanceId | null;
getComposerDraft: (target: ComposerThreadTarget) => ComposerThreadDraftState | null;
getDraftSessionByLogicalProjectKey: (logicalProjectKey: string) => ProjectDraftSession | null;
getDraftThreadByProjectRef: (projectRef: ScopedProjectRef) => ProjectDraftSession | null;
getDraftSessionByProjectRef: (projectRef: ScopedProjectRef) => ProjectDraftSession | null;
getDraftSession: (draftId: DraftId) => DraftSessionState | null;
getDraftSessionByRef: (threadRef: ScopedThreadRef) => DraftSessionState | null;
getDraftIdByRef: (threadRef: ScopedThreadRef) => DraftId | null;
getPromotedDraftRedirect: (draftId: DraftId) => ScopedThreadRef | null;
getDraftThreadByRef: (threadRef: ScopedThreadRef) => DraftThreadState | null;
getDraftThread: (threadRef: ComposerThreadTarget) => DraftThreadState | null;
listDraftThreadKeys: () => string[];
hasDraftThreadsInEnvironment: (environmentId: EnvironmentId) => boolean;
setLogicalProjectDraftThreadId: (
logicalProjectKey: string,
projectRef: ScopedProjectRef,
draftId: DraftId,
options?: {
threadId?: ThreadId;
branch?: string | null;
worktreePath?: string | null;
createdAt?: string;
envMode?: DraftThreadEnvMode;
startFromOrigin?: boolean;
runtimeMode?: RuntimeMode;
interactionMode?: ProviderInteractionMode;
environmentSelection?: "auto" | "manual";
loadBalancedEnvironmentId?: EnvironmentId | null;
},
) => void;
setProjectDraftThreadId: (
projectRef: ScopedProjectRef,
draftId: DraftId,
options?: {
threadId?: ThreadId;
branch?: string | null;
worktreePath?: string | null;
createdAt?: string;
envMode?: DraftThreadEnvMode;
startFromOrigin?: boolean;
runtimeMode?: RuntimeMode;
interactionMode?: ProviderInteractionMode;
environmentSelection?: "auto" | "manual";
loadBalancedEnvironmentId?: EnvironmentId | null;
},
) => void;
setDraftThreadContext: (
threadRef: ComposerThreadTarget,
options: {
branch?: string | null;
worktreePath?: string | null;
projectRef?: ScopedProjectRef;
createdAt?: string;
envMode?: DraftThreadEnvMode;
startFromOrigin?: boolean;
runtimeMode?: RuntimeMode;
interactionMode?: ProviderInteractionMode;
environmentSelection?: "auto" | "manual";
loadBalancedEnvironmentId?: EnvironmentId | null;
},
) => void;
clearProjectDraftThreadId: (projectRef: ScopedProjectRef) => void;
clearProjectDraftThreadById: (
projectRef: ScopedProjectRef,
threadRef: ComposerThreadTarget,
) => void;
markDraftThreadPromoting: (threadRef: ComposerThreadTarget, promotedTo?: ScopedThreadRef) => void;
finalizePromotedDraftThread: (threadRef: ComposerThreadTarget) => void;
clearDraftThread: (threadRef: ComposerThreadTarget) => void;
setStickyModelSelection: (modelSelection: ModelSelection | null | undefined) => void;
setPrompt: (threadRef: ComposerThreadTarget, prompt: string) => void;
setTerminalContexts: (threadRef: ComposerThreadTarget, contexts: TerminalContextDraft[]) => void;
setModelSelection: (
threadRef: ComposerThreadTarget,
modelSelection: ModelSelection | null | undefined,
opts?: {
explicit?: boolean;
/** Replace existing options even when the incoming selection has none. */
replaceOptions?: boolean;
},
) => void;
applyStickyState: (threadRef: ComposerThreadTarget) => void;
setProviderModelOptions: (
threadRef: ComposerThreadTarget,
provider: ProviderDriverKind,
nextProviderOptions: ReadonlyArray<ProviderOptionSelection> | null | undefined,
options?: {
instanceId?: ProviderInstanceId | null | undefined;
model?: string | null | undefined;
persistSticky?: boolean;
},
) => void;
setRuntimeMode: (
threadRef: ComposerThreadTarget,
runtimeMode: RuntimeMode | null | undefined,
) => void;
setInteractionMode: (
threadRef: ComposerThreadTarget,
interactionMode: ProviderInteractionMode | null | undefined,
) => void;
addImage: (threadRef: ComposerThreadTarget, image: ComposerImageAttachment) => boolean;
addImages: (
threadRef: ComposerThreadTarget,
images: ComposerImageAttachment[],
options?: { allowDuplicates?: boolean },
) => string[];
removeImage: (threadRef: ComposerThreadTarget, imageId: string) => void;
/** Returns the ids of files appended; a re-pick that replaces a marker is not listed. */
addFiles: (
threadRef: ComposerThreadTarget,
files: ComposerFileAttachment[],
options?: { allowDuplicates?: boolean; appendReference?: boolean },
) => string[];
removeFile: (threadRef: ComposerThreadTarget, fileId: string) => void;
setFileUpload: (
threadRef: ComposerThreadTarget,
fileId: string,
environmentId: EnvironmentId,
attachmentId: string,
) => void;
markFileUploadMissing: (
threadRef: ComposerThreadTarget,
fileId: string,
environmentId: EnvironmentId,
attachmentId: string,
) => boolean;
insertTerminalContext: (
threadRef: ComposerThreadTarget,
prompt: string,
context: TerminalContextDraft,
index: number,
) => boolean;
addTerminalContexts: (
threadRef: ComposerThreadTarget,
contexts: TerminalContextDraft[],
options?: ComposerContextAddOptions,
) => void;
removeTerminalContext: (threadRef: ComposerThreadTarget, contextId: string) => void;
clearTerminalContexts: (threadRef: ComposerThreadTarget) => void;
addPreviewAnnotation: (
threadRef: ComposerThreadTarget,
annotation: PreviewAnnotationPayload,
options?: ComposerContextAddOptions,
) => void;
setPreviewAnnotations: (
threadRef: ComposerThreadTarget,
annotations: ReadonlyArray<PreviewAnnotationPayload>,
) => void;
removePreviewAnnotation: (threadRef: ComposerThreadTarget, annotationId: string) => void;
addReviewComment: (
threadRef: ComposerThreadTarget,
comment: ReviewCommentContext,
options?: ComposerContextAddOptions,
) => void;
setContextInsertionHandler: (
threadRef: ComposerThreadTarget,
handler: ComposerContextInsertionHandler | null,
) => (() => void) | undefined;
setReviewComments: (
threadRef: ComposerThreadTarget,
comments: ReadonlyArray<ReviewCommentContext>,
) => void;
removeReviewComment: (threadRef: ComposerThreadTarget, commentId: string) => void;
addThreadContexts: (
threadRef: ComposerThreadTarget,
records: ReadonlyArray<ThreadContextRecord>,
options?: ComposerContextAddOptions,
) => void;
setThreadContexts: (
threadRef: ComposerThreadTarget,
records: ReadonlyArray<ThreadContextRecord>,
) => void;
/** Mentions machines as context; already-mentioned machines are skipped. */
addEnvironmentContexts: (
threadRef: ComposerThreadTarget,
records: ReadonlyArray<EnvironmentContextRecord>,
options?: ComposerContextAddOptions,
) => void;
setEnvironmentContexts: (
threadRef: ComposerThreadTarget,
records: ReadonlyArray<EnvironmentContextRecord>,
) => void;
clearPersistedAttachments: (threadRef: ComposerThreadTarget) => void;
syncPersistedAttachments: (
threadRef: ComposerThreadTarget,
attachments: PersistedComposerImageAttachment[],
) => Promise<void>;
clearComposerContent: (threadRef: ComposerThreadTarget) => void;
/** Clears text and attachments, preserving terminal/element contexts, preview annotations, and review comments. */
clearComposerPromptAndImages: (threadRef: ComposerThreadTarget) => void;
/** Keeps attachments over destination limits, other environments' uploads, terminal/element contexts, annotations, and review comments in source. */
moveComposerPromptAndImages: (from: ComposerThreadTarget, to: ComposerThreadTarget) => void;
}
export interface EffectiveComposerModelState {
selectedModel: string;
modelOptions: ProviderOptionSelectionsByProvider | null;
}
interface ComposerDraftModelState {
activeProvider: ProviderInstanceId | null;
modelSelectionByProvider: Partial<Record<ProviderInstanceId, ModelSelection>>;
}
function selectionsByInstance(
modelSelection: ModelSelection | null | undefined,
): Partial<Record<string, ModelSelection>> | null {
return modelSelection ? { [modelSelection.instanceId]: modelSelection } : null;
}
function modelSelectionByProviderToOptions(
map: Partial<Record<string, ModelSelection>> | null | undefined,
): ProviderOptionSelectionsByProvider | null {
if (!map) return null;
const result: ProviderOptionSelectionsByProvider = {};
for (const [provider, selection] of Object.entries(map)) {
if (selection?.options && selection.options.length > 0) {
result[provider] = selection.options;
}
}
return Object.keys(result).length > 0 ? result : null;
}
function cloneModelSelection(selection: ModelSelection): DeepMutable<ModelSelection> {
return {
...selection,
...(selection.options ? { options: selection.options.map((option) => ({ ...option })) } : {}),
} as DeepMutable<ModelSelection>;
}
function compactModelSelectionByProvider(
selections: Partial<Record<ProviderInstanceId, ModelSelection>>,
): DeepMutable<Record<ProviderInstanceId, ModelSelection>> {
const entries: Array<[string, DeepMutable<ModelSelection>]> = [];
for (const [provider, selection] of Object.entries(selections)) {
if (selection !== undefined) {
entries.push([provider, cloneModelSelection(selection)]);
}
}
return Object.fromEntries(entries) as DeepMutable<Record<ProviderInstanceId, ModelSelection>>;
}
function compactStickyOptionsByModel(
optionsByModelByProvider: ComposerDraftStoreState["stickyOptionsByModelByProvider"],
): NonNullable<PersistedComposerDraftStoreState["stickyOptionsByModelByProvider"]> {
const result: Record<string, Record<string, ReadonlyArray<ProviderOptionSelection>>> = {};
for (const [instanceId, optionsByModel] of Object.entries(optionsByModelByProvider)) {
for (const [modelSlug, options] of Object.entries(optionsByModel ?? {})) {
if (options === undefined || options.length === 0) continue;
result[instanceId] ??= {};
result[instanceId][modelSlug] = options;
}
}
return result as NonNullable<PersistedComposerDraftStoreState["stickyOptionsByModelByProvider"]>;
}
function seedStickyOptionsByModel(
stickySelections: Partial<Record<ProviderInstanceId, ModelSelection>>,
): NonNullable<PersistedComposerDraftStoreState["stickyOptionsByModelByProvider"]> {
const result: Record<string, Record<string, ReadonlyArray<ProviderOptionSelection>>> = {};
for (const [instanceId, selection] of Object.entries(stickySelections)) {
if (
selection === undefined ||
selection.options === undefined ||
selection.options.length === 0
) {
continue;
}
result[instanceId] = { [selection.model]: selection.options };
}
return result as NonNullable<PersistedComposerDraftStoreState["stickyOptionsByModelByProvider"]>;
}
const EMPTY_PERSISTED_DRAFT_STORE_STATE = Object.freeze<PersistedComposerDraftStoreState>({
draftsByThreadKey: {},
draftThreadsByThreadKey: {},
logicalProjectDraftThreadKeyByLogicalProjectKey: {},
stickyModelSelectionByProvider: {},
stickyOptionsByModelByProvider: {},
stickyActiveProvider: null,
});
const EMPTY_IMAGES: ComposerImageAttachment[] = [];
const EMPTY_FILES: ComposerFileAttachment[] = [];
const EMPTY_IDS: string[] = [];
const EMPTY_PERSISTED_ATTACHMENTS: PersistedComposerImageAttachment[] = [];
const EMPTY_TERMINAL_CONTEXTS: TerminalContextDraft[] = [];
const EMPTY_PREVIEW_ANNOTATIONS: PreviewAnnotationPayload[] = [];
const EMPTY_REVIEW_COMMENTS: ReviewCommentContext[] = [];
const EMPTY_THREAD_CONTEXTS: ThreadContextRecord[] = [];
const EMPTY_ENVIRONMENT_CONTEXTS: EnvironmentContextRecord[] = [];
Object.freeze(EMPTY_IMAGES);
Object.freeze(EMPTY_FILES);
Object.freeze(EMPTY_IDS);
Object.freeze(EMPTY_PERSISTED_ATTACHMENTS);
Object.freeze(EMPTY_PREVIEW_ANNOTATIONS);
Object.freeze(EMPTY_REVIEW_COMMENTS);
Object.freeze(EMPTY_THREAD_CONTEXTS);
Object.freeze(EMPTY_ENVIRONMENT_CONTEXTS);
const EMPTY_MODEL_SELECTION_BY_PROVIDER: Partial<Record<ProviderDriverKind, ModelSelection>> =
Object.freeze({});
const EMPTY_COMPOSER_DRAFT_MODEL_STATE = Object.freeze<ComposerDraftModelState>({
activeProvider: null,
modelSelectionByProvider: EMPTY_MODEL_SELECTION_BY_PROVIDER,
});
const EMPTY_THREAD_DRAFT = Object.freeze<ComposerThreadDraftState>({
prompt: "",
images: EMPTY_IMAGES,
files: EMPTY_FILES,
nonPersistedImageIds: EMPTY_IDS,
persistedAttachments: EMPTY_PERSISTED_ATTACHMENTS,
terminalContexts: EMPTY_TERMINAL_CONTEXTS,
previewAnnotations: EMPTY_PREVIEW_ANNOTATIONS,
reviewComments: EMPTY_REVIEW_COMMENTS,
threadContexts: EMPTY_THREAD_CONTEXTS,
environmentContexts: EMPTY_ENVIRONMENT_CONTEXTS,
modelSelectionByProvider: EMPTY_MODEL_SELECTION_BY_PROVIDER,
activeProvider: null,
runtimeMode: null,
interactionMode: null,
});
function createEmptyThreadDraft(): ComposerThreadDraftState {
return {
prompt: "",
images: [],
files: [],
nonPersistedImageIds: [],
persistedAttachments: [],
terminalContexts: [],
previewAnnotations: [],
reviewComments: [],
threadContexts: [],
environmentContexts: [],
modelSelectionByProvider: {},
activeProvider: null,
runtimeMode: null,
interactionMode: null,
};
}
function composerImageDedupKey(image: ComposerImageAttachment): string {
// Hydrated images get fresh lastModified values, so exclude it from dedupe.
return `${image.mimeType}\u0000${image.sizeBytes}\u0000${image.name}`;
}
export function composerFileDedupKey(
file: Pick<ComposerFileAttachment, "mimeType" | "sizeBytes" | "name">,
): string {
return `${file.mimeType}\u0000${file.sizeBytes}\u0000${file.name}`;
}
export function composerFileMatchesReattachMarker(
marker: Pick<ComposerFileAttachment, "mimeType" | "sizeBytes" | "name">,
file: Pick<ComposerFileAttachment, "mimeType" | "sizeBytes" | "name">,
): boolean {
if (marker.name !== file.name || marker.sizeBytes !== file.sizeBytes) return false;
if (marker.mimeType === file.mimeType) return true;
const normalizedMarkerMimeType = composerFileAttachmentMimeType({
name: marker.name,
type: marker.mimeType,
});
if (
normalizedMarkerMimeType === "image/x-adobe-dng" &&
normalizedMarkerMimeType ===
composerFileAttachmentMimeType({ name: file.name, type: file.mimeType })
) {
return true;
}
const markerMimeType = marker.mimeType.toLowerCase();
return (
(markerMimeType === "" || markerMimeType === "application/octet-stream") &&
videoMimeType(marker) !== null &&
videoMimeType(file) !== null
);
}
function terminalContextDedupKey(context: TerminalContextDraft): string {
return `${context.terminalId}\u0000${context.lineStart}\u0000${context.lineEnd}`;
}
function normalizeTerminalContextForThread(
threadId: ThreadId,
context: TerminalContextDraft,
): TerminalContextDraft | null {
const terminalId = context.terminalId.trim();
const terminalLabel = context.terminalLabel.trim();
if (terminalId.length === 0 || terminalLabel.length === 0) {
return null;
}
const lineStart = Math.max(1, Math.floor(context.lineStart));
const lineEnd = Math.max(lineStart, Math.floor(context.lineEnd));
return {
...context,
id: toComposerContextId(context.id),
threadId,
terminalId,
terminalLabel,
lineStart,
lineEnd,
text: normalizeTerminalContextText(context.text),
};
}
function normalizeTerminalContextsForThread(
threadId: ThreadId,
contexts: ReadonlyArray<TerminalContextDraft>,
): TerminalContextDraft[] {
const existingIds = new Set<string>();
const existingDedupKeys = new Set<string>();
const normalizedContexts: TerminalContextDraft[] = [];
for (const context of contexts) {
const normalizedContext = normalizeTerminalContextForThread(threadId, context);
if (!normalizedContext) {
continue;
}
const dedupKey = terminalContextDedupKey(normalizedContext);
if (existingIds.has(normalizedContext.id) || existingDedupKeys.has(dedupKey)) {
continue;
}
normalizedContexts.push(normalizedContext);
existingIds.add(normalizedContext.id);
existingDedupKeys.add(dedupKey);
}
return normalizedContexts;
}
function shouldRemoveDraft(draft: ComposerThreadDraftState): boolean {
return (
draft.prompt.length === 0 &&
draft.images.length === 0 &&
draft.files.length === 0 &&
draft.persistedAttachments.length === 0 &&
draft.terminalContexts.length === 0 &&
draft.previewAnnotations.length === 0 &&
draft.reviewComments.length === 0 &&
draft.threadContexts.length === 0 &&
draft.environmentContexts.length === 0 &&
Object.keys(draft.modelSelectionByProvider).length === 0 &&
draft.activeProvider === null &&
draft.runtimeMode === null &&
draft.interactionMode === null
);
}
function normalizeProviderDriverKind(value: unknown): ProviderDriverKind | null {
return isProviderDriverKind(value) ? value : null;
}
/** The schema owns validation; this permissive pattern keeps Effect Schema off the hot path. */
const PROVIDER_INSTANCE_ID_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
function normalizeProviderInstanceId(value: unknown): ProviderInstanceId | null {
if (typeof value !== "string") return null;
if (!PROVIDER_INSTANCE_ID_PATTERN.test(value)) return null;
return value as ProviderInstanceId;
}
function coerceProviderOptionSelections(
value: unknown,
): ReadonlyArray<ProviderOptionSelection> | undefined {
if (Array.isArray(value)) {
const out: ProviderOptionSelection[] = [];
for (const entry of value) {
if (!entry || typeof entry !== "object") continue;
const record = entry as Record<string, unknown>;
const id = record.id;
const optionValue = record.value;
if (typeof id !== "string" || id.length === 0) continue;
if (typeof optionValue === "string" || typeof optionValue === "boolean") {
out.push({ id, value: optionValue });
}
}
return out.length > 0 ? out : undefined;
}
if (value && typeof value === "object") {
const record = value as Record<string, unknown>;
const out: ProviderOptionSelection[] = [];
for (const [id, raw] of Object.entries(record)) {
if (typeof raw === "string" || typeof raw === "boolean") {
out.push({ id, value: raw });
}
}
return out.length > 0 ? out : undefined;
}
return undefined;
}
function normalizeProviderModelOptions(
value: unknown,
provider?: ProviderDriverKind | null,
legacy?: LegacyCodexFields,
): ProviderOptionSelectionsByProvider | null {
const candidate = value && typeof value === "object" ? (value as Record<string, unknown>) : null;
const result: ProviderOptionSelectionsByProvider = {};
for (const providerKey of ["codex", "claudeAgent", "cursor", "opencode"] as const) {
const selections = coerceProviderOptionSelections(candidate?.[providerKey]);
if (selections) {
result[providerKey] = selections;
}
}
if (provider === "codex" && legacy) {
const codexExtras: ProviderOptionSelection[] = [];
if (typeof legacy.effort === "string" && legacy.effort.length > 0) {
codexExtras.push({ id: "reasoningEffort", value: legacy.effort });
}
const fastMode =
legacy.codexFastMode === true ||
(typeof legacy.serviceTier === "string" && legacy.serviceTier === "fast");
if (fastMode) {
codexExtras.push({ id: "fastMode", value: true });
}
if (codexExtras.length > 0) {
const existing = result.codex ?? [];
const existingIds = new Set(existing.map((entry) => entry.id));
const merged = [...existing];
for (const extra of codexExtras) {
if (!existingIds.has(extra.id)) merged.push(extra);
}
result.codex = merged;
}
}
return Object.keys(result).length > 0 ? result : null;
}
function normalizeModelSelection(
value: unknown,
legacy?: {
provider?: unknown;
model?: unknown;
modelOptions?: unknown;
legacyCodex?: LegacyCodexFields;
},
): NormalizedModelSelection | null {
const candidate = value && typeof value === "object" ? (value as Record<string, unknown>) : null;
const instanceId = normalizeProviderInstanceId(
candidate?.instanceId ?? candidate?.provider ?? legacy?.provider,
);
if (instanceId === null) {
return null;
}
const rawModel = candidate?.model ?? legacy?.model;
if (typeof rawModel !== "string") {
return null;
}
const driverKindHint =
normalizeProviderDriverKind(candidate?.provider ?? legacy?.provider) ??
ProviderDriverKind.make("codex");
// Instance-scoped picks are already resolved slugs; a custom slug can match a static alias.
const model =
candidate?.instanceId === undefined
? normalizeModelSlug(rawModel, driverKindHint)
: normalizeCustomModelSlug(rawModel);
if (!model) {
return null;
}
if (Array.isArray(candidate?.options)) {
const selections = coerceProviderOptionSelections(candidate.options);
return createModelSelection(instanceId, model, selections) as NormalizedModelSelection;
}
const kindForLegacyOptions = normalizeProviderDriverKind(instanceId);
const modelOptions = kindForLegacyOptions
? normalizeProviderModelOptions(
candidate?.options ? { [kindForLegacyOptions]: candidate.options } : legacy?.modelOptions,
kindForLegacyOptions,
kindForLegacyOptions === "codex" ? legacy?.legacyCodex : undefined,
)
: null;
const options = kindForLegacyOptions ? modelOptions?.[kindForLegacyOptions] : undefined;
return createModelSelection(instanceId, model, options) as NormalizedModelSelection;
}
type NormalizedModelSelection = Omit<ModelSelection, "instanceId"> & {
readonly instanceId: ProviderInstanceId;
};
function legacySyncModelSelectionOptions(
modelSelection: NormalizedModelSelection | null,
modelOptions: ProviderOptionSelectionsByProvider | null | undefined,
): NormalizedModelSelection | null {
if (modelSelection === null) {
return null;
}
const kind = normalizeProviderDriverKind(modelSelection.instanceId);
const options = kind ? modelOptions?.[kind] : undefined;
return createModelSelection(
modelSelection.instanceId,
modelSelection.model,
options,
) as NormalizedModelSelection;
}
function legacyMergeModelSelectionIntoProviderModelOptions(
modelSelection: NormalizedModelSelection | null,
currentModelOptions: ProviderOptionSelectionsByProvider | null | undefined,
): ProviderOptionSelectionsByProvider | null {
if (!modelSelection?.options || modelSelection.options.length === 0) {
return normalizeProviderModelOptions(currentModelOptions);
}
const kind = normalizeProviderDriverKind(modelSelection.instanceId);
if (!kind) {
return normalizeProviderModelOptions(currentModelOptions);
}
return legacyReplaceProviderModelOptions(
normalizeProviderModelOptions(currentModelOptions),
kind,
modelSelection.options,
);
}
function legacyReplaceProviderModelOptions(
currentModelOptions: ProviderOptionSelectionsByProvider | null | undefined,
provider: ProviderDriverKind,
nextProviderOptions: ReadonlyArray<ProviderOptionSelection> | null | undefined,
): ProviderOptionSelectionsByProvider | null {
const { [provider]: _discardedProviderModelOptions, ...otherProviderModelOptions } =
currentModelOptions ?? {};
const merged: ProviderOptionSelectionsByProvider = { ...otherProviderModelOptions };
if (nextProviderOptions && nextProviderOptions.length > 0) {
merged[provider] = nextProviderOptions;
}
return Object.keys(merged).length > 0 ? merged : null;
}
function legacyToModelSelectionByProvider(
modelSelection: NormalizedModelSelection | null,
modelOptions: ProviderOptionSelectionsByProvider | null | undefined,
): Partial<Record<ProviderInstanceId, ModelSelection>> {
const result: Partial<Record<ProviderInstanceId, ModelSelection>> = {};
if (modelOptions) {
for (const provider of ["codex", "claudeAgent", "cursor", "opencode"] as const) {
const options = modelOptions[provider];
if (options && options.length > 0) {
const driverKind = ProviderDriverKind.make(provider);
const instanceKey = defaultInstanceIdForDriver(driverKind);
result[instanceKey] = createModelSelection(
instanceKey,
modelSelection?.instanceId === instanceKey
? modelSelection.model
: (DEFAULT_MODEL_BY_PROVIDER[driverKind] ?? DEFAULT_MODEL),
options,
);
}
}
}
if (modelSelection) {
result[modelSelection.instanceId] = modelSelection as ModelSelection;
}
return result;
}
export function deriveEffectiveComposerModelState(input: {
draft:
| Pick<ComposerThreadDraftState, "modelSelectionByProvider" | "activeProvider">
| null
| undefined;
providers: ReadonlyArray<ServerProvider>;
selectedProvider: ProviderDriverKind;
selectedInstanceId?: ProviderInstanceId | null | undefined;
/** The instance the draft, thread or project asked for; differs from the selection on fallback. */
requestedInstanceId?: ProviderInstanceId | null | undefined;
threadModelSelection: ModelSelection | null | undefined;
projectModelSelection: ModelSelection | null | undefined;
settings: UnifiedSettings;
}): EffectiveComposerModelState {
const baseModelCandidate =
input.threadModelSelection?.model ?? input.projectModelSelection?.model ?? null;
const preserveThreadModel =
input.selectedInstanceId !== null &&
input.selectedInstanceId !== undefined &&
input.threadModelSelection?.instanceId === input.selectedInstanceId;
const baseModel =
(input.selectedInstanceId
? resolveAppModelSelectionForInstance(
input.selectedInstanceId,
input.settings,
input.providers,
baseModelCandidate,
{ preserveUnavailableSelection: preserveThreadModel },
)
: null) ??
// Antigravity has no static model or cross-account catalog fallback.
(input.selectedProvider === "antigravity" && input.selectedInstanceId ? "" : null) ??
resolveAppModelSelection(
input.selectedProvider,
input.settings,
input.providers,
baseModelCandidate,
) ??
normalizeModelSlug(baseModelCandidate, input.selectedProvider) ??
getDefaultServerModel(input.providers, input.selectedProvider);
const instanceSelection = input.selectedInstanceId
? input.draft?.modelSelectionByProvider?.[input.selectedInstanceId]
: undefined;
// Legacy driver-keyed drafts belong to the default instance.
const legacySelection =
input.selectedInstanceId &&
input.selectedInstanceId !== defaultInstanceIdForDriver(input.selectedProvider)
? undefined
: input.draft?.modelSelectionByProvider?.[ProviderInstanceId.make(input.selectedProvider)];
const activeSelection = instanceSelection ?? legacySelection;
const activeSelectionInstanceId = instanceSelection
? (input.selectedInstanceId ?? ProviderInstanceId.make(input.selectedProvider))
: ProviderInstanceId.make(input.selectedProvider);
const selectedModel = activeSelection?.model
? (resolveAppModelSelectionForInstance(
activeSelectionInstanceId,
input.settings,
input.providers,
activeSelection.model,
{ preserveUnavailableSelection: true },
) ??
(input.selectedProvider === "antigravity" ? "" : null) ??
resolveAppModelSelection(
input.selectedProvider,
input.settings,
input.providers,
activeSelection.model,
))
: baseModel;
// Options come from the first of the draft, thread and project that has any. Their selections
// stay with them, so a fallback instance can check which model the options belong to.
const optionSelections =
[
input.draft?.modelSelectionByProvider,
selectionsByInstance(input.threadModelSelection),
selectionsByInstance(input.projectModelSelection),
].find((selections) => modelSelectionByProviderToOptions(selections) !== null) ?? null;
const modelOptions = modelSelectionByProviderToOptions(optionSelections);
return {
selectedModel,
modelOptions: withFallbackInstanceOptions({
...input,
modelOptions,
optionSelections,
selectedModel,
}),
};
}
/**
* When the requested instance is disabled or unavailable, the composer shows another instance of
* the same driver. When that instance has no options of its own and shows the model the requested
* instance's options were picked with, it takes those options instead of the model's defaults.
*/
function withFallbackInstanceOptions(input: {
readonly modelOptions: ProviderOptionSelectionsByProvider | null;
readonly optionSelections: Partial<Record<string, ModelSelection>> | null;
readonly selectedModel: string;
readonly providers: ReadonlyArray<ServerProvider>;
readonly selectedProvider: ProviderDriverKind;
readonly selectedInstanceId?: ProviderInstanceId | null | undefined;
readonly requestedInstanceId?: ProviderInstanceId | null | undefined;
readonly settings: UnifiedSettings;
}): ProviderOptionSelectionsByProvider | null {
const { modelOptions, selectedInstanceId, requestedInstanceId } = input;
if (
!modelOptions ||
!selectedInstanceId ||
!requestedInstanceId ||
selectedInstanceId === requestedInstanceId ||
modelOptions[selectedInstanceId] !== undefined
) {
return modelOptions;
}
const requestedOptions = modelOptions[requestedInstanceId];
const requestedProvider = input.providers.find(
(provider) => provider.instanceId === requestedInstanceId,
);
const requestedModel = input.optionSelections?.[requestedInstanceId]?.model;
// Static aliases are shared across instances; exact custom slugs and catalog aliases are not.
const modelIdentity = (instanceId: ProviderInstanceId, model: string | undefined) => {
const isCustom =
input.providers
.find((provider) => provider.instanceId === instanceId)
?.models.some((entry) => entry.slug === model && entry.isCustom) ||
readInstanceCustomModels(input.settings, instanceId, input.selectedProvider).some(
(entry) => entry.slug === model,
);
return isCustom ? model : normalizeModelSlug(model, input.selectedProvider);
};
const sameModel =
requestedModel === input.selectedModel ||
modelIdentity(requestedInstanceId, requestedModel) ===
modelIdentity(selectedInstanceId, input.selectedModel);
if (!requestedOptions || requestedProvider?.driver !== input.selectedProvider || !sameModel) {
return modelOptions;
}
return { ...modelOptions, [selectedInstanceId]: requestedOptions };
}
function revokeObjectPreviewUrl(previewUrl: string): void {
if (typeof URL === "undefined") {
return;
}
if (!previewUrl.startsWith("blob:")) {
return;
}
URL.revokeObjectURL(previewUrl);
}
function revokeDraftThreadPreviewUrls(draft: ComposerThreadDraftState | undefined): void {
if (!draft) {
return;
}
for (const image of draft.images) {
revokeObjectPreviewUrl(image.previewUrl);
}
}
function normalizePersistedAttachment(value: unknown): PersistedComposerImageAttachment | null {
if (!value || typeof value !== "object") {
return null;
}
const candidate = value as Record<string, unknown>;
const id = candidate.id;
const name = candidate.name;
const mimeType = candidate.mimeType;
const sizeBytes = candidate.sizeBytes;
const dataUrl = candidate.dataUrl;
if (
typeof id !== "string" ||
typeof name !== "string" ||
typeof mimeType !== "string" ||
typeof sizeBytes !== "number" ||
!Number.isFinite(sizeBytes) ||
typeof dataUrl !== "string" ||
id.length === 0 ||
dataUrl.length === 0
) {
return null;
}
return {
id,
name,
mimeType,
sizeBytes,
dataUrl,
...(isSnapShotSource(candidate.source) ? { source: candidate.source } : {}),
};
}
function normalizePersistedTerminalContextDraft(
value: unknown,
): PersistedTerminalContextDraft | null {
if (!value || typeof value !== "object") {
return null;
}
const candidate = value as Record<string, unknown>;
const id = candidate.id;
const threadId = candidate.threadId;
const createdAt = candidate.createdAt;
const lineStart = candidate.lineStart;
const lineEnd = candidate.lineEnd;
if (
typeof id !== "string" ||
id.length === 0 ||
typeof threadId !== "string" ||
threadId.length === 0 ||
typeof createdAt !== "string" ||
createdAt.length === 0 ||
typeof lineStart !== "number" ||
!Number.isFinite(lineStart) ||
typeof lineEnd !== "number" ||
!Number.isFinite(lineEnd)
) {
return null;
}
const terminalId = typeof candidate.terminalId === "string" ? candidate.terminalId.trim() : "";
const terminalLabel =
typeof candidate.terminalLabel === "string" ? candidate.terminalLabel.trim() : "";
if (terminalId.length === 0 || terminalLabel.length === 0) {
return null;
}
const normalizedLineStart = Math.max(1, Math.floor(lineStart));
const normalizedLineEnd = Math.max(normalizedLineStart, Math.floor(lineEnd));
return {
id: toComposerContextId(id),
threadId: threadId as ThreadId,
createdAt,
terminalId,
terminalLabel,
lineStart: normalizedLineStart,
lineEnd: normalizedLineEnd,
...(typeof candidate.text === "string" ? { text: candidate.text } : {}),
};
}
function normalizeDraftThreadEnvMode(
value: unknown,
fallbackWorktreePath: string | null,
): DraftThreadEnvMode {
if (value === "local" || value === "worktree") {
return value;
}
return fallbackWorktreePath ? "worktree" : "local";
}
function projectDraftKey(projectRef: ScopedProjectRef): string {
return scopedProjectKey(projectRef);
}
function logicalProjectDraftKey(logicalProjectKey: string): string {
return logicalProjectKey.trim();
}
export function composerTargetKey(target: ScopedThreadRef | DraftId): string {
if (typeof target === "string") {
return target.trim();
}
return scopedThreadKey(target);
}
function normalizeLegacyComposerStorageKey(
threadKeyOrId: string,
options?: {
environmentId?: EnvironmentId;
},
): string {
const parsedThreadRef = parseScopedThreadKey(threadKeyOrId);
if (parsedThreadRef) {
return composerTargetKey(parsedThreadRef);
}
if (options?.environmentId) {
return composerTargetKey(scopeThreadRef(options.environmentId, threadKeyOrId as ThreadId));
}
return threadKeyOrId;
}
function composerThreadRefFromKey(threadKey: string): ScopedThreadRef | null {
return parseScopedThreadKey(threadKey);
}
type ComposerThreadLookupState = Pick<
ComposerDraftStoreState,
"draftsByThreadKey" | "draftThreadsByThreadKey"
>;
function normalizeComposerTarget(
state: ComposerThreadLookupState,
target: ComposerThreadTarget,
): ComposerThreadTarget | null {
if (typeof target === "string") {
const draftId = target.trim();
return draftId.length > 0 ? DraftId.make(draftId) : null;
}
return target;
}
export function resolveComposerDraftKey(
state: ComposerThreadLookupState,
target: ComposerThreadTarget,
): string | null {
const normalizedTarget = normalizeComposerTarget(state, target);
if (!normalizedTarget) {
return null;
}
if (typeof normalizedTarget !== "string") {
const scopedKey = composerTargetKey(normalizedTarget);
if (state.draftsByThreadKey[scopedKey]) {
return scopedKey;
}
for (const [draftId, draftSession] of Object.entries(state.draftThreadsByThreadKey)) {
if (
draftSession.environmentId === normalizedTarget.environmentId &&
draftSession.threadId === normalizedTarget.threadId
) {
return draftId;
}
}
return scopedKey;
}
const threadKey = composerTargetKey(normalizedTarget);
return threadKey.length > 0 ? threadKey : null;
}
function resolveComposerThreadId(
state: ComposerThreadLookupState,
target: ComposerThreadTarget,
): ThreadId | null {
const normalizedTarget = normalizeComposerTarget(state, target);
if (!normalizedTarget) {
return null;
}
if (typeof normalizedTarget !== "string") {
return normalizedTarget.threadId;
}
return state.draftThreadsByThreadKey[normalizedTarget]?.threadId ?? null;
}
function getComposerDraftState(
state: Pick<ComposerDraftStoreState, "draftsByThreadKey" | "draftThreadsByThreadKey">,
target: ComposerThreadTarget,
): ComposerThreadDraftState | null {
const threadKey = resolveComposerDraftKey(state, target);
if (!threadKey) {
return null;
}
return state.draftsByThreadKey[threadKey] ?? null;
}
function draftThreadHasOpenPreview(draftThread: DraftThreadState | undefined): boolean {
if (draftThread === undefined) return false;
const ref = scopeThreadRef(draftThread.environmentId, draftThread.threadId);
return Object.keys(readThreadPreviewState(ref).sessions).length > 0;
}
function isComposerThreadKeyInUse(mappings: Record<string, string>, threadKey: string): boolean {
return Object.values(mappings).includes(threadKey);
}
function toProjectDraftSession(
draftId: DraftId,
draftSession: DraftSessionState,
): ProjectDraftSession {
return {
draftId,
...draftSession,
};
}
function createDraftThreadState(
projectRef: ScopedProjectRef,
threadId: ThreadId,
logicalProjectKey: string,
existingThread: DraftThreadState | undefined,
options?: {
threadId?: ThreadId;
branch?: string | null;
worktreePath?: string | null;
createdAt?: string;
envMode?: DraftThreadEnvMode;
startFromOrigin?: boolean;
runtimeMode?: RuntimeMode;
interactionMode?: ProviderInteractionMode;
environmentSelection?: "auto" | "manual";
loadBalancedEnvironmentId?: EnvironmentId | null;
},
): DraftThreadState {
const projectChanged =
existingThread !== undefined &&
(existingThread.environmentId !== projectRef.environmentId ||
existingThread.projectId !== projectRef.projectId);
const nextWorktreePath =
options?.worktreePath === undefined
? projectChanged
? null
: (existingThread?.worktreePath ?? null)
: (options.worktreePath ?? null);
const nextBranch =
options?.branch === undefined
? projectChanged
? null
: (existingThread?.branch ?? null)
: (options.branch ?? null);
const nextStartFromOrigin =
options?.startFromOrigin === undefined
? (existingThread?.startFromOrigin ?? false)
: options.startFromOrigin;
const environmentSelection =
options?.environmentSelection ?? existingThread?.environmentSelection;
return {
threadId,
environmentId: projectRef.environmentId,
projectId: projectRef.projectId,
logicalProjectKey,
...(environmentSelection ? { environmentSelection } : {}),
...(options?.loadBalancedEnvironmentId !== undefined
? { loadBalancedEnvironmentId: options.loadBalancedEnvironmentId }
: existingThread?.loadBalancedEnvironmentId !== undefined
? {
loadBalancedEnvironmentId: projectChanged
? null
: existingThread.loadBalancedEnvironmentId,
}
: {}),
createdAt: options?.createdAt ?? existingThread?.createdAt ?? new Date().toISOString(),
runtimeMode: options?.runtimeMode ?? existingThread?.runtimeMode ?? DEFAULT_RUNTIME_MODE,
interactionMode:
options?.interactionMode ?? existingThread?.interactionMode ?? DEFAULT_INTERACTION_MODE,
branch: nextBranch,
worktreePath: nextWorktreePath,
envMode:
options?.envMode ?? (nextWorktreePath ? "worktree" : (existingThread?.envMode ?? "local")),
startFromOrigin: nextStartFromOrigin,
promotedTo: null,
};
}
function scopedThreadRefsEqual(
left: ScopedThreadRef | null | undefined,
right: ScopedThreadRef | null | undefined,
): boolean {
if (!left || !right) {
return left === right;
}
return left.environmentId === right.environmentId && left.threadId === right.threadId;
}
function isDraftThreadPromoting(draftThread: DraftThreadState | null | undefined): boolean {
return draftThread?.promotedTo !== null && draftThread?.promotedTo !== undefined;
}
function draftThreadsEqual(left: DraftThreadState | undefined, right: DraftThreadState): boolean {
return (
!!left &&
left.threadId === right.threadId &&
left.environmentId === right.environmentId &&
left.projectId === right.projectId &&
left.logicalProjectKey === right.logicalProjectKey &&
left.environmentSelection === right.environmentSelection &&
left.loadBalancedEnvironmentId === right.loadBalancedEnvironmentId &&
left.createdAt === right.createdAt &&
left.runtimeMode === right.runtimeMode &&
left.interactionMode === right.interactionMode &&
left.branch === right.branch &&
left.worktreePath === right.worktreePath &&
left.envMode === right.envMode &&
left.startFromOrigin === right.startFromOrigin &&
scopedThreadRefsEqual(left.promotedTo, right.promotedTo)
);
}
function removeDraftThreadReferences(
state: Pick<
ComposerDraftStoreState,
| "draftThreadsByThreadKey"
| "draftsByThreadKey"
| "logicalProjectDraftThreadKeyByLogicalProjectKey"
>,
threadKey: string,
composerDestination?: ScopedThreadRef,
): Pick<
ComposerDraftStoreState,
| "draftThreadsByThreadKey"
| "draftsByThreadKey"
| "logicalProjectDraftThreadKeyByLogicalProjectKey"
> {
const nextLogicalMappings = Object.fromEntries(
Object.entries(state.logicalProjectDraftThreadKeyByLogicalProjectKey).filter(
([, draftThreadKey]) => draftThreadKey !== threadKey,
),
) as Record<string, string>;
const { [threadKey]: _removedDraftThread, ...restDraftThreadsByThreadKey } =
state.draftThreadsByThreadKey;
const { [threadKey]: removedComposerDraft, ...restDraftsByThreadKey } = state.draftsByThreadKey;
if (composerDestination && removedComposerDraft) {
restDraftsByThreadKey[composerTargetKey(composerDestination)] = removedComposerDraft;
} else {
revokeDraftThreadPreviewUrls(removedComposerDraft);
}
return {
draftsByThreadKey: restDraftsByThreadKey,
draftThreadsByThreadKey: restDraftThreadsByThreadKey,
logicalProjectDraftThreadKeyByLogicalProjectKey: nextLogicalMappings,
};
}
function normalizePersistedDraftThreads(
rawDraftThreadsByThreadId: unknown,
rawProjectDraftThreadIdByProjectKey: unknown,
): Pick<
PersistedComposerDraftStoreState,
"draftThreadsByThreadKey" | "logicalProjectDraftThreadKeyByLogicalProjectKey"
> {
const draftThreadsByThreadKey: Record<string, PersistedDraftThreadState> = {};
const environmentIdByThreadId = new Map<ThreadId, EnvironmentId>();
if (
rawProjectDraftThreadIdByProjectKey &&
typeof rawProjectDraftThreadIdByProjectKey === "object"
) {
for (const [projectKey, threadId] of Object.entries(
rawProjectDraftThreadIdByProjectKey as Record<string, unknown>,
)) {
if (typeof threadId !== "string" || threadId.length === 0) {
continue;
}
const projectRef = parseScopedProjectKey(projectKey);
if (!projectRef) {
continue;
}
const parsedThreadRef = parseScopedThreadKey(threadId);
if (parsedThreadRef) {
environmentIdByThreadId.set(parsedThreadRef.threadId, parsedThreadRef.environmentId);
continue;
}
environmentIdByThreadId.set(threadId as ThreadId, projectRef.environmentId);
}
}
if (rawDraftThreadsByThreadId && typeof rawDraftThreadsByThreadId === "object") {
for (const [threadKeyOrId, rawDraftThread] of Object.entries(
rawDraftThreadsByThreadId as Record<string, unknown>,
)) {
if (typeof threadKeyOrId !== "string" || threadKeyOrId.length === 0) {
continue;
}
if (!rawDraftThread || typeof rawDraftThread !== "object") {
continue;
}
const candidateDraftThread = rawDraftThread as Record<string, unknown>;
const parsedThreadRef = parseScopedThreadKey(threadKeyOrId);
const threadKey = normalizeLegacyComposerStorageKey(threadKeyOrId);
const threadId =
parsedThreadRef?.threadId ??
(typeof candidateDraftThread.threadId === "string" &&
candidateDraftThread.threadId.length > 0
? (candidateDraftThread.threadId as ThreadId)
: (threadKeyOrId as ThreadId));
const environmentId =
parsedThreadRef?.environmentId ??
(typeof candidateDraftThread.environmentId === "string" &&
candidateDraftThread.environmentId.length > 0
? (candidateDraftThread.environmentId as EnvironmentId)
: environmentIdByThreadId.get(threadKeyOrId as ThreadId));
const projectId = candidateDraftThread.projectId;
const createdAt = candidateDraftThread.createdAt;
const branch = candidateDraftThread.branch;
const worktreePath = candidateDraftThread.worktreePath;
const startFromOrigin = candidateDraftThread.startFromOrigin === true;
const normalizedWorktreePath = typeof worktreePath === "string" ? worktreePath : null;
const promotedToCandidate = candidateDraftThread.promotedTo;
const promotedToRecord =
promotedToCandidate && typeof promotedToCandidate === "object"
? (promotedToCandidate as Record<string, unknown>)
: null;
const promotedTo =
promotedToRecord &&
typeof promotedToRecord.environmentId === "string" &&
promotedToRecord.environmentId.length > 0 &&
typeof promotedToRecord.threadId === "string" &&
promotedToRecord.threadId.length > 0
? scopeThreadRef(
promotedToRecord.environmentId as EnvironmentId,
promotedToRecord.threadId as ThreadId,
)
: null;
if (typeof projectId !== "string" || projectId.length === 0 || environmentId === undefined) {
continue;
}
const normalizedEnvironmentId = environmentId as EnvironmentId;
draftThreadsByThreadKey[threadKey] = {
threadId,
environmentId: normalizedEnvironmentId,
projectId: projectId as ProjectId,
logicalProjectKey:
typeof candidateDraftThread.logicalProjectKey === "string" &&
candidateDraftThread.logicalProjectKey.length > 0
? candidateDraftThread.logicalProjectKey
: parsedThreadRef
? projectDraftKey(scopeProjectRef(normalizedEnvironmentId, projectId as ProjectId))
: threadKeyOrId,
createdAt:
typeof createdAt === "string" && createdAt.length > 0
? createdAt
: new Date().toISOString(),
runtimeMode: isRuntimeMode(candidateDraftThread.runtimeMode)
? candidateDraftThread.runtimeMode
: DEFAULT_RUNTIME_MODE,
interactionMode:
candidateDraftThread.interactionMode === "plan" ||
candidateDraftThread.interactionMode === "default"
? candidateDraftThread.interactionMode
: DEFAULT_INTERACTION_MODE,
branch: typeof branch === "string" ? branch : null,
worktreePath: normalizedWorktreePath,
envMode: normalizeDraftThreadEnvMode(candidateDraftThread.envMode, normalizedWorktreePath),
startFromOrigin,
...(candidateDraftThread.environmentSelection === "manual" ||
candidateDraftThread.environmentSelection === "auto"
? { environmentSelection: candidateDraftThread.environmentSelection }
: {}),
...(typeof candidateDraftThread.loadBalancedEnvironmentId === "string" &&
candidateDraftThread.loadBalancedEnvironmentId.length > 0
? { loadBalancedEnvironmentId: candidateDraftThread.loadBalancedEnvironmentId }
: candidateDraftThread.loadBalancedEnvironmentId === null
? { loadBalancedEnvironmentId: null }
: {}),
promotedTo,
};
}
}
const logicalProjectDraftThreadKeyByLogicalProjectKey: Record<string, string> = {};
if (
rawProjectDraftThreadIdByProjectKey &&
typeof rawProjectDraftThreadIdByProjectKey === "object"
) {
for (const [logicalProjectKey, threadKeyOrId] of Object.entries(
rawProjectDraftThreadIdByProjectKey as Record<string, unknown>,
)) {
if (typeof threadKeyOrId !== "string" || threadKeyOrId.length === 0) {
continue;
}
const projectRef = parseScopedProjectKey(logicalProjectKey);
const parsedThreadRef = parseScopedThreadKey(threadKeyOrId);
const threadKey = normalizeLegacyComposerStorageKey(threadKeyOrId);
logicalProjectDraftThreadKeyByLogicalProjectKey[logicalProjectKey] = threadKey;
const existingDraftThread = draftThreadsByThreadKey[threadKey];
if (parsedThreadRef) {
environmentIdByThreadId.set(parsedThreadRef.threadId, parsedThreadRef.environmentId);
}
// Logical keys may contain workspace paths; a matching draft's concrete project id wins.
if (existingDraftThread?.logicalProjectKey === logicalProjectKey) {
continue;
}
if (!projectRef) {
if (existingDraftThread) {
draftThreadsByThreadKey[threadKey] = {
...existingDraftThread,
logicalProjectKey,
};
}
continue;
}
if (!existingDraftThread) {
draftThreadsByThreadKey[threadKey] = {
threadId: parsedThreadRef?.threadId ?? (threadKey as ThreadId),
environmentId: projectRef.environmentId,
projectId: projectRef.projectId,