@xopcai/xopc 0.0.248 → 0.0.250

package/dist/src/config/schema.js

@@ -2,7 +2,7 @@ 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 { checkCacheDir, init_cache_dir_policy } from "../browser/cache-dir-policy.js";
-import { UserContextConfigSchema, init_config } from "../user-context/config.js";
+import { DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, init_config } from "../user-context/config.js";
 import { init_default_model } from "./default-model.js";
 import { init_public_url, validatePublicUrl } from "./public-url.js";
 import { TelegramAccountConfigSchema, TelegramConfigSchema, TelegramGroupConfigSchema, TelegramTopicConfigSchema, init_config_schema } from "../../extensions/telegram/src/config-schema.js";
@@ -1007,30 +1007,41 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 		userContext: {
 			enabled: true,
 			preferences: { responseLanguage: "auto" },
-			memory: {
-				mode: "confirmWrite",
-				sources: ["session", "understanding"],
-				writePolicy: { understanding: "confirm" }
-			},
-			understanding: {
+			userModel: {
 				enabled: true,
+				writePolicy: "confirm",
+				sensitiveWritePolicy: "confirm",
 				processingPolicy: "remote_allowed",
-				adaptiveCadence: true,
-				reviewIntervalTurns: 10,
-				maxHistoryMessages: 80,
-				maxDurationMs: 12e4
+				extraction: {
+					reviewIntervalTurns: 10,
+					maxHistoryMessages: 80,
+					maxDurationMs: 12e4
+				},
+				maintenance: {
+					enabled: true,
+					temporalSweepMinutes: 60,
+					dailyTime: "03:00",
+					weeklyDay: "sun",
+					weeklyTime: "04:00",
+					evidenceThreshold: 2,
+					limit: 1e3,
+					staleRetentionDays: 30
+				}
 			},
-			privacy: { sensitiveWritePolicy: "confirm" },
-			providerRouting: {
+			knowledgeMemory: {
+				enabled: true,
+				writePolicy: "confirm",
+				sources: ["session", "workspace"],
 				searchStrategy: "fanout",
 				writeStrategy: "local-first",
 				allowExternalWrites: false
 			},
-			dreaming: {
-				mode: "review",
-				schedule: { time: "03:00" },
-				minEvidenceSources: 2,
-				limit: 500
+			contextPlanning: {
+				enabled: true,
+				maxAssertions: 20,
+				maxKnowledge: 12,
+				maxChars: 6e3,
+				compaction: DEFAULT_CONTEXT_COMPACTION_POLICY
 			}
 		},
 		agents: {

package/dist/src/config/web-patch.d.ts

@@ -26,7 +26,7 @@ export declare function resolveSessionConfigForWeb(config: Config): {
 };
 export declare function resolveUpdateConfigForWeb(config: Config): {
     checkOnStart: boolean;
-    channel: "beta" | "stable" | "dev";
+    channel: "stable" | "beta" | "dev";
     auto: {
         enabled: boolean;
         stableDelayHours: number;

package/dist/src/connectors/auth-provider-registry.js

@@ -1,7 +1,7 @@
 import { startComposioAuthorize } from "./composio.js";
-import { getMcpOAuthManager } from "../agent/mcp/oauth/mcp-oauth-manager.js";
 import { isManagedConnectorServer } from "./materialize.js";
 import { getConnectorInstance } from "./instances.js";
+import { getMcpOAuthManager } from "../agent/mcp/oauth/mcp-oauth-manager.js";
 //#region src/connectors/auth-provider-registry.ts
 async function startConnectorAuthorization(definition, config, instanceId) {
 	if (definition.auth.mode !== "oauth") throw new Error(`Connector "${definition.id}" does not use OAuth.`);

package/dist/src/connectors/composio-managed-client.js

@@ -73,8 +73,12 @@ var ManagedComposioClient = class {
 					}
 				})).item;
 			},
-			search: async () => {
-				return (await this.request({ path: `/connectors/composio/toolkits/${encodeURIComponent(toolkit())}/tools` })).result;
+			search: async ({ query }) => {
+				const results = await Promise.all([...new Set(toolkits)].map(async (slug) => {
+					return (await this.request({ path: `/connectors/composio/toolkits/${encodeURIComponent(slug)}/tools?query=${encodeURIComponent(query)}` })).result;
+				}));
+				if (results.length === 1) return results[0];
+				return { toolSchemas: Object.assign({}, ...results.map((result) => result.toolSchemas ?? {})) };
 			},
 			execute: async (toolSlug, args = {}, options) => {
 				const selected = options?.account ?? connectedAccounts[toolkit()]?.[0];

package/dist/src/connectors/connected-source-ingestion.js

@@ -6,8 +6,8 @@ import { ComposioSessionsAdapter } from "./composio-sessions.js";
 import { decodeConnectedSourceCursor, encodeConnectedSourceCursor } from "./connected-source-cursor.js";
 import { scopeForComposioAction } from "./composio.js";
 import { getConnectorDefinition } from "./catalog.js";
-import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { getConnectorInstance } from "./instances.js";
+import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { KnowledgeIngestionService } from "../knowledge/ingestion-service.js";
 import { ConnectedKnowledgePipeline } from "../knowledge/connected-knowledge-pipeline.js";
 import { LocalFolderKnowledgeSourceAdapter } from "../knowledge/local-folder-adapter.js";

package/dist/src/connectors/connected-source-understanding.d.ts

@@ -1,4 +1,3 @@
-import type { MemoryManager } from '../agent/memory/manager.js';
 import type { Config } from '../config/schema.js';
 import type { KnowledgeSourceItem } from '../knowledge/types.js';
 import type { UnderstandingSourceItem } from '../user-context/sources/types.js';
@@ -10,11 +9,10 @@ export declare function deriveConnectedSourceUnderstanding(input: {
     sourceInstanceId: string;
     sourceRunId: string;
     processingPolicy: 'local_only' | 'remote_allowed';
-    memoryManager: MemoryManager;
     analyze?: typeof analyzeUnderstandingSources;
 }): Promise<{
     created: number;
-    focusCount: number;
+    knowledgeCount: number;
     status: 'completed' | 'partial' | 'failed';
     error?: string;
 }>;

package/dist/src/connectors/connected-source-understanding.js

@@ -1,8 +1,11 @@
 import { finishContextExtractionRun } from "../storage/sqlite/context-extraction-repository.js";
+import { createContextEvidence } from "../storage/sqlite/context-evidence-repository.js";
 import { listKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
 import "../storage/sqlite/index.js";
-import { focusLifecycle } from "../user-context/focus-lifecycle.js";
-import { upsertUserFocus } from "../user-context/sources/repository.js";
+import { writeKnowledgeItem } from "../knowledge-memory/repository.js";
+import "../knowledge-memory/index.js";
+import { reconcileAssertion } from "../user-model/repository.js";
+import "../user-model/index.js";
 import { claimRegisteredExtraction } from "../user-context/extraction/registry.js";
 import { allowsRemoteSourceProcessing } from "../user-context/sources/processing-policy.js";
 import { analyzeUnderstandingSources } from "../work-discovery/analyzer.js";
@@ -20,11 +23,11 @@ function normalizedValue(item) {
 function text(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-function itemType(itemType) {
-	if (itemType === "email") return "mail";
-	if (itemType === "calendar_event") return "calendar_event";
-	if (itemType === "external_task") return "task";
-	if (itemType === "development_activity" || itemType === "repository") return "code_activity";
+function itemType(value) {
+	if (value === "email") return "mail";
+	if (value === "calendar_event") return "calendar_event";
+	if (value === "external_task") return "task";
+	if (value === "development_activity" || value === "repository") return "code_activity";
 	return "document";
 }
 function timestamp(value) {
@@ -32,14 +35,8 @@ function timestamp(value) {
 	const parsed = Date.parse(value);
 	return Number.isFinite(parsed) ? parsed : void 0;
 }
-function contentPriority(item) {
-	const value = normalizedValue(item);
-	if (item.itemType === "connected_content") return 3;
-	if (text(value.content)) return 2;
-	return 1;
-}
 function connectedItemsForUnderstanding(items) {
-	return [...items].sort((left, right) => contentPriority(right) - contentPriority(left)).slice(0, MAX_CONNECTED_ITEMS).flatMap((item) => {
+	return [...items].sort((left, right) => Number(right.itemType === "connected_content") - Number(left.itemType === "connected_content")).slice(0, MAX_CONNECTED_ITEMS).flatMap((item) => {
 		const value = normalizedValue(item);
 		const title = text(value.title) ?? text(value.subject) ?? text(value.fullName) ?? text(value.repository) ?? `${text(item.metadata.toolkit) ?? "Connected source"} ${item.itemType}`;
 		const normalizedText = item.normalizedText?.trim();
@@ -59,62 +56,38 @@ function connectedItemsForUnderstanding(items) {
 		}];
 	});
 }
-function isConnectedPortraitCandidate(candidate) {
+function isPortraitCandidate(candidate) {
 	return candidate.category === "preference" || candidate.category === "routine";
 }
-function understandingCandidate(candidate) {
-	return {
-		kind: candidate.category,
-		content: candidate.statement,
-		canonicalKey: `understanding:${candidate.category}:${candidate.factKey}`,
-		confidence: candidate.confidence === "high" ? .9 : candidate.confidence === "medium" ? .72 : .55,
-		importance: .68,
-		explicitness: "inferred",
-		durability: candidate.category === "routine" ? "recurring" : "durable",
-		sensitivity: "personal",
-		disclosurePolicy: "referenceable"
-	};
-}
-function hasLongVerbatimOverlap(value, sourceTexts, minimumLength = 32) {
-	const normalized = value.replace(/\s+/g, " ").trim();
-	if (normalized.length < minimumLength) return false;
-	return sourceTexts.some((source) => source.replace(/\s+/g, " ").includes(normalized));
-}
-function evidenceDate(item) {
-	const timestamp = item.occurredAt ?? item.modifiedAt;
-	return timestamp == null ? void 0 : new Date(timestamp).toISOString().slice(0, 10);
-}
-function durableConnectedEvidence(candidate, itemsByRef) {
-	if (candidate.confidence !== "high") return [];
-	const items = [...new Set(candidate.evidenceRefs ?? [])].flatMap((ref) => itemsByRef.get(ref) ?? []);
-	if (items.some((item) => item.ownerAttribution !== "user")) return [];
+function durableEvidence(candidate, items) {
+	const evidence = [...new Set(candidate.evidenceRefs ?? [])].flatMap((ref) => items.get(ref) ?? []);
 	const required = candidate.category === "routine" ? 3 : 2;
-	const dates = new Set(items.map(evidenceDate).filter((value) => Boolean(value)));
-	return items.length >= required && dates.size >= required ? items : [];
+	const dates = new Set(evidence.map((item) => item.occurredAt ?? item.modifiedAt).filter((value) => value !== void 0).map((value) => new Date(value).toISOString().slice(0, 10)));
+	return candidate.confidence === "high" && evidence.every((item) => item.ownerAttribution === "user") && evidence.length >= required && dates.size >= required ? evidence : [];
 }
 async function deriveConnectedSourceUnderstanding(input) {
-	const knowledgeItems = listKnowledgeSourceItems({
+	const sourceItems = listKnowledgeSourceItems({
 		agentId: input.agentId,
 		sourceInstanceId: input.sourceInstanceId,
 		includeDeleted: false,
 		limit: MAX_CONNECTED_ITEMS
 	});
-	const items = connectedItemsForUnderstanding(knowledgeItems);
+	const items = connectedItemsForUnderstanding(sourceItems);
 	if (!items.length) return {
 		created: 0,
-		focusCount: 0,
+		knowledgeCount: 0,
 		status: "completed"
 	};
 	const extraction = claimRegisteredExtraction({
 		extractorId: "connector-semantic",
 		sourceRef: `understanding-source-run:${input.sourceRunId}`,
-		contentForHash: knowledgeItems.map((item) => `${item.id}:${item.sourceUpdatedAt ?? ""}`).join("\n"),
+		contentForHash: sourceItems.map((item) => `${item.id}:${item.sourceUpdatedAt ?? ""}`).join("\n"),
 		processingPolicy: input.processingPolicy,
 		destination: "remote_model"
 	});
 	if (!allowsRemoteSourceProcessing([input.processingPolicy]) || !extraction.shouldExecute) return {
 		created: 0,
-		focusCount: 0,
+		knowledgeCount: 0,
 		status: "completed"
 	};
 	try {
@@ -122,63 +95,77 @@ async function deriveConnectedSourceUnderstanding(input) {
 			config: input.config,
 			items
 		});
-		const rawTexts = items.flatMap((item) => item.text ? [item.text] : []);
-		const itemsByRef = new Map(items.map((item) => [item.evidenceRef, item]));
-		const profileCandidates = analysis.profileCandidates.filter(isConnectedPortraitCandidate).filter((candidate) => !hasLongVerbatimOverlap(candidate.statement, rawTexts) && durableConnectedEvidence(candidate, itemsByRef).length > 0);
-		const reviewed = {
-			created: 0,
-			writeOutputs: []
-		};
-		for (const candidate of profileCandidates) {
-			const evidenceItems = durableConnectedEvidence(candidate, itemsByRef);
-			const applied = await input.memoryManager.applyUnderstandingCandidates([understandingCandidate(candidate)], {
-				agentId: input.agentId,
-				sourceItemIds: evidenceItems.map((item) => item.id).slice(0, 20),
-				sourceText: "Bounded semantic synthesis from explicitly connected work sources.",
-				source: {
-					provider: "connected-sources",
-					sourceInstanceId: input.sourceInstanceId
-				},
-				reviewSource: "background",
-				extractionRunId: extraction.run.id
-			});
-			reviewed.created += applied.created;
-			reviewed.writeOutputs.push(...applied.writeOutputs ?? []);
+		const byRef = new Map(items.map((item) => [item.evidenceRef, item]));
+		let created = 0;
+		for (const candidate of analysis.profileCandidates.filter(isPortraitCandidate)) {
+			const evidenceItems = durableEvidence(candidate, byRef);
+			if (!evidenceItems.length) continue;
+			for (const [index, evidenceItem] of evidenceItems.entries()) {
+				const evidence = createContextEvidence({
+					sourceType: "connector",
+					sourceInstanceId: input.sourceInstanceId,
+					sourceRef: evidenceItem.evidenceRef,
+					redactedExcerpt: evidenceItem.title.slice(0, 600),
+					trustLevel: "owner",
+					observedAt: evidenceItem.occurredAt ?? evidenceItem.modifiedAt ?? Date.now()
+				});
+				const result = reconcileAssertion({
+					subject: {
+						type: "user",
+						id: "self"
+					},
+					predicate: `${candidate.category}.connected.${candidate.factKey}`,
+					cardinality: "single",
+					scope: {
+						type: "agent",
+						id: input.agentId
+					},
+					kind: candidate.category,
+					value: candidate.statement,
+					normalizedValue: candidate.statement.toLocaleLowerCase(),
+					statement: candidate.statement,
+					authority: "user_observed",
+					confidence: candidate.confidence === "high" ? .9 : .7,
+					inferredImportance: .65,
+					consequence: "medium",
+					actionability: .6,
+					volatility: candidate.category === "routine" ? "slow" : "stable",
+					sensitivity: "personal",
+					disclosurePolicy: "referenceable",
+					observedAt: evidenceItem.occurredAt ?? evidenceItem.modifiedAt ?? Date.now(),
+					createdBy: "connector",
+					evidenceId: evidence.id,
+					evidenceConfidence: .9
+				});
+				if (index === 0 && result.action === "created") created += 1;
+			}
 		}
-		const focuses = analysis.workThreadCandidates.filter((candidate) => !hasLongVerbatimOverlap(candidate.title, rawTexts) && !hasLongVerbatimOverlap(candidate.summary, rawTexts)).map((candidate) => upsertUserFocus({
-			canonicalKey: `connected-focus:${candidate.topicKey}`,
-			title: candidate.title,
-			summary: candidate.summary,
-			horizon: candidate.horizon,
-			status: "candidate",
-			confidence: candidate.confidence === "high" ? .9 : candidate.confidence === "medium" ? .72 : .55,
-			evidenceRefs: candidate.evidenceRefs,
-			sourceRunId: input.sourceRunId,
-			...focusLifecycle(candidate.horizon)
-		}));
+		let knowledgeCount = 0;
+		for (const thread of analysis.workThreadCandidates) if (writeKnowledgeItem({
+			kind: "project_fact",
+			scope: {
+				type: "agent",
+				id: input.agentId
+			},
+			content: `${thread.title}: ${thread.summary}`,
+			canonicalKey: `connected-thread:${input.sourceInstanceId}:${thread.topicKey}`,
+			confidence: thread.confidence === "high" ? .9 : thread.confidence === "medium" ? .72 : .55,
+			importance: thread.horizon === "current" ? .75 : .5,
+			originClass: "untrusted",
+			sourceAgentId: input.agentId,
+			source: {
+				sourceRunId: input.sourceRunId,
+				evidenceRefs: thread.evidenceRefs
+			}
+		}).created) knowledgeCount += 1;
 		finishContextExtractionRun({
 			runId: extraction.run.id,
-			status: "completed",
-			outputs: [...(reviewed.writeOutputs ?? []).map((output) => ({
-				candidateKey: output.candidateKey,
-				...output.objectId ? {
-					objectType: "understanding",
-					objectId: output.objectId
-				} : {},
-				...output.versionId ? { versionId: output.versionId } : {},
-				outcome: output.outcome
-			})), ...focuses.map((focus) => ({
-				candidateKey: focus.canonicalKey,
-				objectType: "focus",
-				objectId: focus.id,
-				versionId: focus.versionId,
-				outcome: "created"
-			}))]
+			status: "completed"
 		});
 		const sourceStatus = analysis.sourceStatuses.find((item) => item.sourceId === "connected-work");
 		return {
-			created: reviewed.created,
-			focusCount: focuses.length,
+			created,
+			knowledgeCount,
 			status: sourceStatus?.status ?? "failed",
 			...sourceStatus?.error ? { error: sourceStatus.error } : {}
 		};

package/dist/src/connectors/connection-candidates.d.ts

@@ -0,0 +1,11 @@
+export declare function connectionCandidates(query: string): {
+    candidateRef: string;
+    label: string;
+    capabilities: string[];
+}[];
+export declare function resolveConnectionCandidate(ref: string): {
+    key: string;
+    connectorId: string;
+    label: string;
+    capabilities: string[];
+};

package/dist/src/connectors/connection-candidates.js

@@ -0,0 +1,58 @@
+import { getConnectorDefinition } from "./catalog.js";
+//#region src/connectors/connection-candidates.ts
+const CANDIDATES = [
+	{
+		toolkit: "outlook",
+		pattern: /outlook/i,
+		capabilities: ["email.search", "email.read"]
+	},
+	{
+		toolkit: "gmail",
+		pattern: /gmail|mail|email|邮件|邮箱/i,
+		capabilities: ["email.search", "email.read"]
+	},
+	{
+		toolkit: "googlecalendar",
+		pattern: /google.*calendar|calendar|日历|日程/i,
+		capabilities: ["calendar.read"]
+	},
+	{
+		toolkit: "googledrive",
+		pattern: /google.*drive|云盘|谷歌.*文档/i,
+		capabilities: ["files.search", "files.read"]
+	},
+	{
+		toolkit: "slack",
+		pattern: /slack/i,
+		capabilities: ["messages.search"]
+	},
+	{
+		toolkit: "notion",
+		pattern: /notion/i,
+		capabilities: ["pages.search", "pages.read"]
+	}
+];
+function connectionCandidates(query) {
+	return CANDIDATES.filter((item) => item.pattern.test(query)).flatMap((item) => {
+		const connectorId = `composio-${item.toolkit}`;
+		const definition = getConnectorDefinition(connectorId);
+		return definition ? [{
+			candidateRef: connectorId,
+			label: definition.displayName,
+			capabilities: item.capabilities
+		}] : [];
+	});
+}
+function resolveConnectionCandidate(ref) {
+	const item = CANDIDATES.find((item) => `composio-${item.toolkit}` === ref);
+	const definition = item ? getConnectorDefinition(ref) : void 0;
+	if (!item || !definition) throw new Error("Unknown connection candidate. Search for a supported app first.");
+	return {
+		key: `${ref}:default`,
+		connectorId: ref,
+		label: definition.displayName,
+		capabilities: item.capabilities
+	};
+}
+//#endregion
+export { connectionCandidates, resolveConnectionCandidate };

package/dist/src/connectors/connection-capabilities.d.ts

@@ -0,0 +1,4 @@
+import type { ConnectionNeed } from '@xopcai/gateway-contract';
+export declare function isToolInputSchema(value: unknown): value is Record<string, unknown>;
+export declare function capabilityActions(need: Pick<ConnectionNeed, 'connectorId' | 'capabilities'>): string[][];
+export declare function missingConnectionCapabilities(need: Pick<ConnectionNeed, 'connectorId' | 'capabilities'>, actions: Set<string>): string[];

package/dist/src/connectors/connection-capabilities.js

@@ -0,0 +1,37 @@
+//#region src/connectors/connection-capabilities.ts
+/** Supported actions for the task capabilities offered by connection candidates. */
+const CAPABILITY_ACTIONS = {
+	"composio-slack": { "messages.search": ["SLACK_SEARCH_ALL", "SLACK_SEARCH_MESSAGES"] },
+	"composio-gmail": {
+		"email.search": ["GMAIL_FETCH_EMAILS"],
+		"email.read": ["GMAIL_FETCH_EMAILS", "GMAIL_GET_EMAIL"]
+	},
+	"composio-outlook": {
+		"email.search": ["OUTLOOK_LIST_MESSAGES"],
+		"email.read": ["OUTLOOK_LIST_MESSAGES", "OUTLOOK_GET_MESSAGE"]
+	},
+	"composio-googlecalendar": { "calendar.read": ["GOOGLECALENDAR_EVENTS_LIST", "GOOGLECALENDAR_FIND_EVENT"] },
+	"composio-googledrive": {
+		"files.search": ["GOOGLEDRIVE_FIND_FILE", "GOOGLEDRIVE_LIST_FILES"],
+		"files.read": [
+			"GOOGLEDRIVE_DOWNLOAD_FILE",
+			"GOOGLEDRIVE_GET_FILE",
+			"GOOGLEDRIVE_GET_FILE_METADATA"
+		]
+	},
+	"composio-notion": {
+		"pages.search": ["NOTION_SEARCH"],
+		"pages.read": ["NOTION_FETCH_PAGE"]
+	}
+};
+function isToolInputSchema(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value) && value.type === "object");
+}
+function capabilityActions(need) {
+	return need.capabilities.map((capability) => /^[A-Z]+_/.test(capability) ? [capability] : CAPABILITY_ACTIONS[need.connectorId]?.[capability] ?? []);
+}
+function missingConnectionCapabilities(need, actions) {
+	return capabilityActions(need).flatMap((alternatives, index) => alternatives.some((action) => actions.has(action)) ? [] : [need.capabilities[index]]);
+}
+//#endregion
+export { capabilityActions, isToolInputSchema, missingConnectionCapabilities };

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

@@ -0,0 +1,43 @@
+import type { Config } from '../config/schema.js';
+import type { SessionInput } from '../storage/sqlite/session-input-repository.js';
+import { ComposioSessionsAdapter } from './composio-sessions.js';
+import type { ConnectionWaitSnapshot } from '@xopcai/gateway-contract';
+export type ConnectionAction = {
+    waitId: string;
+    expectedSessionId: string;
+    expectedVersion: number;
+    idempotencyKey: string;
+    action: 'connect' | 'check' | 'continue' | 'skip' | 'cancel' | 'select_account' | 'confirm_scope' | 'replace_source';
+    needKey?: string;
+    accountId?: string;
+    candidateRef?: string;
+};
+/** Authorization lives at click time. Chat history contains only immutable explanations. */
+export declare class ConnectionRecoveryService {
+    private readonly deps;
+    private readonly busy;
+    private timer?;
+    private polling;
+    start(): void;
+    stop(): void;
+    poll(): Promise<void>;
+    constructor(deps: {
+        getConfig: () => Config;
+        saveConfig: (config: Config) => Promise<{
+            saved: boolean;
+            error?: string;
+        }>;
+        drain: (sessionKey: string) => void;
+        adapter?: ComposioSessionsAdapter;
+    });
+    private get adapter();
+    snapshot(sessionKey: string): ConnectionWaitSnapshot;
+    private view;
+    private ensureInstallation;
+    private checkCapabilities;
+    preflight(input: SessionInput): Promise<boolean>;
+    act(sessionKey: string, action: ConnectionAction): Promise<{
+        snapshot: ConnectionWaitSnapshot;
+        authorizationUrl?: string;
+    }>;
+}