@xopcai/xopc 0.0.333 → 0.0.334

package/dist/src/providers/register-runtime-providers.js

@@ -1,6 +1,6 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
-import { getOAuthProviderDefinition, init_registry } from "../auth/oauth/registry.js";
 import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
+import { getOAuthProviderDefinition, init_registry } from "../auth/oauth/registry.js";
 import { XOPC_CLOUD_PROVIDER_ID, init_xopc_cloud_config, resolveXopcModelRouterUrl } from "./xopc-cloud-config.js";
 //#region src/providers/register-runtime-providers.ts
 function registerRuntimeProvider(modelRuntime, source) {

package/dist/src/session/store.js

@@ -794,7 +794,6 @@ var SessionStore = class {
 				customData: {
 					...sourceMetadata.customData ?? {},
 					...options.targetMetadata.customData ?? {},
-					genericNewChatShell: false,
 					forkedFromConversationId: sourceKey,
 					forkedFromTranscriptId: sourceMetadata.transcriptId,
 					forkedFromSessionName: sourceMetadata.name,

package/dist/src/storage/sqlite/migrations/223_session_creation_receipts.sql

@@ -0,0 +1,59 @@
+UPDATE sessions SET custom_data_json=json_remove(custom_data_json, '$.genericNewChatShell')
+WHERE json_type(custom_data_json, '$.genericNewChatShell') IS NOT NULL;
+
+CREATE TABLE session_input_receipts (
+  conversation_id TEXT NOT NULL,
+  client_message_id TEXT NOT NULL,
+  principal_id TEXT NOT NULL,
+  request_hash TEXT NOT NULL,
+  input_id TEXT,
+  transcript_id TEXT NOT NULL,
+  accepted_at INTEGER NOT NULL,
+  PRIMARY KEY (conversation_id, client_message_id)
+);
+
+CREATE TABLE session_tombstones (
+  conversation_id TEXT PRIMARY KEY,
+  deleted_at INTEGER NOT NULL
+);
+
+CREATE TABLE session_preparation_retries (
+  conversation_id TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  operation_id TEXT NOT NULL,
+  expected_revision INTEGER NOT NULL,
+  principal_id TEXT NOT NULL,
+  PRIMARY KEY (conversation_id, idempotency_key)
+);
+
+CREATE TABLE session_preparations (
+  conversation_id TEXT PRIMARY KEY REFERENCES sessions(conversation_id) ON DELETE CASCADE,
+  operation_id TEXT NOT NULL UNIQUE,
+  creation_json TEXT NOT NULL CHECK(json_valid(creation_json)),
+  state TEXT NOT NULL CHECK(state IN ('preparing', 'ready', 'preparation_failed')),
+  environment_id TEXT NOT NULL,
+  base_commit TEXT,
+  revision INTEGER NOT NULL DEFAULT 1,
+  lease_until INTEGER NOT NULL DEFAULT 0,
+  last_error TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE session_preparation_cleanup (
+  environment_id TEXT PRIMARY KEY,
+  conversation_id TEXT NOT NULL,
+  not_before INTEGER NOT NULL,
+  last_error TEXT
+);
+
+CREATE TRIGGER session_creation_tombstone BEFORE DELETE ON sessions BEGIN
+  INSERT INTO session_tombstones(conversation_id, deleted_at)
+  VALUES (OLD.conversation_id, CAST(unixepoch('subsec') * 1000 AS INTEGER))
+  ON CONFLICT(conversation_id) DO NOTHING;
+  INSERT INTO session_preparation_cleanup(environment_id, conversation_id, not_before)
+  SELECT environment_id, conversation_id, max(lease_until, CAST(unixepoch('subsec') * 1000 AS INTEGER)) + 5000
+  FROM session_preparations WHERE conversation_id=OLD.conversation_id
+    AND json_extract(creation_json, '$.execution.mode')='managed_worktree'
+  ON CONFLICT(environment_id) DO NOTHING;
+END;

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 222;
+export declare const XOPC_DB_SCHEMA_VERSION = 223;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -57,7 +57,7 @@ function applySingleMigration(db, migration, discardOldScenes = false) {
 */
 function applyPendingMigrations(db, options = {}) {
 	db.function("xopc_operation_id", () => currentOperationId() ?? null);
-	const targetVersion = options.targetVersion ?? 222;
+	const targetVersion = options.targetVersion ?? 223;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (!options.migrationsDir && currentVersion < 165) throw new DatabaseSchemaTooOldError(currentVersion, 165);
@@ -95,7 +95,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 222;
+	const appVersion = options.targetVersion ?? 223;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,
@@ -137,7 +137,7 @@ var init_runner = __esmMin((() => {
 	init_errors();
 	log = createLogger("Sqlite:Migrations");
 	XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
-	XOPC_DB_SCHEMA_VERSION = 222;
+	XOPC_DB_SCHEMA_VERSION = 223;
 }));
 //#endregion
 init_runner();

package/dist/src/storage/sqlite/schema.js

@@ -28,7 +28,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 165;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 222,
+		targetVersion: 223,
 		databasePath: fresh ? void 0 : options.databasePath
 	});
 }

package/dist/src/storage/sqlite/session-creation-repository.d.ts

@@ -0,0 +1,50 @@
+import { type SessionCreation, type SessionInputCommand, type SessionMaterializeCommand, type SessionPreparationState } from '@xopcai/gateway-contract';
+import type { SessionAgentConfig } from '../../session/config-types.js';
+import { insertSessionInput } from './session-input-repository.js';
+export declare class SessionCommandError extends Error {
+    readonly code: 'IDEMPOTENCY_CONFLICT' | 'CONVERSATION_EXISTS' | 'SESSION_DELETED' | 'FORBIDDEN' | 'SESSION_CHANGED' | 'CONFIG_CHANGED' | 'NOT_FOUND' | 'BAD_REQUEST' | 'SESSION_BUSY' | 'QUEUE_FULL';
+    constructor(code: 'IDEMPOTENCY_CONFLICT' | 'CONVERSATION_EXISTS' | 'SESSION_DELETED' | 'FORBIDDEN' | 'SESSION_CHANGED' | 'CONFIG_CHANGED' | 'NOT_FOUND' | 'BAD_REQUEST' | 'SESSION_BUSY' | 'QUEUE_FULL', message: string);
+}
+export type SessionInputReceipt = {
+    conversationId: string;
+    clientMessageId: string;
+    principalId: string;
+    requestHash: string;
+    inputId: string | null;
+    transcriptId: string;
+    acceptedAt: number;
+};
+export type SessionPreparation = {
+    conversationId: string;
+    operationId: string;
+    creation: SessionCreation;
+    state: SessionPreparationState;
+    environmentId: string;
+    baseCommit: string | null;
+    revision: number;
+    leaseUntil: number;
+    lastError: string | null;
+};
+export declare function sessionCommandHash(command: SessionInputCommand | SessionMaterializeCommand): string;
+export declare function isConversationDeleted(conversationId: string): boolean;
+export declare function getSessionInputReceipt(conversationId: string, clientMessageId: string, principalId: string): SessionInputReceipt | undefined;
+export declare function matchSessionInputReceipt(conversationId: string, clientMessageId: string, principalId: string, hash: string): SessionInputReceipt | undefined;
+export declare function getSessionPreparation(conversationId: string): SessionPreparation | undefined;
+/** Commit the identity, configuration, input and replay receipt together. All preparation happens before entry. */
+export declare function acceptSessionCommand(input: {
+    conversationId: string;
+    principalId: string;
+    command: SessionInputCommand | SessionMaterializeCommand;
+    preparedInput?: Omit<Parameters<typeof insertSessionInput>[0], 'conversationId' | 'id' | 'clientMessageId' | 'expectedTranscriptId'>;
+    config?: SessionAgentConfig;
+    sourceChannel?: 'webchat' | 'tui';
+    attachProject?: (conversationId: string, projectId: string) => void;
+}): SessionInputReceipt;
+export declare function claimSessionPreparation(conversationId: string, now?: number): SessionPreparation | undefined;
+export declare function finishSessionPreparation(operation: SessionPreparation, error?: string): boolean;
+export declare function pendingSessionPreparations(): string[];
+export declare function retrySessionPreparation(conversationId: string, principalId: string, input: {
+    operationId: string;
+    expectedRevision: number;
+    idempotencyKey: string;
+}): SessionPreparation;

package/dist/src/storage/sqlite/session-creation-repository.js

@@ -0,0 +1,166 @@
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "./transaction.js";
+import { sessionCommandIdentity } from "../../../packages/gateway-contract/src/session-input-command.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { init_session_input_repository, insertSessionInput } from "./session-input-repository.js";
+import { init_clarification_wait_repository, supersedeActiveClarification } from "./clarification-wait-repository.js";
+import { init_connection_wait_repository, invalidateConnectionResumeIntent } from "./connection-wait-repository.js";
+import { getSessionMetadata } from "./session-read-repository.js";
+import { init_session_repository } from "./session-repository.js";
+import { init_config_repository, setSessionConfig } from "./config-repository.js";
+import { createConversation, init_conversation_repository } from "./conversation-repository.js";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/storage/sqlite/session-creation-repository.ts
+init_src();
+init_conversation_repository();
+init_config_repository();
+init_session_repository();
+init_session_input_repository();
+init_connection_wait_repository();
+init_clarification_wait_repository();
+init_transaction();
+var SessionCommandError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+function sessionCommandHash(command) {
+	return createHash("sha256").update(sessionCommandIdentity(command)).digest("hex");
+}
+function isConversationDeleted(conversationId) {
+	return Boolean(getSqliteDatabase().prepare("SELECT 1 FROM session_tombstones WHERE conversation_id=?").get(conversationId));
+}
+function getSessionInputReceipt(conversationId, clientMessageId, principalId) {
+	const row = getSqliteDatabase().prepare(`SELECT conversation_id AS conversationId, client_message_id AS clientMessageId,
+    principal_id AS principalId, request_hash AS requestHash, input_id AS inputId,
+    transcript_id AS transcriptId, accepted_at AS acceptedAt FROM session_input_receipts
+    WHERE conversation_id=? AND client_message_id=?`).get(conversationId, clientMessageId);
+	if (row && row.principalId !== principalId) throw new SessionCommandError("FORBIDDEN", "Input belongs to another principal");
+	return row;
+}
+function matchSessionInputReceipt(conversationId, clientMessageId, principalId, hash) {
+	const receipt = getSessionInputReceipt(conversationId, clientMessageId, principalId);
+	if (receipt && receipt.requestHash !== hash) throw new SessionCommandError("IDEMPOTENCY_CONFLICT", "Input identity was reused with different content");
+	if (isConversationDeleted(conversationId)) throw new SessionCommandError("SESSION_DELETED", "Conversation was deleted");
+	return receipt;
+}
+function getSessionPreparation(conversationId) {
+	const row = getSqliteDatabase().prepare(`SELECT conversation_id AS conversationId, operation_id AS operationId,
+    creation_json AS creationJson, state, environment_id AS environmentId, base_commit AS baseCommit,
+    revision, lease_until AS leaseUntil, last_error AS lastError FROM session_preparations WHERE conversation_id=?`).get(conversationId);
+	if (!row) return void 0;
+	const { creationJson, ...rest } = row;
+	return {
+		...rest,
+		creation: JSON.parse(creationJson)
+	};
+}
+/** Commit the identity, configuration, input and replay receipt together. All preparation happens before entry. */
+function acceptSessionCommand(input) {
+	return runSqliteWriteTransaction((db) => {
+		const { conversationId, command, principalId } = input;
+		const clientMessageId = "commandId" in command ? command.commandId : command.clientMessageId;
+		const requestHash = sessionCommandHash(command);
+		const existing = matchSessionInputReceipt(conversationId, clientMessageId, principalId, requestHash);
+		if (existing) return existing;
+		if ("input" in command !== Boolean(input.preparedInput)) throw new SessionCommandError("BAD_REQUEST", "Prepared input is required for input commands only");
+		const pending = db.prepare(`SELECT count(*) AS count FROM session_inputs WHERE conversation_id=?
+      AND status IN ('queued','running','injecting','interrupted')`).get(conversationId);
+		if (input.preparedInput && pending.count >= 10) throw new SessionCommandError("QUEUE_FULL", "Input queue is full");
+		const creation = "creation" in command ? command.creation : void 0;
+		let session = getSessionMetadata(conversationId);
+		if (creation) {
+			if (session) throw new SessionCommandError("CONVERSATION_EXISTS", "Conversation already exists");
+			session = createConversation({
+				agentId: creation.agentId,
+				sourceChannel: input.sourceChannel ?? "webchat",
+				sourceChatId: conversationId,
+				sessionType: "chat",
+				hiddenFromSessionList: !input.preparedInput,
+				routing: {
+					agentId: creation.agentId,
+					source: input.sourceChannel ?? "webchat",
+					accountId: "default",
+					peerKind: "direct",
+					peerId: conversationId
+				}
+			}, "", conversationId);
+			setSessionConfig(conversationId, input.config ?? {
+				modelOverride: creation.model,
+				fixedModel: true,
+				thinkingLevel: creation.thinkingLevel,
+				userContextMode: creation.temporary ? "temporary" : "enabled"
+			}, "");
+			if (creation.projectId) {
+				if (!input.attachProject) throw new Error("Project attachment is required");
+				input.attachProject(conversationId, creation.projectId);
+			}
+			if (creation.execution) db.prepare(`INSERT INTO session_preparations
+        (conversation_id,operation_id,creation_json,state,environment_id,created_at,updated_at)
+        VALUES (?,?,?,'preparing',?,?,?)`).run(conversationId, randomUUID(), JSON.stringify(creation), randomUUID(), Date.now(), Date.now());
+		} else {
+			if (!session) throw new SessionCommandError("NOT_FOUND", "Conversation not found");
+			if (!("kind" in command) || command.kind !== "append" || command.expectedTranscriptId !== session.transcriptId) throw new SessionCommandError("SESSION_CHANGED", "Conversation transcript changed");
+			if ((db.prepare("SELECT updated_at FROM session_config WHERE conversation_id=?").get(conversationId)?.updated_at ?? 0) !== command.configVersion) throw new SessionCommandError("CONFIG_CHANGED", "Model configuration changed");
+		}
+		const transcriptId = session.transcriptId;
+		const inputId = input.preparedInput ? randomUUID() : null;
+		if (input.preparedInput && inputId) insertSessionInput({
+			...input.preparedInput,
+			conversationId,
+			id: inputId,
+			clientMessageId,
+			expectedTranscriptId: transcriptId
+		});
+		if (inputId) {
+			invalidateConnectionResumeIntent(conversationId);
+			supersedeActiveClarification(conversationId);
+		}
+		const receipt = {
+			conversationId,
+			clientMessageId,
+			principalId,
+			requestHash,
+			inputId,
+			transcriptId,
+			acceptedAt: Date.now()
+		};
+		db.prepare(`INSERT INTO session_input_receipts
+      (conversation_id,client_message_id,principal_id,request_hash,input_id,transcript_id,accepted_at)
+      VALUES (?,?,?,?,?,?,?)`).run(conversationId, clientMessageId, principalId, requestHash, inputId, transcriptId, receipt.acceptedAt);
+		return receipt;
+	});
+}
+function claimSessionPreparation(conversationId, now = Date.now()) {
+	return runSqliteWriteTransaction((db) => {
+		return db.prepare(`UPDATE session_preparations SET lease_until=?,revision=revision+1,updated_at=?
+      WHERE conversation_id=? AND state='preparing' AND lease_until<=?`).run(now + 6e4, now, conversationId, now).changes ? getSessionPreparation(conversationId) : void 0;
+	});
+}
+function finishSessionPreparation(operation, error) {
+	return runSqliteWriteTransaction((db) => Boolean(db.prepare(`UPDATE session_preparations
+    SET state=?,last_error=?,lease_until=0,revision=revision+1,updated_at=?
+    WHERE conversation_id=? AND operation_id=? AND revision=? AND state='preparing'`).run(error ? "preparation_failed" : "ready", error ?? null, Date.now(), operation.conversationId, operation.operationId, operation.revision).changes));
+}
+function pendingSessionPreparations() {
+	return getSqliteDatabase().prepare("SELECT conversation_id FROM session_preparations WHERE state='preparing' AND lease_until<=?").all(Date.now()).map((row) => row.conversation_id);
+}
+function retrySessionPreparation(conversationId, principalId, input) {
+	return runSqliteWriteTransaction((db) => {
+		if (isConversationDeleted(conversationId)) throw new SessionCommandError("SESSION_DELETED", "Conversation was deleted");
+		const operation = getSessionPreparation(conversationId);
+		if (!operation) throw new SessionCommandError("NOT_FOUND", "Preparation not found");
+		if (db.prepare("SELECT principal_id FROM session_input_receipts WHERE conversation_id=? ORDER BY accepted_at LIMIT 1").get(conversationId)?.principal_id !== principalId) throw new SessionCommandError("FORBIDDEN", "Preparation belongs to another principal");
+		const previous = db.prepare("SELECT * FROM session_preparation_retries WHERE conversation_id=? AND idempotency_key=?").get(conversationId, input.idempotencyKey);
+		if (previous) {
+			if (previous.operation_id !== input.operationId || previous.expected_revision !== input.expectedRevision || previous.principal_id !== principalId) throw new SessionCommandError("IDEMPOTENCY_CONFLICT", "Retry identity was reused");
+			return operation;
+		}
+		if (!db.prepare(`UPDATE session_preparations SET state='preparing', revision=revision+1,
+      lease_until=0,last_error=NULL,updated_at=? WHERE conversation_id=? AND operation_id=? AND revision=? AND state='preparation_failed'`).run(Date.now(), conversationId, input.operationId, input.expectedRevision).changes) throw new SessionCommandError("SESSION_CHANGED", "Preparation state changed");
+		db.prepare("INSERT INTO session_preparation_retries VALUES (?,?,?,?,?)").run(conversationId, input.idempotencyKey, input.operationId, input.expectedRevision, principalId);
+		return getSessionPreparation(conversationId);
+	});
+}
+//#endregion
+export { SessionCommandError, acceptSessionCommand, claimSessionPreparation, finishSessionPreparation, getSessionInputReceipt, getSessionPreparation, isConversationDeleted, matchSessionInputReceipt, pendingSessionPreparations, retrySessionPreparation, sessionCommandHash };

package/dist/src/storage/sqlite/session-input-repository.d.ts

@@ -1,5 +1,6 @@
 import { getSqliteDatabase } from './transaction.js';
 import { type TurnOrigin } from '@xopcai/endpoint-tools-protocol';
+import type { SessionPreparationView } from '@xopcai/gateway-contract';
 import type { AgentSourceContext, SourceContextRefSummary } from '../../agent/source-context/types.js';
 export type SessionInputDelivery = 'next' | 'steer';
 export type SessionInputStatus = 'queued' | 'running' | 'injecting' | 'completed' | 'cancelled' | 'failed' | 'interrupted' | 'suspended';
@@ -38,6 +39,7 @@ export type SessionInput = {
     updatedAtMs: number;
 };
 export type SessionInputState = {
+    preparation?: SessionPreparationView;
     conversationId: string;
     revision: number;
     activeRunId?: string;
@@ -83,8 +85,8 @@ export declare function insertSessionInput(input: {
     origin: TurnOrigin;
     targetRunId?: string;
 }): SessionInput;
-export declare function claimNextSessionInput(conversationId: string, runId: string): SessionInput | undefined;
-export declare function finishSessionInputRun(conversationId: string, runId: string, status: 'completed' | 'failed' | 'cancelled' | 'suspended', error?: string): boolean;
+export declare function claimNextSessionInput(conversationId: string, runId: string, expectedInputId?: string): SessionInput | undefined;
+export declare function finishSessionInputRun(conversationId: string, runId: string, status: 'completed' | 'failed' | 'cancelled' | 'suspended' | 'interrupted', error?: string): boolean;
 export declare function setSessionInputStatus(id: string, status: SessionInputStatus, patch?: {
     effectiveDelivery?: SessionInputDelivery;
     targetRunId?: string | null;

package/dist/src/storage/sqlite/session-input-repository.js

@@ -42,12 +42,14 @@ function bumpSessionInputRevision(db, conversationId) {
 }
 function getSessionInputState(conversationId) {
 	const db = getSqliteDatabase();
+	const preparation = db.prepare("SELECT operation_id AS operationId, revision, state, last_error AS lastError FROM session_preparations WHERE conversation_id=?").get(conversationId);
 	const runtime = db.prepare(`SELECT revision, active_run_id, active_input_id
     FROM session_input_runtime WHERE conversation_id = ?`).get(conversationId);
 	const rows = db.prepare(`${SELECT_INPUTS} WHERE conversation_id = ? AND status IN
     ('queued','running','injecting','interrupted') ORDER BY position, created_at_ms, id`).all(conversationId);
 	return {
 		conversationId,
+		...preparation ? { preparation } : {},
 		revision: runtime?.revision ?? 0,
 		activeRunId: runtime?.active_run_id ?? void 0,
 		activeInputId: runtime?.active_input_id ?? void 0,
@@ -107,8 +109,11 @@ function insertSessionInput(input) {
 		return mapInput(db.prepare(`${SELECT_INPUTS} WHERE id = ?`).get(input.id));
 	});
 }
-function claimNextSessionInput(conversationId, runId) {
+function claimNextSessionInput(conversationId, runId, expectedInputId) {
 	return runSqliteWriteTransaction((db) => {
+		const preparation = db.prepare("SELECT state FROM session_preparations WHERE conversation_id=?").get(conversationId);
+		if (preparation && preparation.state !== "ready") return void 0;
+		if (db.prepare("SELECT 1 FROM session_tombstones WHERE conversation_id=?").get(conversationId)) return void 0;
 		ensureRuntime(db, conversationId);
 		if (db.prepare(`SELECT active_run_id FROM session_input_runtime WHERE conversation_id = ?`).get(conversationId).active_run_id) return void 0;
 		if (db.prepare(`UPDATE session_inputs SET status = 'interrupted', error = 'Session changed before delivery',
@@ -117,6 +122,7 @@ function claimNextSessionInput(conversationId, runId) {
 		const row = db.prepare(`${SELECT_INPUTS} WHERE conversation_id = ? AND effective_delivery = 'next'
       AND status = 'queued' ORDER BY position, created_at_ms, id LIMIT 1`).get(conversationId);
 		if (!row) return void 0;
+		if (expectedInputId && row.id !== expectedInputId) return void 0;
 		const now = Date.now();
 		db.prepare(`UPDATE session_inputs SET status = 'running', run_id = ?, version = version + 1,
       updated_at_ms = ? WHERE id = ?`).run(runId, now, row.id);

package/dist/src/tasks/capabilities/read.js

@@ -2,10 +2,10 @@ import { ProductReadContracts } from "../../../packages/gateway-contract/src/cap
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { TaskRepository, init_task_repository } from "../task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "../task-run-repository.js";
-import { TaskConversationRepository } from "../task-conversation-repository.js";
-import { TaskReadModelProjector } from "../task-read-model-projector.js";
 import { CapabilityError } from "../../capabilities/runtime/errors.js";
 import { defineReadCapability } from "../../capabilities/runtime/dispatcher.js";
+import { TaskConversationRepository } from "../task-conversation-repository.js";
+import { TaskReadModelProjector } from "../task-read-model-projector.js";
 import { TaskContextRepository } from "../task-context-repository.js";
 import { TaskDependencyService } from "../task-dependency-service.js";
 import { TaskValueMetricsService } from "../task-value-metrics-service.js";

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>;