@xopcai/xopc 0.0.285 → 0.0.291

package/dist/src/storage/sqlite/clarification-wait-repository.js

@@ -1,17 +1,22 @@
-import { isXopcDatabaseOpen } from "./connection.js";
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { readCurrentSessionId } from "./session-instance-repository.js";
-import { bumpSessionInputRevision, getSessionInputById, getSessionInputState, insertSessionInput } from "./session-input-repository.js";
-import { TaskRunRepository } from "../../tasks/task-run-repository.js";
+import { init_connection, isXopcDatabaseOpen } from "./connection.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "./transaction.js";
+import { init_session_instance_repository, readCurrentTranscriptId } from "./session-instance-repository.js";
+import { bumpSessionInputRevision, getSessionInputById, getSessionInputState, init_session_input_repository, insertSessionInput } from "./session-input-repository.js";
+import { TaskRunRepository, init_task_run_repository } from "../../tasks/task-run-repository.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/clarification-wait-repository.ts
+init_task_run_repository();
+init_connection();
+init_session_instance_repository();
+init_session_input_repository();
+init_transaction();
 const APPROVAL_TTL_MS = 10 * 6e4;
 const STALE_CONTEXT_MS = 1440 * 6e4;
 function rowToWait(row) {
 	return JSON.parse(row.data_json);
 }
 function getRow(id) {
-	return getSqliteDatabase().prepare(`SELECT id, session_key, session_id, status, version, data_json
+	return getSqliteDatabase().prepare(`SELECT id, conversation_id, transcript_id, status, version, data_json
      FROM session_clarification_waits WHERE id = ?`).get(id);
 }
 function writeWait(wait, expectedVersion) {
@@ -104,26 +109,26 @@ function getClarification(id) {
 	const row = getRow(id);
 	return row ? rowToWait(row) : void 0;
 }
-function getActiveClarification(sessionKey) {
+function getActiveClarification(conversationId) {
 	if (!isXopcDatabaseOpen()) return void 0;
-	const sessionId = readCurrentSessionId(getSqliteDatabase(), sessionKey);
-	if (!sessionId) return void 0;
-	const row = getSqliteDatabase().prepare(`SELECT id, session_key, session_id, status, version, data_json
+	const transcriptId = readCurrentTranscriptId(getSqliteDatabase(), conversationId);
+	if (!transcriptId) return void 0;
+	const row = getSqliteDatabase().prepare(`SELECT id, conversation_id, transcript_id, status, version, data_json
      FROM session_clarification_waits
-     WHERE session_key = ? AND session_id = ? AND status IN ('open', 'queued')
-     ORDER BY version DESC LIMIT 1`).get(sessionKey, sessionId);
+     WHERE conversation_id = ? AND transcript_id = ? AND status IN ('open', 'queued')
+     ORDER BY version DESC LIMIT 1`).get(conversationId, transcriptId);
 	return row ? rowToWait(row) : void 0;
 }
-function getClarificationSnapshot(sessionKey) {
+function getClarificationSnapshot(conversationId) {
 	if (!isXopcDatabaseOpen()) return void 0;
-	const sessionId = readCurrentSessionId(getSqliteDatabase(), sessionKey);
-	if (!sessionId) return void 0;
-	const state = getSessionInputState(sessionKey);
+	const transcriptId = readCurrentTranscriptId(getSqliteDatabase(), conversationId);
+	if (!transcriptId) return void 0;
+	const state = getSessionInputState(conversationId);
 	const now = Date.now();
-	const active = getActiveClarification(sessionKey);
+	const active = getActiveClarification(conversationId);
 	const clarification = active?.kind === "approval" && active.expiresAt !== void 0 && active.expiresAt <= now ? expireApproval(active, now) : active;
 	return {
-		sessionId,
+		transcriptId,
 		revision: state.revision,
 		serverTime: now,
 		clarification: clarification?.status === "open" || clarification?.status === "queued" ? clarification : null
@@ -131,16 +136,16 @@ function getClarificationSnapshot(sessionKey) {
 }
 function createClarificationWait(input) {
 	return runSqliteWriteTransaction((db) => {
-		const sessionId = readCurrentSessionId(db, input.sessionKey);
-		if (!sessionId) throw new Error("Clarification requires a persisted session.");
-		const duplicate = db.prepare(`SELECT id, session_key, session_id, status, version, data_json
+		const transcriptId = readCurrentTranscriptId(db, input.conversationId);
+		if (!transcriptId) throw new Error("Clarification requires a persisted session.");
+		const duplicate = db.prepare(`SELECT id, conversation_id, transcript_id, status, version, data_json
        FROM session_clarification_waits
-       WHERE session_id = ? AND origin_run_id = ? AND origin_tool_call_id = ?`).get(sessionId, input.runId, input.toolCallId);
+       WHERE transcript_id = ? AND origin_run_id = ? AND origin_tool_call_id = ?`).get(transcriptId, input.runId, input.toolCallId);
 		if (duplicate) return rowToWait(duplicate);
 		const now = input.now ?? Date.now();
-		const runtime = getSessionInputState(input.sessionKey);
-		const origin = runtime.activeInputId ? getSessionInputById(input.sessionKey, runtime.activeInputId) : void 0;
-		const active = getActiveClarification(input.sessionKey);
+		const runtime = getSessionInputState(input.conversationId);
+		const origin = runtime.activeInputId ? getSessionInputById(input.conversationId, runtime.activeInputId) : void 0;
+		const active = getActiveClarification(input.conversationId);
 		if (active) {
 			writeWait({
 				...active,
@@ -152,12 +157,12 @@ function createClarificationWait(input) {
 			resolveTaskWait(active, { superseded: true });
 			cancelTaskRun(active, "Task superseded by a newer clarification request.", now);
 		}
-		const lastEntry = db.prepare("SELECT entry_id FROM transcript_entries WHERE session_id = ? ORDER BY seq DESC LIMIT 1").get(sessionId);
+		const lastEntry = db.prepare("SELECT entry_id FROM transcript_entries WHERE transcript_id = ? ORDER BY seq DESC LIMIT 1").get(transcriptId);
 		const wait = {
 			id: randomUUID(),
 			principalId: "local-owner",
-			sessionKey: input.sessionKey,
-			sessionId,
+			conversationId: input.conversationId,
+			transcriptId,
 			objectiveId: origin?.id ?? input.runId,
 			objectiveRevision: (active?.objectiveRevision ?? 0) + 1,
 			originRunId: input.runId,
@@ -183,16 +188,16 @@ function createClarificationWait(input) {
 			updatedAt: now
 		};
 		db.prepare(`INSERT INTO session_clarification_waits (
-        id, principal_id, session_key, session_id, status, version, data_json,
+        id, principal_id, conversation_id, transcript_id, status, version, data_json,
         origin_run_id, origin_tool_call_id
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(wait.id, wait.principalId, wait.sessionKey, wait.sessionId, wait.status, wait.version, JSON.stringify(wait), wait.originRunId, wait.originToolCallId);
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(wait.id, wait.principalId, wait.conversationId, wait.transcriptId, wait.status, wait.version, JSON.stringify(wait), wait.originRunId, wait.originToolCallId);
 		markTaskWaiting(wait);
-		bumpSessionInputRevision(db, input.sessionKey);
+		bumpSessionInputRevision(db, input.conversationId);
 		return wait;
 	});
 }
