@xopcai/xopc 0.0.285 → 0.0.291

package/dist/src/config/models-json.js

@@ -1,6 +1,8 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
-import { init_paths, resolveModelsJsonPath } from "./paths.js";
+import { ComputerProfileSchema, init_src } from "../../packages/computer-control-contract/src/index.js";
 import { init_write_file_atomic, writeTextAtomicSync } from "../infra/write-file-atomic.js";
+import { init_paths, resolveModelsJsonPath } from "./paths.js";
+import { init_model_policy, isComputerModel } from "../computer/model-policy.js";
 import { existsSync, readFileSync } from "fs";
 import { z } from "zod";
 //#region src/config/models-json.ts
@@ -111,6 +113,14 @@ function validateModelsConfig(config) {
 		});
 		if (providerConfig.models) for (let i = 0; i < providerConfig.models.length; i++) {
 			const model = providerConfig.models[i];
+			if (model.computerUse && !isComputerModel({
+				...model,
+				api: model.api ?? providerConfig.api
+			})) errors.push({
+				path: `providers.${providerName}.models[${i}].computerUse`,
+				message: "Computer Use requires image input and the openai-completions API",
+				severity: "error"
+			});
 			if (!model.api && !providerConfig.api) errors.push({
 				path: `providers.${providerName}.models[${i}].api`,
 				message: "api is required when not specified at provider level",
@@ -216,8 +226,10 @@ function modelsJsonExists(path = resolveModelsJsonPath()) {
 }
 var OpenRouterRoutingSchema, VercelGatewayRoutingSchema, OpenAICompletionsCompatSchema, OpenAIResponsesCompatSchema, OpenAICompatSchema, ImageGenerationResolutionSchema, ImageGenerationQualitySchema, ImageGenerationOutputFormatSchema, ImageGenerationBackgroundSchema, ImageGenerationCapabilitiesSchema, ImageGenerationModelSchema, ImageGenerationProviderSchema, CustomModelSchema, ModelOverrideSchema, ProviderConfigSchema, ModelsJsonSchema, PROVIDER_ID_REGEX, RESERVED_PROVIDER_IDS;
 var init_models_json = __esmMin((() => {
+	init_src();
 	init_write_file_atomic();
 	init_paths();
+	init_model_policy();
 	OpenRouterRoutingSchema = z.object({
 		only: z.array(z.string()).optional(),
 		order: z.array(z.string()).optional()
@@ -333,6 +345,7 @@ var init_models_json = __esmMin((() => {
 		models: z.array(ImageGenerationModelSchema).min(1)
 	}).strict();
 	CustomModelSchema = z.object({
+		computerUse: z.object({ profile: ComputerProfileSchema }).strict().optional(),
 		id: z.string().min(1),
 		name: z.string().min(1).optional(),
 		api: z.enum([
@@ -369,6 +382,7 @@ var init_models_json = __esmMin((() => {
 		compat: OpenAICompatSchema.optional()
 	});
 	ModelOverrideSchema = z.object({
+		computerUse: z.object({ profile: ComputerProfileSchema }).strict().optional(),
 		name: z.string().min(1).optional(),
 		reasoning: z.boolean().optional(),
 		thinkingLevelMap: z.partialRecord(z.enum([

package/dist/src/config/schema.d.ts

@@ -41,6 +41,10 @@ export declare const AgentModelsSchema: z.ZodObject<{
         primary: z.ZodString;
         fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>>;
+    computerUse: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        primary: z.ZodString;
+        fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
     imageGeneration: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         primary: z.ZodString;
         fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -72,6 +76,10 @@ export declare const AgentsConfigSchema: z.ZodDefault<z.ZodObject<{
                 primary: z.ZodString;
                 fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
             }, z.core.$strict>>;
+            computerUse: z.ZodOptional<z.ZodObject<{
+                primary: z.ZodString;
+                fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
             imageGeneration: z.ZodOptional<z.ZodObject<{
                 primary: z.ZodString;
                 fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -154,6 +162,10 @@ export declare const AgentsConfigSchema: z.ZodDefault<z.ZodObject<{
                 primary: z.ZodString;
                 fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
             }, z.core.$strict>>>;
+            computerUse: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                primary: z.ZodString;
+                fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>>;
             imageGeneration: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 primary: z.ZodString;
                 fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -1104,11 +1116,16 @@ export declare const VoiceConfigSchema: z.ZodOptional<z.ZodObject<{
         maxDictationMs: z.ZodDefault<z.ZodNumber>;
         maxConversationMs: z.ZodDefault<z.ZodNumber>;
         bargeIn: z.ZodDefault<z.ZodBoolean>;
+        stt: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodLiteral<"xopc-cloud">;
+            model: z.ZodString;
+        }, z.core.$strict>>;
         tts: z.ZodOptional<z.ZodObject<{
             provider: z.ZodEnum<{
                 alibaba: "alibaba";
                 "xopc-cloud": "xopc-cloud";
             }>;
+            model: z.ZodOptional<z.ZodString>;
             voice: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         omni: z.ZodOptional<z.ZodObject<{
@@ -1556,6 +1573,10 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                     primary: z.ZodString;
                     fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 }, z.core.$strict>>;
+                computerUse: z.ZodOptional<z.ZodObject<{
+                    primary: z.ZodString;
+                    fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>>;
                 imageGeneration: z.ZodOptional<z.ZodObject<{
                     primary: z.ZodString;
                     fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -1638,6 +1659,10 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                     primary: z.ZodString;
                     fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 }, z.core.$strict>>>;
+                computerUse: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    primary: z.ZodString;
+                    fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>>>;
                 imageGeneration: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     primary: z.ZodString;
                     fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -1980,6 +2005,13 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
             }>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
+    computer: z.ZodPrefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxActionsPerSession: z.ZodDefault<z.ZodNumber>;
+        maxModelRequests: z.ZodDefault<z.ZodNumber>;
+        maxSessionDurationMs: z.ZodDefault<z.ZodNumber>;
+        idleGrantTtlMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
     tunnel: z.ZodOptional<z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         brokerUrl: z.ZodDefault<z.ZodString>;
@@ -2193,10 +2225,10 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
                 realtime: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>;
             capabilities: z.ZodRecord<z.ZodEnum<{
+                shares: "shares";
                 models: "models";
                 connectors: "connectors";
                 tunnels: "tunnels";
-                shares: "shares";
                 managedRuntime: "managedRuntime";
                 runtimeFleet: "runtimeFleet";
                 traceUpload: "traceUpload";
@@ -2308,11 +2340,16 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
             maxDictationMs: z.ZodDefault<z.ZodNumber>;
             maxConversationMs: z.ZodDefault<z.ZodNumber>;
             bargeIn: z.ZodDefault<z.ZodBoolean>;
+            stt: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodLiteral<"xopc-cloud">;
+                model: z.ZodString;
+            }, z.core.$strict>>;
             tts: z.ZodOptional<z.ZodObject<{
                 provider: z.ZodEnum<{
                     alibaba: "alibaba";
                     "xopc-cloud": "xopc-cloud";
                 }>;
+                model: z.ZodOptional<z.ZodString>;
                 voice: z.ZodOptional<z.ZodString>;
             }, z.core.$strict>>;
             omni: z.ZodOptional<z.ZodObject<{

package/dist/src/config/schema.js

@@ -1,7 +1,8 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { AgentModelsOverrideSchema, AgentsConfigSchema as AgentsConfigSchema$1, DEFAULT_AGENT_MODEL_REF, ImageGenerationRouteSchema, ModelRouteSchema } from "../agent-config/schema.js";
 import { init_agent_config } from "../agent-config/index.js";
-import { DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, init_config } from "../user-context/config.js";
+import { ComputerConfigSchema, init_config } from "../computer/config.js";
+import { DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, init_config as init_config$1 } from "../user-context/config.js";
 import { init_default_model } from "./default-model.js";
 import { init_public_url, validatePublicUrl } from "./public-url.js";
 import { PlatformConfigSchema, init_contracts } from "../platform/contracts.js";
@@ -39,8 +40,9 @@ function parseModelRef(ref) {
 }
 var AgentModelRefSchema, AgentImageGenerationModelSchema, AgentModelsSchema, AgentsConfigSchema, BrowserDriverSchema, BrowserHostnameSchema, BrowserConfigSchema, BindingMatchSchema, BindingRuleSchema, BindingsConfigSchema, SessionDmScopeSchema, SessionStorageConfigSchema, SessionResetModeSchema, SessionResetConfigSchema, SessionResetByTypeSchema, SessionScopeSchema, SessionConfigSchema, ChannelsConfigSchema, SearchProviderEntrySchema, WebSearchConfigSchema, WebsiteBlocklistSchema, WebToolsConfigSchema, ToolsConfigSchema, RuntimePreferenceSchema, RuntimeProvisionSchema, RuntimeVersionRequestSchema, LanguageRuntimeSchema, DEFAULT_RUNTIME_TOOLS_CONFIG, RuntimeToolsConfigSchema, GatewayAuthRateLimitSchema, GatewaySecuritySchema, GatewayTrustedProxySchema, GatewayAuthSchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayRemoteSchema, GatewayTlsSchema, GatewayModeSchema, HeartbeatConfigSchema, GatewayChannelConnectDeferModeSchema, TunnelConsentSchema, TunnelConfigSchema, WorkspaceImportConfigSchema, WorkspaceConfigSchema, GatewayBindModeSchema, GatewayWebchatConfigSchema, GatewayConfigSchema, ModelsDevConfigSchema, ModelCatalogConfigSchema, SttProviderConfigCatchallSchema, STTProviderConfigSchema, STTFallbackConfigSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, STTConfigSchema, TtsProviderConfigCatchallSchema, TTSProviderConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSEdgeConfigSchema, TTSSummarizationConfigSchema, TTSConfigSchema, VoiceRefinementConfigSchema, VoiceConfigSchema, MessagesConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProviderAuthConfigSchema, ProvidersConfigSchema, ExtensionSecurityConfigSchema, ExtensionSlotsConfigSchema, ExtensionsConfigSchema, UpdateAutoConfigSchema, UpdateConfigSchema, CommandsConfigSchema, TuiConfigSchema, McpHttpUrlSchema, ConnectorSecretReferenceSchema, McpConfigScalarSchema, McpOAuthConfigSchema, McpServerSchema, McpConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ConfigSchema;
 var init_schema = __esmMin((() => {
-	init_agent_config();
 	init_config();
+	init_agent_config();
+	init_config$1();
 	init_default_model();
 	init_public_url();
 	init_contracts();
@@ -843,9 +845,14 @@ activityDetailDefault: z.enum([
 			maxDictationMs: z.number().int().min(1e4).max(36e5).default(6e5),
 			maxConversationMs: z.number().int().min(1e4).max(72e5).default(36e5),
 			bargeIn: z.boolean().default(true),
+			stt: z.object({
+				provider: z.literal("xopc-cloud"),
+				model: z.string().min(1).max(200)
+			}).strict().optional(),
 			/** Conversation output selection; credentials stay in the provider configuration. */
 			tts: z.object({
 				provider: z.enum(["alibaba", "xopc-cloud"]),
+				model: z.string().min(1).max(200).optional(),
 				voice: z.string().trim().min(1).max(200).optional()
 			}).strict().optional(),
 			omni: z.object({
@@ -1018,6 +1025,7 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 		channels: ChannelsConfigSchema,
 		gateway: GatewayConfigSchema,
 		browser: BrowserConfigSchema,
+		computer: ComputerConfigSchema,
 		tunnel: TunnelConfigSchema.optional(),
 		workspace: WorkspaceConfigSchema,
 		tools: ToolsConfigSchema,
@@ -1141,6 +1149,7 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 			skillsMarketplaceProvider: "store",
 			skillsStoreBaseUrl: "https://store.xopc.ai"
 		},
+		computer: ComputerConfigSchema.parse({}),
 		browser: {
 			enabled: true,
 			driver: { kind: "extension" },

package/dist/src/config/voice.js

@@ -25,11 +25,11 @@ function getVoiceModelsConfig() {
 		config.ttsVoices[metadata.id] = toVoiceModels(metadata.voices);
 	}
 	const cloudModels = getModelCatalogStore().getSource("xopc-cloud")?.models ?? [];
-	config.stt["xopc-cloud"] = cloudModels.filter((model) => model.availability === "available" && model.kind === "stt").map((model) => ({
+	config.stt["xopc-cloud"] = cloudModels.filter((model) => model.availability === "available" && model.kind === "stt" && model.voice?.modes.includes("transcription")).map((model) => ({
 		id: model.id,
 		name: model.name
 	}));
-	config.tts["xopc-cloud"] = cloudModels.filter((model) => model.availability === "available" && model.kind === "tts").map((model) => ({
+	config.tts["xopc-cloud"] = cloudModels.filter((model) => model.availability === "available" && model.kind === "tts" && model.voice?.modes.includes("speech")).map((model) => ({
 		id: model.id,
 		name: model.name,
 		...model.tts ? { tts: {

package/dist/src/connectors/catalog.js

@@ -1,7 +1,8 @@
-import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
+import { init_connection, isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
 import { getCachedConnectorCatalogEntry } from "../storage/sqlite/connector-repository.js";
 import { listConnectorProviderDefinitions, listConnectorProviders } from "./providers.js";
 //#region src/connectors/catalog.ts
+init_connection();
 const CONNECTOR_BY_ID = new Map(listConnectorProviderDefinitions().map((connector) => [connector.id, connector]));
 function listConnectorCatalog() {
 	return listConnectorProviderDefinitions().sort((left, right) => left.displayName.localeCompare(right.displayName));

package/dist/src/connectors/composio-sessions.d.ts

@@ -56,7 +56,7 @@ export declare class ComposioSessionsAdapter {
         action: ConnectorActionMetadata;
         args?: Record<string, unknown>;
         agentId?: string;
-        sessionKey?: string;
+        conversationId?: string;
         confirmed?: boolean;
     }): Promise<{
         decision: 'allowed';

package/dist/src/connectors/composio-sessions.js

@@ -311,7 +311,7 @@ var ComposioSessionsAdapter = class {
 				connectorId: input.installation.connectorId,
 				principalId: input.context.principalId,
 				agentId: input.agentId,
-				sessionKey: input.sessionKey,
+				conversationId: input.conversationId,
 				actionId: input.action.actionId,
 				scope: input.action.scope,
 				decision: evaluation.decision,
@@ -341,7 +341,7 @@ var ComposioSessionsAdapter = class {
 				connectorId: input.installation.connectorId,
 				principalId: input.context.principalId,
 				agentId: input.agentId,
-				sessionKey: input.sessionKey,
+				conversationId: input.conversationId,
 				actionId: input.action.actionId,
 				scope: input.action.scope,
 				decision: "allowed",
@@ -360,7 +360,7 @@ var ComposioSessionsAdapter = class {
 				connectorId: input.installation.connectorId,
 				principalId: input.context.principalId,
 				agentId: input.agentId,
-				sessionKey: input.sessionKey,
+				conversationId: input.conversationId,
 				actionId: input.action.actionId,
 				scope: input.action.scope,
 				decision: "allowed",

package/dist/src/connectors/connection-recovery-service.d.ts

@@ -4,7 +4,7 @@ import { ComposioSessionsAdapter } from './composio-sessions.js';
 import type { ConnectionWaitSnapshot } from '@xopcai/gateway-contract';
 export type ConnectionAction = {
     waitId: string;
-    expectedSessionId: string;
+    expectedTranscriptId: string;
     expectedVersion: number;
     idempotencyKey: string;
     action: 'connect' | 'check' | 'continue' | 'skip' | 'cancel' | 'select_account' | 'confirm_scope' | 'replace_source';
@@ -27,16 +27,16 @@ export declare class ConnectionRecoveryService {
             saved: boolean;
             error?: string;
         }>;
-        drain: (sessionKey: string) => void;
+        drain: (conversationId: string) => void;
         adapter?: ComposioSessionsAdapter;
     });
     private get adapter();
-    snapshot(sessionKey: string): ConnectionWaitSnapshot;
+    snapshot(conversationId: string): ConnectionWaitSnapshot;
     private view;
     private ensureInstallation;
     private checkCapabilities;
     preflight(input: SessionInput): Promise<boolean>;
-    act(sessionKey: string, action: ConnectionAction): Promise<{
+    act(conversationId: string, action: ConnectionAction): Promise<{
         snapshot: ConnectionWaitSnapshot;
         authorizationUrl?: string;
     }>;

package/dist/src/connectors/connection-recovery-service.js

@@ -1,10 +1,10 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
-import { readCurrentSessionId } from "../storage/sqlite/session-instance-repository.js";
-import { getSessionInputState } from "../storage/sqlite/session-input-repository.js";
-import { cancelConnectionObjective, getActiveConnectionWait, getConnectionWait, listConnectionWaitsToCheck, publishConnectionWait, queueConnectionResolution, updateConnectionWait } from "../storage/sqlite/connection-wait-repository.js";
-import "../storage/sqlite/session-repository.js";
+import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transaction.js";
+import { readCurrentTranscriptId } from "../storage/sqlite/session-instance-repository.js";
+import { getSessionInputState, init_session_input_repository } from "../storage/sqlite/session-input-repository.js";
+import { cancelConnectionObjective, getActiveConnectionWait, getConnectionWait, init_connection_wait_repository, listConnectionWaitsToCheck, publishConnectionWait, queueConnectionResolution, updateConnectionWait } from "../storage/sqlite/connection-wait-repository.js";
+import { init_session_repository } from "../storage/sqlite/session-repository.js";
 import { getConnectorInstallation, listConnectorConnections, upsertConnectorInstallation } from "../storage/sqlite/connector-repository.js";
 import { getConnectorAccount } from "../storage/sqlite/connector-account-repository.js";
 import { ComposioSessionsAdapter } from "./composio-sessions.js";
@@ -18,6 +18,10 @@ import { installConnector } from "./install.js";
 import { persistConfigMutation } from "../config/config-mutation.js";
 import { randomUUID } from "node:crypto";
 //#region src/connectors/connection-recovery-service.ts
+init_transaction();
+init_session_repository();
+init_session_input_repository();
+init_connection_wait_repository();
 init_logger();
 const log = createLogger("Connectors:Recovery");
 const SCOPE_ORDER = {
@@ -49,10 +53,10 @@ var ConnectionRecoveryService = class {
 		this.polling = true;
 		try {
 			for (const wait of listConnectionWaitsToCheck()) {
-				if (this.busy.has(wait.sessionKey)) continue;
-				await this.act(wait.sessionKey, {
+				if (this.busy.has(wait.conversationId)) continue;
+				await this.act(wait.conversationId, {
 					waitId: wait.id,
-					expectedSessionId: wait.sessionId,
+					expectedTranscriptId: wait.transcriptId,
 					expectedVersion: wait.version,
 					idempotencyKey: randomUUID(),
 					action: "check"
@@ -68,14 +72,14 @@ var ConnectionRecoveryService = class {
 	get adapter() {
 		return this.deps.adapter ?? new ComposioSessionsAdapter();
 	}
-	snapshot(sessionKey) {
-		if (!connectorPrincipalForSession(sessionKey).isLocalOwner) throw new Error("This connection belongs to another principal.");
-		const sessionId = readCurrentSessionId(getSqliteDatabase(), sessionKey);
-		if (!sessionId) throw new Error("SESSION_CHANGED");
-		const wait = getActiveConnectionWait(sessionKey);
+	snapshot(conversationId) {
+		if (!connectorPrincipalForSession(conversationId).isLocalOwner) throw new Error("This connection belongs to another principal.");
+		const transcriptId = readCurrentTranscriptId(getSqliteDatabase(), conversationId);
+		if (!transcriptId) throw new Error("SESSION_CHANGED");
+		const wait = getActiveConnectionWait(conversationId);
 		return {
-			sessionId,
-			revision: getSessionInputState(sessionKey).revision,
+			transcriptId,
+			revision: getSessionInputState(conversationId).revision,
 			wait: wait ? this.view(wait) : null
 		};
 	}
@@ -182,7 +186,7 @@ var ConnectionRecoveryService = class {
 				const schemas = result && typeof result === "object" ? result.toolSchemas : void 0;
 				const missing = missingConnectionCapabilities(need, new Set(Object.entries(schemas && typeof schemas === "object" ? schemas : {}).filter(([action, value]) => value && typeof value === "object" && isToolInputSchema(value.inputSchema) && isComposioActionAllowedByCatalog(action)).map(([action]) => action)));
 				if (missing.length) log.warn({
-					sessionKey: wait.sessionKey,
+					conversationId: wait.conversationId,
 					connectorId: need.connectorId,
 					missingCapabilities: missing
 				}, "Connected app lacks required tool contracts");
@@ -193,7 +197,7 @@ var ConnectionRecoveryService = class {
 			} catch (err) {
 				log.warn({
 					err,
-					sessionKey: wait.sessionKey,
+					conversationId: wait.conversationId,
 					connectorId: need.connectorId
 				}, "Connected app capability check failed");
 				return {
@@ -206,7 +210,7 @@ var ConnectionRecoveryService = class {
 	async preflight(input) {
 		if (input.kind !== "connection_resume") return true;
 		const wait = input.payload ? getConnectionWait(input.payload.waitId) : void 0;
-		if (!wait || wait.status !== "queued" || wait.queuedInputId !== input.id || wait.sessionId !== readCurrentSessionId(getSqliteDatabase(), input.sessionKey)) return false;
+		if (!wait || wait.status !== "queued" || wait.queuedInputId !== input.id || wait.transcriptId !== readCurrentTranscriptId(getSqliteDatabase(), input.conversationId)) return false;
 		if (wait.resolution === "skipped") return true;
 		try {
 			const fresh = await this.adapter.syncConnections({ principalId: wait.principalId });
@@ -228,22 +232,22 @@ var ConnectionRecoveryService = class {
 				queuedInputId: void 0,
 				objectiveRevision: wait.objectiveRevision + 1
 			}, wait.version);
-			publishConnectionWait(input.sessionKey);
+			publishConnectionWait(input.conversationId);
 		}
 		return false;
 	}
-	async act(sessionKey, action) {
-		const ownsLock = !this.busy.has(sessionKey);
+	async act(conversationId, action) {
+		const ownsLock = !this.busy.has(conversationId);
 		if (!ownsLock && ![
 			"cancel",
 			"skip",
 			"replace_source"
 		].includes(action.action)) throw new Error("WAIT_CHANGED");
-		if (ownsLock) this.busy.add(sessionKey);
+		if (ownsLock) this.busy.add(conversationId);
 		try {
-			const snapshot = this.snapshot(sessionKey);
+			const snapshot = this.snapshot(conversationId);
 			let wait = getConnectionWait(action.waitId);
-			if (!wait || wait.sessionKey !== sessionKey || wait.principalId !== "local-owner" || wait.sessionId !== action.expectedSessionId || snapshot.sessionId !== action.expectedSessionId) throw new Error("SESSION_CHANGED");
+			if (!wait || wait.conversationId !== conversationId || wait.principalId !== "local-owner" || wait.transcriptId !== action.expectedTranscriptId || snapshot.transcriptId !== action.expectedTranscriptId) throw new Error("SESSION_CHANGED");
 			if (wait.lastAction?.key === action.idempotencyKey && wait.lastAction.action === action.action) return { snapshot };
 			if (wait.status !== "open" || wait.version !== action.expectedVersion) throw new Error("WAIT_CHANGED");
 			wait = {
@@ -253,7 +257,7 @@ var ConnectionRecoveryService = class {
 					action: action.action
 				}
 			};
-			if (action.action === "cancel") cancelConnectionObjective(sessionKey);
+			if (action.action === "cancel") cancelConnectionObjective(conversationId);
 			else if (action.action === "replace_source") {
 				const need = wait.needs.find((need) => need.key === action.needKey);
 				if (!need || !this.view(wait).needs.find((item) => item.key === need.key)?.alternatives?.some((item) => item.candidateRef === action.candidateRef)) throw new Error("Unsupported replacement.");
@@ -270,7 +274,7 @@ var ConnectionRecoveryService = class {
 					...wait,
 					intent: void 0
 				}, "skipped");
-				this.deps.drain(sessionKey);
+				this.deps.drain(conversationId);
 			} else if (action.action === "connect") {
 				const need = wait.needs.find((need) => need.key === action.needKey);
 				if (!need) throw new Error("Unknown connection requirement.");
@@ -292,7 +296,7 @@ var ConnectionRecoveryService = class {
 						}
 					} : item)
 				}, wait.version);
-				publishConnectionWait(sessionKey);
+				publishConnectionWait(conversationId);
 				const config = this.deps.getConfig();
 				await this.ensureInstallation(wait, need.connectorId);
 				const installationId = `${need.connectorId}-${wait.principalId}`;
@@ -315,15 +319,15 @@ var ConnectionRecoveryService = class {
 						}
 					} : item)
 				}, wait.version);
-				publishConnectionWait(sessionKey);
+				publishConnectionWait(conversationId);
 				log.info({
-					sessionKey,
+					conversationId,
 					waitId: wait.id,
 					objectiveRevision: wait.objectiveRevision,
 					phase: "authorization_started"
 				}, "Connection authorization started");
 				return {
-					snapshot: this.snapshot(sessionKey),
+					snapshot: this.snapshot(conversationId),
 					authorizationUrl: auth.connectUrl
 				};
 			} else {
@@ -387,18 +391,18 @@ var ConnectionRecoveryService = class {
 						needs: view.needs.map(({ phase: _phase, accounts: _accounts, reason: _reason, alternatives: _alternatives, ...need }) => need)
 					}, "continued");
 					log.info({
-						sessionKey,
+						conversationId,
 						waitId: wait.id,
 						objectiveRevision: wait.objectiveRevision,
 						phase: "resume_queued"
 					}, "Connection continuation queued");
-					this.deps.drain(sessionKey);
+					this.deps.drain(conversationId);
 				}
 			}
-			publishConnectionWait(sessionKey);
-			return { snapshot: this.snapshot(sessionKey) };
+			publishConnectionWait(conversationId);
+			return { snapshot: this.snapshot(conversationId) };
 		} catch (error) {
-			const wait = getActiveConnectionWait(sessionKey);
+			const wait = getActiveConnectionWait(conversationId);
 			if (action.action === "connect" && wait?.status === "open" && wait.lastAction?.key === action.idempotencyKey) {
 				updateConnectionWait({
 					...wait,
@@ -408,11 +412,11 @@ var ConnectionRecoveryService = class {
 						attempt: void 0
 					} : need)
 				}, wait.version);
-				publishConnectionWait(sessionKey);
+				publishConnectionWait(conversationId);
 			}
 			throw error;
 		} finally {
-			if (ownsLock) this.busy.delete(sessionKey);
+			if (ownsLock) this.busy.delete(conversationId);
 		}
 	}
 };

package/dist/src/connectors/principal.d.ts

@@ -1,4 +1,4 @@
-export declare function connectorPrincipalForSession(sessionKey: string | undefined): {
+export declare function connectorPrincipalForSession(conversationId: string | undefined): {
     principalId: string;
     agentId?: string;
     isLocalOwner: boolean;

package/dist/src/connectors/principal.js

@@ -1,8 +1,9 @@
-import { init_session_key, parseSessionKey } from "../routing/session-key.js";
+import { getConversationRouting } from "../storage/sqlite/conversation-repository.js";
+import { init_session_key } from "../routing/session-key.js";
 //#region src/connectors/principal.ts
 init_session_key();
-function connectorPrincipalForSession(sessionKey) {
-	const parsed = parseSessionKey(sessionKey);
+function connectorPrincipalForSession(conversationId) {
+	const parsed = getConversationRouting(conversationId);
 	if (!parsed || parsed.source === "cli" || parsed.source === "webchat") return {
 		principalId: "local-owner",
 		agentId: parsed?.agentId,

package/dist/src/connectors/types.d.ts

@@ -172,7 +172,7 @@ export type ConnectorExecutionAuditRecord = {
     connectorId: string;
     principalId: string;
     agentId?: string;
-    sessionKey?: string;
+    conversationId?: string;
     actionId: string;
     scope: ConnectorScope;
     decision: ConnectorExecutionDecision;
@@ -188,7 +188,7 @@ export type ConnectorApprovalRecord = {
     connectorId: string;
     connectionId?: string;
     agentId?: string;
-    sessionKey?: string;
+    conversationId?: string;
     actionId: string;
     scope: ConnectorScope;
     argumentsHash: string;

package/dist/src/discussions/action-tasks.js

@@ -1,11 +1,14 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { TaskCreateRequestSchema } from "../../packages/gateway-contract/src/tasks.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { TaskRepository } from "../tasks/task-repository.js";
 import { TaskApplicationService } from "../tasks/task-application-service.js";
-import { getDiscussionCapture, getLatestDiscussionOrganization } from "./repository.js";
 import { DiscussionServiceError } from "./errors.js";
+import { getDiscussionCapture, getLatestDiscussionOrganization } from "./repository.js";
 import { readTranscriptRevision } from "./revisions.js";
 //#region src/discussions/action-tasks.ts
+init_src();
+init_transaction();
 function meetingActionTasks(id) {
 	const rows = getSqliteDatabase().prepare("SELECT action_id, task_id FROM discussion_action_tasks WHERE discussion_id=?").all(id);
 	const tasks = new TaskRepository();

package/dist/src/discussions/analyzer.js

@@ -1,4 +1,4 @@
-import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
+import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transaction.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { init_providers, resolveModel } from "../providers/index.js";
 import { completeWithResolvedCredentials } from "../providers/model-call.js";
@@ -6,6 +6,7 @@ import { MeetingChangesSchema, reconcileMeetingChapters } from "./reconcile.js";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 //#region src/discussions/analyzer.ts
+init_transaction();
 init_schema();
 init_providers();
 const optionalString = (max) => z.preprocess((value) => value === null ? void 0 : value, z.string().trim().min(1).max(max).optional());

package/dist/src/discussions/edits.js

@@ -1,7 +1,9 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
-import { completeDiscussionOrganization, createDiscussionOrganization, getDiscussionCapture, getLatestDiscussionOrganization } from "./repository.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { DiscussionServiceError } from "./errors.js";
+import { completeDiscussionOrganization, createDiscussionOrganization, getDiscussionCapture, getLatestDiscussionOrganization } from "./repository.js";
 import { z } from "zod";
+//#region src/discussions/edits.ts
+init_transaction();
 const MeetingEditSchema = z.object({
 	kind: z.enum([
 		"summary",

package/dist/src/discussions/index.js

@@ -1,7 +1,7 @@
 import { DISCUSSION_AUDIO_MAX_BYTES, DISCUSSION_MAX_DURATION_MS, DISCUSSION_STATUSES } from "../../packages/gateway-contract/src/discussions.js";
 import { DiscussionServiceError } from "./errors.js";
-import { DiscussionService } from "./service.js";
 import { analyzeDiscussion } from "./analyzer.js";
+import { DiscussionService } from "./service.js";
 import { DiscussionOrganizer } from "./organizer.js";
 import { DiscussionLiveWorker } from "./live-worker.js";
 import { DiscussionOrganizerWorker } from "./organizer-worker.js";

package/dist/src/discussions/organizer.js

@@ -1,11 +1,12 @@
-import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { ObjectLinkService } from "../activity/service.js";
 import { completeDiscussionOrganization, createDiscussionOrganization, getDiscussionCapture, getLatestDiscussionOrganization, listDiscussionTranscriptSegments, renewDiscussionWorkLease, updateDiscussionCapture } from "./repository.js";
-import { applyMeetingEdits } from "./edits.js";
 import { saveTranscriptRevision } from "./revisions.js";
 import { analyzeDiscussion } from "./analyzer.js";
+import { applyMeetingEdits } from "./edits.js";
 import { acceptRankedProject, findExactProjectMention } from "./project-inference.js";
 //#region src/discussions/organizer.ts
+init_transaction();
 const PROMPT_VERSION = "discussion-evidence-v2";
 var DiscussionOrganizer = class {
 	objectLinks = new ObjectLinkService();

package/dist/src/discussions/recording.js

@@ -1,15 +1,18 @@
-import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { DISCUSSION_MAX_DURATION_MS } from "../../packages/gateway-contract/src/discussions.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { decodeWavToMonoFloat32 } from "../voice/local/wav.js";
 import { forEachNormalizedAudioSegment } from "../voice/audio/normalize.js";
-import { getDiscussionCapture, updateDiscussionCapture } from "./repository.js";
 import { DiscussionServiceError } from "./errors.js";
+import { getDiscussionCapture, updateDiscussionCapture } from "./repository.js";
 import { resolveNoteMediaDir } from "../notes/paths.js";
 import { join } from "node:path";
 import { createReadStream } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, open, rename, rm } from "node:fs/promises";
 //#region src/discussions/recording.ts
+init_src();
+init_transaction();
 const invalid = (message) => new DiscussionServiceError("invalid_input", message);
 const directory = (capture) => join(resolveNoteMediaDir(capture.noteId), ".recording");
 function listRecordingChunks(id) {