@xopcai/xopc 0.0.332 → 0.0.334

package/dist/src/tui/backends/embedded-backend.d.ts

@@ -29,12 +29,15 @@ export declare class EmbeddedBackend implements TuiBackend {
     private running;
     private chatAbort;
     private readonly chatInputStates;
+    private readonly drafts;
+    private readonly inputStateRevisions;
     onEvent?: (evt: TuiEvent) => void;
     onConnected?: () => void;
     onDisconnected?: (reason: string) => void;
     constructor(opts?: EmbeddedBackendOptions);
     get connectionLabel(): string;
     getComposerInputHistory(): Promise<TuiComposerHistoryItem[]>;
+    getComposerDraftDirectory(): Promise<string>;
     recordComposerInputHistory(text: string): Promise<TuiComposerHistoryItem>;
     start(): void;
     private ensureAgent;
@@ -97,6 +100,7 @@ export declare class EmbeddedBackend implements TuiBackend {
     private appendPendingChatInput;
     private consumePendingChatInput;
     private publishChatInputState;
+    private sequenceInputState;
     private replaceEmbeddedQueue;
     loadHistory(opts: {
         conversationId: string;
@@ -130,6 +134,7 @@ export declare class EmbeddedBackend implements TuiBackend {
         ok: boolean;
     }>;
     createConversation(agentId: string, conversationId?: string): Promise<string>;
+    private materializeDraft;
     getSessionInfo(conversationId: string): Promise<SessionInfo>;
     listModels(): Promise<TuiModelChoice[]>;
     refreshModels(): Promise<void>;

package/dist/src/tui/backends/embedded-backend.js

@@ -1,14 +1,20 @@
+import { resolveStateDir } from "../../config/paths-state.js";
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { openXopcDatabase } from "../../storage/sqlite/connection.js";
+import { canonicalSessionCommand, sessionInputCommandSchema } from "../../../packages/gateway-contract/src/session-input-command.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { cancelQueuedSessionInput, claimNextSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, init_session_input_repository, setSessionInputStatus } from "../../storage/sqlite/session-input-repository.js";
 import { appendComposerInputHistory, listComposerInputHistory } from "../../storage/sqlite/composer-input-history-repository.js";
 import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
 import { init_sqlite } from "../../storage/sqlite/index.js";
 import { normalizeAgentId } from "../../agent-catalog/id.js";
-import { getAgentDefaultModelRef, init_schema } from "../../config/schema.js";
 import { init_agent_scope, listAgentEntries } from "../../agent/agent-scope.js";
-import { createConversation, init_conversation_repository } from "../../storage/sqlite/conversation-repository.js";
+import { init_paths } from "../../config/paths.js";
+import { AgentCatalogService } from "../../agent-catalog/service.js";
+import { getAgentDefaultModelRef, init_schema } from "../../config/schema.js";
 import { init_agent_session_key, resolveAgentIdFromConversationId } from "../../routing/agent-session-key.js";
+import { resolveEffectiveAgentProfile } from "../../config/agent-profile.js";
 import { effectiveWorkspacePathForSession } from "../../session/session-workspace.js";
 import { ProjectService } from "../../projects/project-service.js";
 import { inferSuggestedProjectDefaultAgentId } from "../../projects/project-agent-suggestion.js";
@@ -17,7 +23,6 @@ import { buildSessionTimeline } from "../../session/transcript-outline.js";
 import { transcriptRowsToClientHistory } from "../../session/client-history.js";
 import { createCreateShareTool, isShareToolAvailable } from "../../agent/tools/create-share-tool.js";
 import { evictEmbeddedSessionRunner } from "../../agent/embedded/session-runner.js";
-import { AgentCatalogService } from "../../agent-catalog/service.js";
 import { SessionIndex } from "../../session/manager.js";
 import "../../session/index.js";
 import { parseModelRef } from "../../agent/models/selection.js";
@@ -33,15 +38,19 @@ import { WorkflowRunService } from "../../workflows/service/workflow-run-service
 import { WorkflowSessionBridge } from "../../workflows/service/workflow-session-bridge.js";
 import { ChatStreamMapper } from "../../gateway/chat-stream/mapper.js";
 import { getXopcCloudCatalogCoordinator } from "../../providers/xopc-cloud-catalog-coordinator.js";
+import { acceptSessionCommand } from "../../storage/sqlite/session-creation-repository.js";
 import { fuzzySearchWorkspaceFiles } from "../../gateway/workspace-file-search.js";
 import { commitDeliveredChatInput } from "../tui-chat-input-state.js";
 import { sessionMetadataToTuiItem } from "../tui-session-format.js";
 import { buildTuiTranscriptTree, transcriptTreeEntryIdToRowNumber } from "../tui-transcript-tree.js";
 import { computeTuiSessionStats } from "../tui-session-stats.js";
 import { collectTuiStartupResources } from "../tui-startup-resources.js";
-import { isAbsolute, relative, resolve } from "node:path";
+import { EmbeddedDraftStore } from "./embedded-drafts.js";
+import { isAbsolute, join, relative, resolve } from "node:path";
 //#region src/tui/backends/embedded-backend.ts
-init_conversation_repository();
+init_src();
+init_paths();
+init_session_input_repository();
 init_agent_scope();
 init_agent_session_key();
 init_schema();
@@ -83,6 +92,8 @@ var EmbeddedBackend = class {
 	running = false;
 	chatAbort = null;
 	chatInputStates = /* @__PURE__ */ new Map();
+	drafts = new EmbeddedDraftStore();
+	inputStateRevisions = /* @__PURE__ */ new Map();
 	onEvent;
 	onConnected;
 	onDisconnected;
@@ -96,6 +107,9 @@ var EmbeddedBackend = class {
 	async getComposerInputHistory() {
 		return listComposerInputHistory();
 	}
+	async getComposerDraftDirectory() {
+		return join(resolveStateDir(), "client-drafts", "embedded", "composers");
+	}
 	async recordComposerInputHistory(text) {
 		return appendComposerInputHistory(text).item;
 	}
@@ -231,12 +245,17 @@ var EmbeddedBackend = class {
 		return Boolean(implicit && isPathSameOrInside(implicit, workspaceDir));
 	}
 	async getStartupResources(conversationId) {
-		return collectTuiStartupResources(this.activeConfig(), conversationId, { isWorkspaceTrusted: (workspaceDir) => this.isWorkspaceTrusted(workspaceDir) });
+		const draft = this.drafts.read(conversationId);
+		return collectTuiStartupResources(this.activeConfig(), draft ? void 0 : conversationId, {
+			agentId: draft?.creation.agentId,
+			isWorkspaceTrusted: (workspaceDir) => this.isWorkspaceTrusted(workspaceDir)
+		});
 	}
 	refreshWorkspaceTrust() {
 		this.agent?.refreshSkillsAfterTrustChange();
 	}
 	async startWorkflowRun(opts) {
+		await this.materializeDraft(opts.conversationId);
 		await this.sessionIndexReady;
 		const agentId = opts.agentId?.trim() || resolveAgentIdFromConversationId(opts.conversationId);
 		const result = await this.getWorkflowRunService().startWorkflowRun({
@@ -278,6 +297,17 @@ var EmbeddedBackend = class {
 			created: match.created,
 			reason: match.reason
 		};
+		const draft = this.drafts.read(opts.conversationId);
+		if (draft) {
+			if (draft.command || draft.materialization) throw new Error("First input is awaiting confirmation");
+			draft.creation.projectId = match.project.id;
+			this.drafts.save(opts.conversationId, draft);
+			return {
+				project: match.project,
+				created: match.created,
+				reason: match.reason
+			};
+		}
 		if (!getSessionMetadata(opts.conversationId)) await this.sessionIndex.getStore().resolveTranscriptPath(opts.conversationId, { metadata: {
 			sourceChannel: "tui",
 			sourceChatId: `default:direct:${opts.conversationId}`,
@@ -299,9 +329,10 @@ var EmbeddedBackend = class {
 		};
 	}
 	async searchWorkspaceFiles(conversationId, query, options) {
-		if (!this.agent) return [];
+		const draft = this.drafts.read(conversationId);
+		if (!this.agent && !draft) return [];
 		try {
-			return await fuzzySearchWorkspaceFiles(await this.agent.getEffectiveWorkspacePathForSession(conversationId), query, options?.limit ?? 15);
+			return await fuzzySearchWorkspaceFiles(draft ? (await this.getSessionInfo(conversationId)).effectiveWorkspacePath : await this.agent.getEffectiveWorkspacePathForSession(conversationId), query, options?.limit ?? 15);
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			log.warn({
@@ -313,13 +344,91 @@ var EmbeddedBackend = class {
 		}
 	}
 	async getReviewContext(conversationId) {
+		if (this.drafts.read(conversationId)) return buildReviewContext(await resolveGitRoot((await this.getSessionInfo(conversationId)).effectiveWorkspacePath));
 		const config = this.activeConfig();
 		const metadata = getSessionMetadata(conversationId);
 		return buildReviewContext(await resolveGitRoot(effectiveWorkspacePathForSession(config, conversationId, null, metadata?.projectId ? new ProjectService().get(metadata.projectId) : null)));
 	}
 	async sendChat(opts) {
-		const agent = await this.ensureAgent();
+		if (this.drafts.read(opts.conversationId)?.materialization) await this.materializeDraft(opts.conversationId);
 		const runId = crypto.randomUUID();
+		let durableInput = false;
+		const draft = this.drafts.read(opts.conversationId);
+		if (draft) {
+			const candidate = sessionInputCommandSchema.parse({
+				kind: "start",
+				clientMessageId: draft.command?.clientMessageId ?? crypto.randomUUID(),
+				creation: {
+					...draft.creation,
+					thinkingLevel: opts.thinking ?? draft.creation.thinkingLevel
+				},
+				input: {
+					content: opts.message,
+					...opts.attachments?.length ? { attachments: opts.attachments } : {}
+				},
+				origin: {
+					type: "system",
+					source: "cli"
+				}
+			});
+			if (candidate.kind !== "start") throw new Error("Expected first input");
+			if (draft.command && canonicalSessionCommand(draft.command) !== canonicalSessionCommand(candidate)) throw new Error("First input is awaiting confirmation");
+			draft.command = candidate;
+			draft.creation = candidate.creation;
+			this.drafts.save(opts.conversationId, draft);
+			await this.ensureAgent();
+			const receipt = acceptSessionCommand({
+				conversationId: opts.conversationId,
+				principalId: "local:tui",
+				command: candidate,
+				sourceChannel: "tui",
+				config: {
+					...draft.config,
+					modelOverride: draft.creation.model,
+					fixedModel: true,
+					thinkingLevel: draft.creation.thinkingLevel
+				},
+				attachProject: (id, projectId) => {
+					new ProjectService().attachSession(id, projectId);
+				},
+				preparedInput: {
+					content: opts.message,
+					attachments: opts.attachments,
+					thinking: opts.thinking,
+					requestedDelivery: "next",
+					effectiveDelivery: "next",
+					status: "queued",
+					origin: candidate.origin
+				}
+			});
+			const accepted = getSessionInputById(opts.conversationId, receipt.inputId);
+			if (accepted?.runId && ![
+				"running",
+				"interrupted",
+				"queued"
+			].includes(accepted.status)) {
+				this.drafts.remove(opts.conversationId);
+				return { runId: accepted.runId };
+			}
+			if (accepted?.status === "running") {
+				let alive = true;
+				if (draft.ownerPid) try {
+					process.kill(draft.ownerPid, 0);
+				} catch (error) {
+					alive = error.code !== "ESRCH";
+				}
+				if (alive) throw new Error("First input is still owned by a running process");
+				finishSessionInputRun(opts.conversationId, accepted.runId, "interrupted", "Embedded process exited");
+				throw new Error("Previous run was interrupted. Review its history before explicitly retrying the same input.");
+			}
+			if (accepted?.status === "interrupted") setSessionInputStatus(accepted.id, "queued");
+			draft.ownerPid = process.pid;
+			this.drafts.save(opts.conversationId, draft);
+			const claimed = claimNextSessionInput(opts.conversationId, runId, receipt.inputId);
+			if (!claimed || claimed.id !== receipt.inputId) throw new Error("First input is already queued for execution");
+			durableInput = true;
+		}
+		const agent = await this.ensureAgent();
 		this.chatAbort?.abort();
 		this.chatAbort = new AbortController();
 		const signal = this.chatAbort.signal;
@@ -335,6 +444,7 @@ var EmbeddedBackend = class {
 		});
 		(async () => {
 			let initialUserMessageObserved = false;
+			let outcome = "completed";
 			try {
 				const messageForAgent = opts.message.trimStart().startsWith("/") ? opts.message : prependEnvelopeTimestamp(opts.message);
 				const stream = agent.turnDispatcher.processDirectStreaming(messageForAgent, opts.conversationId, {
@@ -361,6 +471,7 @@ var EmbeddedBackend = class {
 					source: "embedded"
 				});
 			} catch (error) {
+				outcome = "failed";
 				if (signal.aborted) return;
 				const errorMessage = error instanceof Error ? error.message : String(error);
 				for (const mapped of mapper.error(errorMessage)) this.onEvent?.({
@@ -373,6 +484,23 @@ var EmbeddedBackend = class {
 					data: mapped,
 					source: "embedded"
 				});
+			} finally {
+				if (durableInput) {
+					finishSessionInputRun(opts.conversationId, runId, signal.aborted ? "cancelled" : outcome);
+					try {
+						this.drafts.remove(opts.conversationId);
+					} catch (err) {
+						log.warn({
+							err,
+							conversationId: opts.conversationId
+						}, "Accepted draft cleanup failed");
+					}
+					this.publishChatInputState(this.chatInputStates.get(opts.conversationId) ?? {
+						conversationId: opts.conversationId,
+						revision: 0,
+						inputs: []
+					});
+				}
 			}
 		})();
 		return { runId };
@@ -406,11 +534,35 @@ var EmbeddedBackend = class {
 		};
 	}
 	async getChatInputState(conversationId) {
-		return this.chatInputStates.get(conversationId) ?? {
+		const draft = this.drafts.read(conversationId);
+		if (draft?.command) {
+			const durable = getSessionInputState(conversationId);
+			const input = durable.inputs.find((item) => item.clientMessageId === draft.command.clientMessageId);
+			if (input?.status === "running" && draft.ownerPid) {
+				let alive = true;
+				try {
+					process.kill(draft.ownerPid, 0);
+				} catch (error) {
+					alive = error.code !== "ESRCH";
+				}
+				if (!alive) {
+					finishSessionInputRun(conversationId, input.runId, "interrupted", "Embedded process exited");
+					return this.sequenceInputState(getSessionInputState(conversationId));
+				}
+			}
+			if (durable.inputs.length) {
+				const local = this.chatInputStates.get(conversationId);
+				return this.sequenceInputState({
+					...durable,
+					inputs: [...durable.inputs, ...local?.inputs.filter((item) => !durable.inputs.some((saved) => saved.id === item.id)) ?? []]
+				});
+			}
+		}
+		return this.sequenceInputState(this.chatInputStates.get(conversationId) ?? {
 			conversationId,
 			revision: 0,
 			inputs: []
-		};
+		});
 	}
 	async updateChatInput(opts) {
 		const current = await this.getChatInputState(opts.conversationId);
@@ -439,6 +591,14 @@ var EmbeddedBackend = class {
 		};
 	}
 	async removeChatInput(opts) {
+		if (this.drafts.read(opts.conversationId)?.command && getSessionInputById(opts.conversationId, opts.inputId)) {
+			const ok = cancelQueuedSessionInput(opts.conversationId, opts.inputId, opts.version);
+			if (ok) this.drafts.remove(opts.conversationId);
+			return {
+				ok,
+				state: this.sequenceInputState(getSessionInputState(opts.conversationId))
+			};
+		}
 		const current = await this.getChatInputState(opts.conversationId);
 		const target = current.inputs.find((input) => input.id === opts.inputId);
 		if (!target || target.version !== opts.version || target.status !== "queued" && target.status !== "interrupted") return {
@@ -489,23 +649,37 @@ var EmbeddedBackend = class {
 		if (next !== current) this.publishChatInputState(next);
 	}
 	publishChatInputState(state) {
-		this.chatInputStates.set(state.conversationId, state);
+		state = this.sequenceInputState(state);
+		this.chatInputStates.set(state.conversationId, {
+			...state,
+			inputs: state.inputs.filter((input) => input.status !== "running")
+		});
 		this.onEvent?.({
 			event: "session.input-state",
 			data: state,
 			source: "embedded"
 		});
 	}
+	sequenceInputState(state) {
+		const revision = Math.max(state.revision, (this.inputStateRevisions.get(state.conversationId) ?? -1) + 1);
+		this.inputStateRevisions.set(state.conversationId, revision);
+		return {
+			...state,
+			revision
+		};
+	}
 	async replaceEmbeddedQueue(conversationId, state) {
 		const { getEmbeddedRunByConversationId } = await import("../../agent/embedded/runs.js");
 		const handle = getEmbeddedRunByConversationId(conversationId);
 		if (!handle) return false;
 		handle.session.clearQueue();
 		for (const input of state.inputs) if (input.status === "injecting") await handle.session.steer(input.content);
-		else await handle.session.followUp(input.content);
+		else if (input.status === "queued") await handle.session.followUp(input.content);
 		return true;
 	}
 	async loadHistory(opts) {
+		const draft = this.drafts.read(opts.conversationId);
+		if (draft && (!draft.command || !getSessionMetadata(opts.conversationId))) return { messages: [] };
 		if (!this.agent) return { messages: [] };
 		try {
 			return { messages: transcriptRowsToClientHistory(await this.agent.sessionStore.loadTranscriptRows(opts.conversationId), { limit: opts.limit }) };
@@ -656,10 +830,17 @@ var EmbeddedBackend = class {
 		}
 	}
 	async deleteSession(conversationId) {
+		const draft = this.drafts.read(conversationId);
+		if (draft && !draft.command && !draft.materialization) {
+			this.drafts.remove(conversationId);
+			return { ok: true };
+		}
 		const store = this.agent?.sessionStore ?? this.sessionIndex?.getStore();
 		if (!store) return { ok: false };
 		try {
-			return { ok: await store.deleteSession(conversationId) };
+			const ok = await store.deleteSession(conversationId);
+			if (ok && draft) this.drafts.remove(conversationId);
+			return { ok };
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			log.warn({
@@ -671,14 +852,68 @@ var EmbeddedBackend = class {
 		}
 	}
 	async createConversation(agentId, conversationId) {
-		return createConversation({
-			agentId,
+		const id = conversationId ?? crypto.randomUUID();
+		if (this.drafts.read(id)) return id;
+		const profile = resolveEffectiveAgentProfile(agentId);
+		this.drafts.save(id, {
+			creation: {
+				agentId: profile.agentId,
+				projectId: null,
+				execution: null,
+				temporary: false,
+				model: profile.primaryModelRef,
+				thinkingLevel: "off"
+			},
+			config: {}
+		});
+		return id;
+	}
+	async materializeDraft(conversationId) {
+		const draft = this.drafts.read(conversationId);
+		if (!draft) return;
+		if (draft.command) throw new Error("First input is awaiting confirmation");
+		draft.materialization ??= {
+			commandId: crypto.randomUUID(),
+			purpose: "session_resources",
+			creation: draft.creation
+		};
+		this.drafts.save(conversationId, draft);
+		await this.ensureAgent();
+		acceptSessionCommand({
+			conversationId,
+			principalId: "local:tui",
 			sourceChannel: "tui",
-			customData: { genericNewChatShell: true },
-			hiddenFromSessionList: true
-		}, "", conversationId).key;
+			command: draft.materialization,
+			config: {
+				...draft.config,
+				modelOverride: draft.creation.model,
+				fixedModel: true,
+				thinkingLevel: draft.creation.thinkingLevel
+			},
+			attachProject: (id, projectId) => {
+				new ProjectService().attachSession(id, projectId);
+			}
+		});
+		this.drafts.remove(conversationId);
 	}
 	async getSessionInfo(conversationId) {
+		const draft = this.drafts.read(conversationId);
+		if (draft) {
+			const model = parseModelRef(draft.creation.model);
+			const profile = resolveEffectiveAgentProfile(draft.creation.agentId);
+			const project = draft.creation.projectId ? new ProjectService().get(draft.creation.projectId) : null;
+			return {
+				agentId: draft.creation.agentId,
+				model: model?.model ?? draft.creation.model,
+				modelProvider: model?.provider,
+				thinkingLevel: draft.creation.thinkingLevel,
+				reasoningLevel: draft.config.reasoningLevel,
+				verboseLevel: draft.config.verboseLevel,
+				projectId: draft.creation.projectId ?? void 0,
+				workingDirectoryLocked: Boolean(project),
+				effectiveWorkspacePath: project?.workspaceRoot || draft.config.workingDirectoryOverride || profile.resolvedWorkspacePath
+			};
+		}
 		if (!this.agent) return { model: getAgentDefaultModelRef() ?? void 0 };
 		try {
 			const cfg = await this.agent.sessionInspector.agentConfig(conversationId);
@@ -686,7 +921,6 @@ var EmbeddedBackend = class {
 			const usage = await this.agent.sessionInspector.contextUsage(conversationId);
 			return {
 				agentId: getSessionMetadata(conversationId)?.agentId,
-				generatedShell: getSessionMetadata(conversationId)?.customData?.genericNewChatShell === true,
 				model: parsed?.model ?? cfg.model,
 				modelProvider: parsed?.provider,
 				thinkingLevel: cfg.thinkingLevel,
@@ -726,6 +960,18 @@ var EmbeddedBackend = class {
 		await this.agent.resetSession(conversationId);
 	}
 	async patchSession(conversationId, patch) {
+		const draft = this.drafts.read(conversationId);
+		if (draft) {
+			if (draft.command || draft.materialization) throw new Error("First input is awaiting confirmation");
+			if (typeof patch.model === "string") draft.creation.model = patch.model;
+			if (typeof patch.thinkingLevel === "string") draft.creation.thinkingLevel = patch.thinkingLevel;
+			if (typeof patch.workingDirectory === "string") draft.config.workingDirectoryOverride = resolve(patch.workingDirectory);
+			if (patch.reasoningLevel === "off" || patch.reasoningLevel === "on" || patch.reasoningLevel === "stream") draft.config.reasoningLevel = patch.reasoningLevel;
+			if (patch.verboseLevel === "off" || patch.verboseLevel === "on" || patch.verboseLevel === "full") draft.config.verboseLevel = patch.verboseLevel;
+			if (patch.projectId === null || typeof patch.projectId === "string") draft.creation.projectId = typeof patch.projectId === "string" ? patch.projectId : null;
+			this.drafts.save(conversationId, draft);
+			return;
+		}
 		const agent = await this.ensureAgent();
 		const hasProjectPatch = Object.prototype.hasOwnProperty.call(patch, "projectId");
 		const projectId = typeof patch.projectId === "string" ? patch.projectId.trim() : "";

package/dist/src/tui/backends/embedded-drafts.d.ts

@@ -0,0 +1,22 @@
+import type { SessionCreation, SessionInputCommand, SessionMaterializeCommand } from '@xopcai/gateway-contract';
+import type { SessionAgentConfig } from '../../session/config-types.js';
+export interface EmbeddedDraft {
+    creation: SessionCreation;
+    config: SessionAgentConfig;
+    command?: Extract<SessionInputCommand, {
+        kind: 'start';
+    }>;
+    materialization?: SessionMaterializeCommand;
+    ownerPid?: number;
+}
+/** Draft files are private client state, never session/transcript rows. */
+export declare class TuiDraftFileStore<T> {
+    private readonly directory;
+    constructor(directory?: string);
+    private path;
+    read(id: string): T | undefined;
+    save(id: string, draft: T): void;
+    remove(id: string): void;
+}
+export declare class EmbeddedDraftStore extends TuiDraftFileStore<EmbeddedDraft> {
+}

package/dist/src/tui/backends/embedded-drafts.js

@@ -0,0 +1,53 @@
+import { resolveStateDir } from "../../config/paths-state.js";
+import { init_paths } from "../../config/paths.js";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+//#region src/tui/backends/embedded-drafts.ts
+init_paths();
+/** Draft files are private client state, never session/transcript rows. */
+var TuiDraftFileStore = class {
+	constructor(directory = join(resolveStateDir(), "client-drafts", "embedded")) {
+		this.directory = directory;
+	}
+	path(id) {
+		if (!/^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(id)) throw new Error("Invalid conversation UUID");
+		return join(this.directory, `${id}.json`);
+	}
+	read(id) {
+		if (!/^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(id)) return void 0;
+		try {
+			return JSON.parse(readFileSync(this.path(id), "utf8"));
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+	}
+	save(id, draft) {
+		const path = this.path(id);
+		mkdirSync(this.directory, {
+			recursive: true,
+			mode: 448
+		});
+		const temporary = `${path}.${randomUUID()}.tmp`;
+		try {
+			writeFileSync(temporary, JSON.stringify(draft), { mode: 384 });
+			renameSync(temporary, path);
+		} finally {
+			try {
+				unlinkSync(temporary);
+			} catch (error) {
+				if (error.code !== "ENOENT") throw error;
+			}
+		}
+	}
+	remove(id) {
+		try {
+			unlinkSync(this.path(id));
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+	}
+};
+var EmbeddedDraftStore = class extends TuiDraftFileStore {};
+//#endregion
+export { EmbeddedDraftStore, TuiDraftFileStore };

package/dist/src/tui/backends/gateway-realtime-backend.d.ts

@@ -23,6 +23,10 @@ export declare class GatewayRealtimeBackend implements TuiBackend {
     private activeRunId;
     private observedConversationId;
     private chatAbort;
+    private readonly drafts;
+    private readonly pendingInputs;
+    private draftDirectory?;
+    private draftInitialization?;
     onEvent?: (evt: TuiEvent) => void;
     onConnected?: () => void;
     onDisconnected?: (reason: string) => void;
@@ -32,11 +36,17 @@ export declare class GatewayRealtimeBackend implements TuiBackend {
     }) => void;
     constructor(opts: GatewayRealtimeOptions);
     get connectionLabel(): string;
+    getComposerDraftDirectory(): Promise<string>;
+    private initializeDrafts;
+    private persistDraft;
     start(): void;
     stop(): void;
     getActiveSignal(): AbortSignal | undefined;
     getComposerInputHistory(): Promise<TuiComposerHistoryItem[]>;
     recordComposerInputHistory(text: string): Promise<TuiComposerHistoryItem>;
+    private acceptReceipt;
+    private reconcileInput;
+    private prepareInput;
     sendChat(opts: ChatSendOptions): Promise<{
         runId: string;
     }>;