-function isClarificationSuspended(sessionKey, runId) {
-	const wait = getActiveClarification(sessionKey);
+function isClarificationSuspended(conversationId, runId) {
+	const wait = getActiveClarification(conversationId);
 	return Boolean(wait?.status === "open" && wait.originRunId === runId);
 }
 function expireApproval(wait, now) {
@@ -206,13 +211,13 @@ function expireApproval(wait, now) {
 	const updated = writeWait(expired, wait.version) ?? getClarification(wait.id) ?? expired;
 	resolveTaskWait(updated, { expired: true });
 	cancelTaskRun(updated, "Approval expired before the task could continue.", now);
-	bumpSessionInputRevision(getSqliteDatabase(), wait.sessionKey);
+	bumpSessionInputRevision(getSqliteDatabase(), wait.conversationId);
 	return updated;
 }
 function resolveClarification(input) {
 	return runSqliteWriteTransaction((db) => {
 		const wait = getClarification(input.id);
-		if (!wait || readCurrentSessionId(db, wait.sessionKey) !== wait.sessionId) return {
+		if (!wait || readCurrentTranscriptId(db, wait.conversationId) !== wait.transcriptId) return {
 			ok: false,
 			code: "NOT_FOUND"
 		};
@@ -222,7 +227,7 @@ function resolveClarification(input) {
 			code: "EXPIRED",
 			clarification: expireApproval(wait, now)
 		};
-		if (db.prepare("SELECT id FROM session_inputs WHERE session_key = ? AND client_message_id = ?").get(wait.sessionKey, input.idempotencyKey)) return {
+		if (db.prepare("SELECT id FROM session_inputs WHERE conversation_id = ? AND client_message_id = ?").get(wait.conversationId, input.idempotencyKey)) return {
 			ok: true,
 			clarification: wait,
 			idempotent: true,
@@ -265,7 +270,7 @@ function resolveClarification(input) {
 			};
 			resolveTaskWait(cancelled, { cancelled: true });
 			cancelTaskRun(cancelled, "Task cancelled while waiting for clarification.", now);
-			bumpSessionInputRevision(db, wait.sessionKey);
+			bumpSessionInputRevision(db, wait.conversationId);
 			return {
 				ok: true,
 				clarification: cancelled,
@@ -296,11 +301,11 @@ function resolveClarification(input) {
 			stale ? "The request is over 24 hours old. Re-check mutable state before acting." : "",
 			"Do not repeat completed side effects. Continue from the stored transcript and current state."
 		].filter(Boolean).join("\n");
-		const origin = getSessionInputById(wait.sessionKey, wait.originInputId);
+		const origin = getSessionInputById(wait.conversationId, wait.originInputId);
 		insertSessionInput({
 			id: randomUUID(),
-			sessionKey: wait.sessionKey,
-			expectedSessionId: wait.sessionId,
+			conversationId: wait.conversationId,
+			expectedTranscriptId: wait.transcriptId,
 			clientMessageId: input.idempotencyKey,
 			requestedDelivery: "next",
 			effectiveDelivery: "next",
@@ -329,11 +334,11 @@ function resolveClarification(input) {
 		};
 	});
 }
-function getClarificationResumeInput(sessionKey, runId) {
+function getClarificationResumeInput(conversationId, runId) {
 	if (!isXopcDatabaseOpen()) return void 0;
-	const state = getSessionInputState(sessionKey);
+	const state = getSessionInputState(conversationId);
 	if (state.activeRunId !== runId || !state.activeInputId) return void 0;
-	const input = getSessionInputById(sessionKey, state.activeInputId);
+	const input = getSessionInputById(conversationId, state.activeInputId);
 	return input?.kind === "clarification_resume" ? input : void 0;
 }
 function consumeClarificationResume(input) {
@@ -341,7 +346,7 @@ function consumeClarificationResume(input) {
 	return runSqliteWriteTransaction((db) => {
 		const wait = input.payload ? getClarification(input.payload.waitId) : void 0;
 		if (!wait || wait.status !== "queued" || wait.objectiveRevision !== input.payload?.objectiveRevision) return false;
-		if (readCurrentSessionId(db, input.sessionKey) !== wait.sessionId) return false;
+		if (readCurrentTranscriptId(db, input.conversationId) !== wait.transcriptId) return false;
 		if (wait.taskRunId) {
 			const runs = new TaskRunRepository();
 			const run = runs.get(wait.taskRunId);
@@ -368,15 +373,15 @@ function consumeClarificationResume(input) {
 			resolvedAt: Date.now(),
 			updatedAt: Date.now()
 		}, wait.version)) return false;
-		bumpSessionInputRevision(db, wait.sessionKey);
+		bumpSessionInputRevision(db, wait.conversationId);
 		return true;
 	});
 }
-function consumeClarificationApproval(sessionKey, approvalKey) {
+function consumeClarificationApproval(conversationId, approvalKey) {
 	return runSqliteWriteTransaction(() => {
-		const state = getSessionInputState(sessionKey);
+		const state = getSessionInputState(conversationId);
 		if (!state.activeInputId) return void 0;
-		const input = getSessionInputById(sessionKey, state.activeInputId);
+		const input = getSessionInputById(conversationId, state.activeInputId);
 		if (input?.kind !== "clarification_resume" || !input.payload) return void 0;
 		const wait = getClarification(input.payload.waitId);
 		if (!wait || wait.kind !== "approval" || wait.approvalKey !== approvalKey || wait.approvalConsumedAt) return;
@@ -389,14 +394,14 @@ function consumeClarificationApproval(sessionKey, approvalKey) {
 		return approved ? "approved" : "denied";
 	});
 }
-function supersedeActiveClarification(sessionKey, now = Date.now()) {
+function supersedeActiveClarification(conversationId, now = Date.now()) {
 	return runSqliteWriteTransaction((db) => {
-		const wait = getActiveClarification(sessionKey);
+		const wait = getActiveClarification(conversationId);
 		if (!wait) return void 0;
 		if (wait.status === "queued") {
 			const queued = db.prepare(`SELECT id FROM session_inputs
-         WHERE session_key = ? AND kind = 'clarification_resume'
-           AND status = 'queued' AND json_extract(payload_json, '$.waitId') = ?`).get(sessionKey, wait.id);
+         WHERE conversation_id = ? AND kind = 'clarification_resume'
+           AND status = 'queued' AND json_extract(payload_json, '$.waitId') = ?`).get(conversationId, wait.id);
 			if (queued) db.prepare(`UPDATE session_inputs SET status = 'cancelled', version = version + 1, updated_at_ms = ?
            WHERE id = ? AND status = 'queued'`).run(now, queued.id);
 		}
@@ -410,7 +415,7 @@ function supersedeActiveClarification(sessionKey, now = Date.now()) {
 		if (!updated) return void 0;
 		resolveTaskWait(updated, { superseded: true });
 		cancelTaskRun(updated, "Task superseded by a newer instruction.", now);
-		bumpSessionInputRevision(db, sessionKey);
+		bumpSessionInputRevision(db, conversationId);
 		return updated;
 	});
 }

package/dist/src/storage/sqlite/collaboration-rule-repository.js

@@ -1,7 +1,8 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "./transaction.js";
 import { USER_MODEL_PRINCIPAL_ID } from "../../user-model/domain.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/collaboration-rule-repository.ts
+init_transaction();
 function fromRow(row) {
 	return {
 		id: row.rule_id,

package/dist/src/storage/sqlite/composer-input-history-repository.js

@@ -1,5 +1,6 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "./transaction.js";
 //#region src/storage/sqlite/composer-input-history-repository.ts
+init_transaction();
 const COMPOSER_INPUT_HISTORY_LIMIT = 100;
 function fromRow(row) {
 	return {

package/dist/src/storage/sqlite/config-repository.d.ts

@@ -1,11 +1,11 @@
 import type { SessionAgentConfig } from '../../session/config-types.js';
-export declare function getSessionConfig(sessionKey: string): SessionAgentConfig | null;
+export declare function getSessionConfig(conversationId: string): SessionAgentConfig | null;
 /** Persisted file locations must be discoverable before a session runs again. */
 export declare function listSessionWorkspaceOverrides(): Array<{
-    sessionKey: string;
+    conversationId: string;
     workingDirectoryOverride: string;
 }>;
-export declare function setSessionConfig(sessionKey: string, config: SessionAgentConfig, cwd: string): SessionAgentConfig;
-export declare function updateSessionConfig(sessionKey: string, partial: Partial<SessionAgentConfig>, cwd: string): SessionAgentConfig;
-export declare function deleteSessionConfig(sessionKey: string): void;
-export declare function hasSessionConfig(sessionKey: string): boolean;
+export declare function setSessionConfig(conversationId: string, config: SessionAgentConfig, cwd: string): SessionAgentConfig;
+export declare function updateSessionConfig(conversationId: string, partial: Partial<SessionAgentConfig>, cwd: string): SessionAgentConfig;
+export declare function deleteSessionConfig(conversationId: string): void;
+export declare function hasSessionConfig(conversationId: string): boolean;

package/dist/src/storage/sqlite/config-repository.js

@@ -1,43 +1,47 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { sessionConfigRowToConfig } from "./row-mappers.js";
-import { notifyUserContextChange } from "../../user-context/changes.js";
-import { ensureSessionInTransaction } from "./session-repository.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "./transaction.js";
+import { init_row_mappers, sessionConfigRowToConfig } from "./row-mappers.js";
+import { init_changes, notifyUserContextChange } from "../../user-context/changes.js";
+import { ensureSessionInTransaction, init_session_repository } from "./session-repository.js";
 //#region src/storage/sqlite/config-repository.ts
-function readConfigRow(db, sessionKey) {
-	return db.prepare(`SELECT session_key, thinking_level, reasoning_level, verbose_level, elevated_mode,
+init_changes();
+init_row_mappers();
+init_session_repository();
+init_transaction();
+function readConfigRow(db, conversationId) {
+	return db.prepare(`SELECT conversation_id, thinking_level, reasoning_level, verbose_level, elevated_mode,
               model_override, provider_override, working_directory_override, response_language,
               user_context_mode, fixed_model, updated_at
-       FROM session_config WHERE session_key = ?`).get(sessionKey);
+       FROM session_config WHERE conversation_id = ?`).get(conversationId);
 }
-function getSessionConfig(sessionKey) {
-	const row = readConfigRow(getSqliteDatabase(), sessionKey);
+function getSessionConfig(conversationId) {
+	const row = readConfigRow(getSqliteDatabase(), conversationId);
 	if (!row) return null;
 	return sessionConfigRowToConfig(row);
 }
 /** Persisted file locations must be discoverable before a session runs again. */
 function listSessionWorkspaceOverrides() {
 	return getSqliteDatabase().prepare(`
-    SELECT session_key AS sessionKey, working_directory_override AS workingDirectoryOverride
+    SELECT conversation_id AS conversationId, working_directory_override AS workingDirectoryOverride
     FROM session_config WHERE length(trim(working_directory_override)) > 0
   `).all();
 }
-function setSessionConfig(sessionKey, config, cwd) {
+function setSessionConfig(conversationId, config, cwd) {
 	notifyUserContextChange({
 		kind: "session",
-		id: sessionKey
+		id: conversationId
 	});
 	return runSqliteWriteTransaction((db) => {
-		ensureSessionInTransaction(db, sessionKey, cwd);
-		const updatedAt = Math.max(Date.now(), (readConfigRow(db, sessionKey)?.updated_at ?? 0) + 1);
+		ensureSessionInTransaction(db, conversationId, cwd);
+		const updatedAt = Math.max(Date.now(), (readConfigRow(db, conversationId)?.updated_at ?? 0) + 1);
 		const next = {
 			...config,
 			updatedAt
 		};
 		db.prepare(`INSERT INTO session_config (
-        session_key, thinking_level, reasoning_level, verbose_level, elevated_mode,
+        conversation_id, thinking_level, reasoning_level, verbose_level, elevated_mode,
         model_override, provider_override, working_directory_override, response_language, user_context_mode, fixed_model, updated_at
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      ON CONFLICT(session_key) DO UPDATE SET
+      ON CONFLICT(conversation_id) DO UPDATE SET
         thinking_level = excluded.thinking_level,
         reasoning_level = excluded.reasoning_level,
         verbose_level = excluded.verbose_level,
@@ -48,27 +52,27 @@ function setSessionConfig(sessionKey, config, cwd) {
         response_language = excluded.response_language,
         user_context_mode = excluded.user_context_mode,
         fixed_model = excluded.fixed_model,
-        updated_at = excluded.updated_at`).run(sessionKey, next.thinkingLevel ?? null, next.reasoningLevel ?? null, next.verboseLevel ?? null, next.elevatedMode ?? null, next.modelOverride ?? null, next.providerOverride ?? null, next.workingDirectoryOverride ?? null, next.responseLanguage ?? null, next.userContextMode ?? null, next.fixedModel ? 1 : 0, updatedAt);
+        updated_at = excluded.updated_at`).run(conversationId, next.thinkingLevel ?? null, next.reasoningLevel ?? null, next.verboseLevel ?? null, next.elevatedMode ?? null, next.modelOverride ?? null, next.providerOverride ?? null, next.workingDirectoryOverride ?? null, next.responseLanguage ?? null, next.userContextMode ?? null, next.fixedModel ? 1 : 0, updatedAt);
 		return next;
 	});
 }
-function updateSessionConfig(sessionKey, partial, cwd) {
-	return setSessionConfig(sessionKey, {
-		...getSessionConfig(sessionKey),
+function updateSessionConfig(conversationId, partial, cwd) {
+	return setSessionConfig(conversationId, {
+		...getSessionConfig(conversationId),
 		...partial
 	}, cwd);
 }
-function deleteSessionConfig(sessionKey) {
+function deleteSessionConfig(conversationId) {
 	notifyUserContextChange({
 		kind: "session",
-		id: sessionKey
+		id: conversationId
 	});
 	runSqliteWriteTransaction((db) => {
-		db.prepare(`DELETE FROM session_config WHERE session_key = ?`).run(sessionKey);
+		db.prepare(`DELETE FROM session_config WHERE conversation_id = ?`).run(conversationId);
 	});
 }
-function hasSessionConfig(sessionKey) {
-	return getSqliteDatabase().prepare(`SELECT 1 AS ok FROM session_config WHERE session_key = ?`).get(sessionKey)?.ok === 1;
+function hasSessionConfig(conversationId) {
+	return getSqliteDatabase().prepare(`SELECT 1 AS ok FROM session_config WHERE conversation_id = ?`).get(conversationId)?.ok === 1;
 }
 //#endregion
 export { deleteSessionConfig, getSessionConfig, hasSessionConfig, listSessionWorkspaceOverrides, setSessionConfig, updateSessionConfig };

package/dist/src/storage/sqlite/connection-wait-repository.d.ts

@@ -1,13 +1,13 @@
 import type { ConnectionCheckpoint, ConnectionNeed, ConnectionWait } from '@xopcai/gateway-contract';
 import { type SessionInput } from './session-input-repository.js';
-export declare function onConnectionWaitChanged(listener: (sessionKey: string) => void): () => void;
-export declare function publishConnectionWait(sessionKey: string): void;
+export declare function onConnectionWaitChanged(listener: (conversationId: string) => void): () => void;
+export declare function publishConnectionWait(conversationId: string): void;
 export declare function getConnectionWait(id: string): ConnectionWait | undefined;
-export declare function getActiveConnectionWait(sessionKey: string): ConnectionWait | undefined;
-export declare function isConnectionSuspended(sessionKey: string, runId: string): boolean;
+export declare function getActiveConnectionWait(conversationId: string): ConnectionWait | undefined;
+export declare function isConnectionSuspended(conversationId: string, runId: string): boolean;
 export declare function updateConnectionWait(wait: ConnectionWait, expectedVersion: number): ConnectionWait;
 export declare function requireSessionConnection(input: {
-    sessionKey: string;
+    conversationId: string;
     principalId: string;
     agentId: string;
     summary: string;
@@ -20,11 +20,11 @@ export declare function requireSessionConnection(input: {
 /** The input and the wait transition commit together, using the existing queue's unique key. */
 export declare function queueConnectionResolution(wait: ConnectionWait, resolution: 'continued' | 'skipped'): ConnectionWait;
 export declare function consumeConnectionResume(input: SessionInput): boolean;
-export declare function connectionBindings(sessionKey: string): ConnectionNeed[];
-export declare function connectionBinding(sessionKey: string, connectorId: string): string | undefined;
+export declare function connectionBindings(conversationId: string): ConnectionNeed[];
+export declare function connectionBinding(conversationId: string, connectorId: string): string | undefined;
 /** New input wins over an outstanding auto-resume intent, including an already queued resume. */
-export declare function invalidateConnectionResumeIntent(sessionKey: string): void;
-export declare function reviseCurrentConnectionObjective(sessionKey: string, summary: string | undefined): void;
-export declare function cancelConnectionObjective(sessionKey: string): void;
-export declare function getConnectionResumeInput(sessionKey: string, runId: string): SessionInput | undefined;
+export declare function invalidateConnectionResumeIntent(conversationId: string): void;
+export declare function reviseCurrentConnectionObjective(conversationId: string, summary: string | undefined): void;
+export declare function cancelConnectionObjective(conversationId: string): void;
+export declare function getConnectionResumeInput(conversationId: string, runId: string): SessionInput | undefined;
 export declare function listConnectionWaitsToCheck(): ConnectionWait[];