@xopcai/xopc 0.0.187 → 0.0.188

package/dist/src/agent/mcp/bundle-mcp-materialize.js

@@ -1,183 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { init_string_coerce, normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "../../utils/string-coerce.js";
-import { buildSafeToolName, normalizeReservedToolNames } from "./bundle-mcp-names.js";
-import { setPluginToolMeta } from "./mcp-tool-meta.js";
-import crypto from "node:crypto";
-//#region src/agent/mcp/bundle-mcp-materialize.ts
-init_logger();
-init_string_coerce();
-const log = createLogger("Mcp:Bundle");
-function readMaterializedToolDescription(tool) {
-	const raw = tool;
-	return normalizeOptionalString(raw.description) ?? normalizeOptionalString(raw.label) ?? tool.name;
-}
-function mapBundleMcpToolsForGateway(tools, serverId) {
-	const prefix = `${serverId.trim()}__`;
-	return tools.filter((tool) => tool.name.startsWith(prefix)).map((tool) => ({
-		name: tool.name,
-		shortName: tool.name.slice(prefix.length),
-		description: readMaterializedToolDescription(tool)
-	}));
-}
-async function listBundleMcpServerToolsForGateway(params) {
-	const runtime = await createBundleMcpToolRuntime({
-		workspaceDir: params.workspaceDir,
-		cfg: params.cfg
-	});
-	try {
-		return mapBundleMcpToolsForGateway(runtime.tools, params.serverId);
-	} finally {
-		await runtime.dispose();
-	}
-}
-function mapBundleMcpResourcesForGateway(resources, serverId) {
-	return resources.filter((resource) => resource.serverName === serverId).map((resource) => ({
-		uri: resource.uri,
-		name: resource.name,
-		title: resource.title,
-		description: resource.description,
-		mimeType: resource.mimeType
-	}));
-}
-function mapBundleMcpPromptsForGateway(prompts, serverId) {
-	return prompts.filter((prompt) => prompt.serverName === serverId).map((prompt) => ({
-		name: prompt.name,
-		title: prompt.title,
-		description: prompt.description,
-		argumentCount: prompt.argumentCount
-	}));
-}
-async function listBundleMcpServerCapabilitiesForGateway(params) {
-	const createRuntime = (await import("./bundle-mcp-runtime.js")).createSessionMcpRuntime;
-	const runtime = createRuntime({
-		sessionId: `bundle-mcp:${crypto.randomUUID()}`,
-		workspaceDir: params.workspaceDir,
-		cfg: params.cfg
-	});
-	try {
-		const catalog = await runtime.getCatalog();
-		const tools = mapBundleMcpToolsForGateway(await materializeBundleMcpToolsForRun({ runtime }).then(async (toolRuntime) => {
-			try {
-				return toolRuntime.tools;
-			} finally {
-				await toolRuntime.dispose();
-			}
-		}), params.serverId);
-		const resources = mapBundleMcpResourcesForGateway(catalog.resources, params.serverId);
-		const prompts = mapBundleMcpPromptsForGateway(catalog.prompts, params.serverId);
-		return {
-			serverId: params.serverId,
-			toolCount: tools.length,
-			resourceCount: resources.length,
-			promptCount: prompts.length,
-			tools,
-			resources,
-			prompts
-		};
-	} finally {
-		await runtime.dispose();
-	}
-}
-function toAgentToolResult(params) {
-	const content = Array.isArray(params.result.content) ? params.result.content : [];
-	const normalizedContent = content.length > 0 ? content : params.result.structuredContent !== void 0 ? [{
-		type: "text",
-		text: JSON.stringify(params.result.structuredContent, null, 2)
-	}] : [{
-		type: "text",
-		text: JSON.stringify({
-			status: params.result.isError === true ? "error" : "ok",
-			server: params.serverName,
-			tool: params.toolName
-		}, null, 2)
-	}];
-	const details = {
-		mcpServer: params.serverName,
-		mcpTool: params.toolName
-	};
-	if (params.result.structuredContent !== void 0) details.structuredContent = params.result.structuredContent;
-	if (params.result.isError === true) details.status = "error";
-	return {
-		content: normalizedContent,
-		details
-	};
-}
-async function materializeBundleMcpToolsForRun(params) {
-	let disposed = false;
-	const releaseLease = params.runtime.acquireLease?.();
-	params.runtime.markUsed();
-	let catalog;
-	try {
-		catalog = await params.runtime.getCatalog();
-	} catch (error) {
-		releaseLease?.();
-		throw error;
-	}
-	const reservedNames = normalizeReservedToolNames(params.reservedToolNames);
-	const tools = [];
-	const sortedCatalogTools = [...catalog.tools].toSorted((a, b) => {
-		const serverOrder = a.safeServerName.localeCompare(b.safeServerName);
-		if (serverOrder !== 0) return serverOrder;
-		const toolOrder = a.toolName.localeCompare(b.toolName);
-		if (toolOrder !== 0) return toolOrder;
-		return a.serverName.localeCompare(b.serverName);
-	});
-	for (const tool of sortedCatalogTools) {
-		const originalName = tool.toolName.trim();
-		if (!originalName) continue;
-		const safeToolName = buildSafeToolName({
-			serverName: tool.safeServerName,
-			toolName: originalName,
-			reservedNames
-		});
-		if (safeToolName !== `${tool.safeServerName}__${originalName}`) log.warn(`bundle-mcp: tool "${tool.toolName}" from server "${tool.serverName}" registered as "${safeToolName}" to keep the tool name provider-safe.`);
-		reservedNames.add(normalizeLowercaseStringOrEmpty(safeToolName));
-		const agentTool = {
-			name: safeToolName,
-			label: tool.title ?? tool.toolName,
-			description: tool.description || tool.title || tool.fallbackDescription,
-			parameters: tool.inputSchema,
-			execute: async (_toolCallId, input, signal) => {
-				params.runtime.markUsed();
-				const result = await params.runtime.callTool(tool.serverName, tool.toolName, input, signal);
-				return toAgentToolResult({
-					serverName: tool.serverName,
-					toolName: tool.toolName,
-					result
-				});
-			}
-		};
-		setPluginToolMeta(agentTool, {
-			pluginId: "bundle-mcp",
-			optional: false
-		});
-		tools.push(agentTool);
-	}
-	tools.sort((a, b) => a.name.localeCompare(b.name));
-	return {
-		tools,
-		dispose: async () => {
-			if (disposed) return;
-			disposed = true;
-			releaseLease?.();
-			await params.disposeRuntime?.();
-		}
-	};
-}
-async function createBundleMcpToolRuntime(params) {
-	const runtime = (params.createRuntime ?? (await import("./bundle-mcp-runtime.js")).createSessionMcpRuntime)({
-		sessionId: `bundle-mcp:${crypto.randomUUID()}`,
-		workspaceDir: params.workspaceDir,
-		cfg: params.cfg
-	});
-	return await materializeBundleMcpToolsForRun({
-		runtime,
-		reservedToolNames: params.reservedToolNames,
-		disposeRuntime: async () => {
-			await runtime.dispose();
-		}
-	});
-}
-//#endregion
-export { createBundleMcpToolRuntime, listBundleMcpServerCapabilitiesForGateway, listBundleMcpServerToolsForGateway, mapBundleMcpToolsForGateway, materializeBundleMcpToolsForRun };

package/dist/src/agent/mcp/mcp-tool-meta.d.ts

@@ -1,8 +0,0 @@
-import type { AgentTool } from '@earendil-works/pi-agent-core';
-export type McpToolMeta = {
-    pluginId: string;
-    optional?: boolean;
-};
-export declare function setPluginToolMeta(tool: AgentTool, meta: McpToolMeta): void;
-export declare function getPluginToolMeta(tool: AgentTool): McpToolMeta | undefined;
-export declare function isBundleMcpTool(tool: AgentTool): boolean;

package/dist/src/agent/mcp/mcp-tool-meta.js

@@ -1,13 +0,0 @@
-//#region src/agent/mcp/mcp-tool-meta.ts
-const MCP_TOOL_META = Symbol.for("xopc.mcpToolMeta");
-function setPluginToolMeta(tool, meta) {
-	tool[MCP_TOOL_META] = meta;
-}
-function getPluginToolMeta(tool) {
-	return tool[MCP_TOOL_META];
-}
-function isBundleMcpTool(tool) {
-	return getPluginToolMeta(tool)?.pluginId === "bundle-mcp";
-}
-//#endregion
-export { getPluginToolMeta, isBundleMcpTool, setPluginToolMeta };

package/dist/src/agent/mcp/resolve-embedded-mcp-tools.d.ts

@@ -1,14 +0,0 @@
-import type { AgentTool } from '@earendil-works/pi-agent-core';
-import type { Config } from '../../config/schema.js';
-export type ResolvedEmbeddedMcpTools = {
-    tools: AgentTool[];
-    dispose: () => Promise<void>;
-};
-export declare function resolveEmbeddedMcpToolsForTurn(params: {
-    sessionKey: string;
-    workspaceDir: string;
-    cfg?: Config;
-    baseTools: AgentTool[];
-    cleanupOnTurnEnd?: boolean;
-}): Promise<ResolvedEmbeddedMcpTools>;
-export declare function mergeTurnTools(baseTools: AgentTool[], mcpTools: AgentTool[]): AgentTool[];

package/dist/src/agent/mcp/resolve-embedded-mcp-tools.js

@@ -1,48 +0,0 @@
-import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
-import { isMcpToolDenied, shouldCreateBundleMcpRuntimeForAttempt } from "./bundle-mcp-policy.js";
-import { getOrCreateSessionMcpRuntime } from "./bundle-mcp-runtime.js";
-import { materializeBundleMcpToolsForRun } from "./bundle-mcp-materialize.js";
-import "./bundle-mcp-tools.js";
-//#region src/agent/mcp/resolve-embedded-mcp-tools.ts
-async function resolveEmbeddedMcpToolsForTurn(params) {
-	const profile = params.cfg ? resolveEffectiveAgentProfileForSession(params.cfg, params.sessionKey) : void 0;
-	const disabledTools = profile?.tools.denied;
-	if (!shouldCreateBundleMcpRuntimeForAttempt(params.cfg)) return {
-		tools: [],
-		dispose: async () => {}
-	};
-	const reserved = new Set(params.baseTools.map((t) => t.name));
-	const runtime = await getOrCreateSessionMcpRuntime({
-		sessionId: params.sessionKey,
-		sessionKey: params.sessionKey,
-		workspaceDir: params.workspaceDir,
-		cfg: params.cfg
-	});
-	let materialized;
-	try {
-		materialized = await materializeBundleMcpToolsForRun({
-			runtime,
-			reservedToolNames: reserved,
-			disposeRuntime: params.cleanupOnTurnEnd ? async () => {
-				await runtime.dispose();
-			} : void 0
-		});
-	} catch (error) {
-		await runtime.dispose().catch(() => {});
-		throw error;
-	}
-	return {
-		tools: materialized.tools.filter((tool) => {
-			if (disabledTools?.has(tool.name)) return false;
-			if (isMcpToolDenied(tool.name, profile?.manifest.tools.mcp)) return false;
-			return true;
-		}),
-		dispose: materialized.dispose
-	};
-}
-function mergeTurnTools(baseTools, mcpTools) {
-	if (mcpTools.length === 0) return baseTools;
-	return [...baseTools, ...mcpTools];
-}
-//#endregion
-export { mergeTurnTools, resolveEmbeddedMcpToolsForTurn };

package/dist/src/agent/tools/composio-tool.d.ts

@@ -1,21 +0,0 @@
-import type { AgentTool } from '@earendil-works/pi-agent-core';
-import type { Config } from '../../config/schema.js';
-import { ComposioSessionsAdapter } from '../../connectors/composio-sessions.js';
-type CurrentContext = {
-    channel: string;
-    chatId: string;
-    sessionKey: string;
-} | null;
-export type ComposioToolDeps = {
-    getConfig: () => Config | undefined;
-    getCurrentContext: () => CurrentContext;
-    agentId?: string;
-    adapter?: ComposioSessionsAdapter;
-};
-export declare function connectorPrincipalForSession(sessionKey: string | undefined): {
-    principalId: string;
-    agentId?: string;
-    isLocalOwner: boolean;
-};
-export declare function createComposioTools(deps: ComposioToolDeps): AgentTool[];
-export {};

package/dist/src/agent/tools/composio-tool.js

@@ -1,261 +0,0 @@
-import { consumeConnectorApproval, createConnectorApproval, getConnectorApproval, getConnectorInstallation, listConnectorActionMetadata, listConnectorConnections, listConnectorInstallations, upsertConnectorActionMetadata, upsertConnectorInstallation } from "../../storage/sqlite/connector-repository.js";
-import "../../storage/sqlite/index.js";
-import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
-import { connectorArgumentsHash, connectorArgumentsPreview } from "../../connectors/approval.js";
-import { ComposioSessionsAdapter } from "../../connectors/composio-sessions.js";
-import { getComposioToolkitScope, isComposioActionAllowedByCatalog, scopeForComposioAction } from "../../connectors/composio.js";
-import { getConnectorDefinition } from "../../connectors/catalog.js";
-import { Type } from "@sinclair/typebox";
-//#region src/agent/tools/composio-tool.ts
-init_session_key();
-const ComposioSearchSchema = Type.Object({
-	query: Type.String({ description: "Describe the task or information you need from connected apps." }),
-	toolkits: Type.Optional(Type.Array(Type.String(), {
-		maxItems: 8,
-		description: "Optional installed app slugs to search."
-	}))
-});
-const ComposioConnectSchema = Type.Object({
-	toolkit: Type.String({ description: "Installed Composio app slug, for example gmail or notion." }),
-	alias: Type.Optional(Type.String({ description: "Optional account label such as Personal or Work." }))
-});
-const ComposioExecuteSchema = Type.Object({
-	actionId: Type.String({ description: "Exact action slug returned by composio_search." }),
-	arguments: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Arguments matching the exact contract returned by composio_search." })),
-	connectionId: Type.Optional(Type.String({ description: "Local connection id when more than one account is connected." })),
-	approvalId: Type.Optional(Type.String({ description: "Approval id after the user explicitly approves a pending write/admin action." }))
-});
-function textResult(value) {
-	return {
-		content: [{
-			type: "text",
-			text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
-		}],
-		details: {}
-	};
-}
-function connectorPrincipalForSession(sessionKey) {
-	const parsed = parseSessionKey(sessionKey);
-	if (!parsed || parsed.source === "cli" || parsed.source === "webchat") return {
-		principalId: "local-owner",
-		agentId: parsed?.agentId,
-		isLocalOwner: true
-	};
-	return {
-		principalId: `channel:${parsed.source}:${parsed.accountId}:${parsed.peerKind}:${parsed.peerId}`,
-		agentId: parsed.agentId,
-		isLocalOwner: false
-	};
-}
-function installedConfigToolkits(config) {
-	return Object.entries(config?.connectors?.instances ?? {}).flatMap(([_instanceId, record]) => {
-		if (!record || typeof record !== "object" || Array.isArray(record)) return [];
-		const row = record;
-		const marker = row.xopcConnector;
-		if (marker && typeof marker === "object" && !Array.isArray(marker) && marker.enabled === false) return [];
-		const connectorId = marker && typeof marker === "object" && !Array.isArray(marker) ? marker.connectorId : void 0;
-		const runtime = row.runtime;
-		if (typeof connectorId !== "string" || !runtime || typeof runtime !== "object" || Array.isArray(runtime) || runtime.type !== "composio" || runtime.role !== "toolkit" || typeof runtime.toolkit !== "string") return [];
-		return [{
-			connectorId,
-			toolkit: runtime.toolkit
-		}];
-	});
-}
-function syncLocalOwnerInstallations(config) {
-	for (const { connectorId, toolkit } of installedConfigToolkits(config)) {
-		const id = `${connectorId}-local-owner`;
-		const existing = getConnectorInstallation(id);
-		upsertConnectorInstallation({
-			id,
-			connectorId,
-			principalId: "local-owner",
-			enabled: true,
-			allowedAgentIds: existing?.allowedAgentIds ?? [],
-			maxScope: getComposioToolkitScope(config, toolkit),
-			confirmationPolicy: existing?.confirmationPolicy ?? "writes",
-			selectedConnectionIds: existing?.selectedConnectionIds ?? [],
-			createdAt: existing?.createdAt
-		});
-	}
-}
-function availableInstallations(deps) {
-	const context = deps.getCurrentContext();
-	const principal = connectorPrincipalForSession(context?.sessionKey);
-	if (principal.isLocalOwner) syncLocalOwnerInstallations(deps.getConfig());
-	const agentId = deps.agentId ?? principal.agentId;
-	const installations = listConnectorInstallations(principal.principalId).filter((installation) => installation.enabled && composioToolkitFromConnectorId(installation.connectorId) !== void 0 && (installation.allowedAgentIds.length === 0 || Boolean(agentId && installation.allowedAgentIds.includes(agentId))));
-	return {
-		principalId: principal.principalId,
-		agentId,
-		context,
-		installations
-	};
-}
-function composioToolkitFromConnectorId(connectorId) {
-	const definition = getConnectorDefinition(connectorId);
-	return definition?.runtime.type === "composio" && definition.runtime.role === "toolkit" ? definition.runtime.toolkit : void 0;
-}
-function toolkitFromInstallation(installation) {
-	const toolkit = composioToolkitFromConnectorId(installation.connectorId);
-	if (!toolkit) throw new Error(`Connector installation is not a Composio toolkit: ${installation.connectorId}`);
-	return toolkit;
-}
-function toolkitForAction(actionId, candidates) {
-	const normalizedAction = actionId.trim().toUpperCase();
-	return [...candidates].sort((left, right) => right.length - left.length).find((toolkit) => normalizedAction === toolkit.toUpperCase() || normalizedAction.startsWith(`${toolkit.toUpperCase()}_`));
-}
-function contractFromSearch(connectorId, toolkit, actionId, value) {
-	const row = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-	const risk = scopeForComposioAction(actionId);
-	return {
-		connectorId,
-		actionId,
-		toolkit,
-		scope: risk.scope,
-		curated: risk.curated,
-		inputSchema: row.inputSchema,
-		cachedAt: (/* @__PURE__ */ new Date()).toISOString()
-	};
-}
-function createComposioTools(deps) {
-	if (installedConfigToolkits(deps.getConfig()).length === 0) return [];
-	const adapter = deps.adapter ?? new ComposioSessionsAdapter();
-	return [
-		{
-			name: "composio_search",
-			label: "🔎 Connected Apps Search",
-			description: "Discover exact actions and argument contracts for the connected apps allowed in this session. Call this before composio_execute.",
-			parameters: ComposioSearchSchema,
-			async execute(_toolCallId, params) {
-				const available = availableInstallations(deps);
-				const installedToolkits = available.installations.map(toolkitFromInstallation);
-				const requested = params.toolkits?.length ? params.toolkits.map((toolkit) => toolkit.toLowerCase()).filter((toolkit) => installedToolkits.includes(toolkit)) : installedToolkits;
-				if (requested.length === 0) return textResult("No connected apps are allowed for this user and agent.");
-				const result = await (await adapter.createSession({
-					principalId: available.principalId,
-					toolkits: requested
-				})).search({
-					query: params.query,
-					toolkits: requested
-				});
-				let visibleResult = result;
-				if (result && typeof result === "object" && !Array.isArray(result)) {
-					const schemas = result.toolSchemas;
-					if (schemas && typeof schemas === "object" && !Array.isArray(schemas)) {
-						const visibleSchemas = {};
-						for (const [actionId, schema] of Object.entries(schemas)) {
-							const toolkit = toolkitForAction(actionId, requested);
-							if (toolkit && requested.includes(toolkit)) {
-								if (!isComposioActionAllowedByCatalog(actionId)) continue;
-								visibleSchemas[actionId] = schema;
-								const installation = available.installations.find((candidate) => toolkitFromInstallation(candidate) === toolkit);
-								if (installation) upsertConnectorActionMetadata(contractFromSearch(installation.connectorId, toolkit, actionId, schema));
-							}
-						}
-						visibleResult = {
-							...result,
-							toolSchemas: visibleSchemas
-						};
-					}
-				}
-				return textResult(visibleResult);
-			}
-		},
-		{
-			name: "composio_connect",
-			label: "🔐 Connect App Account",
-			description: "Create an authorization link for an installed app. Never claims the connection succeeded until it is checked again.",
-			parameters: ComposioConnectSchema,
-			async execute(_toolCallId, params) {
-				const available = availableInstallations(deps);
-				const toolkit = params.toolkit.trim().toLowerCase();
-				const installation = available.installations.find((candidate) => toolkitFromInstallation(candidate) === toolkit);
-				if (!installation) return textResult("This app is not installed or is not allowed for this user and agent.");
-				const authorization = await adapter.authorize({
-					principalId: available.principalId,
-					toolkit,
-					installationId: installation.id,
-					alias: params.alias
-				});
-				return textResult({
-					status: authorization.status,
-					toolkit,
-					authorizationUrl: authorization.connectUrl,
-					connectionId: authorization.connectionId,
-					instruction: "Ask the user to open the authorization URL. Check the connection again after they finish."
-				});
-			}
-		},
-		{
-			name: "composio_execute",
-			label: "🔌 Connected App Action",
-			description: "Execute an exact action returned by composio_search. Write and admin actions require a user-approved approvalId.",
-			parameters: ComposioExecuteSchema,
-			async execute(_toolCallId, params) {
-				const available = availableInstallations(deps);
-				const toolkit = toolkitForAction(params.actionId, available.installations.map(toolkitFromInstallation));
-				if (!toolkit) return textResult("Unknown toolkit for this action. Call composio_search first.");
-				const installation = available.installations.find((candidate) => toolkitFromInstallation(candidate) === toolkit);
-				if (!installation) return textResult("This app is not allowed for this user and agent.");
-				if (!isComposioActionAllowedByCatalog(params.actionId)) return textResult("This action is not in the connector curated action catalog.");
-				const action = listConnectorActionMetadata(installation.connectorId).find((candidate) => candidate.actionId === params.actionId);
-				if (!action?.inputSchema) return textResult("The exact action contract is not cached. Call composio_search for this task before executing.");
-				await adapter.syncConnections({ principalId: available.principalId }).catch(() => []);
-				const connections = listConnectorConnections({
-					principalId: available.principalId,
-					connectorId: installation.connectorId
-				}).filter((connection) => connection.status === "active");
-				const connection = params.connectionId ? connections.find((candidate) => candidate.id === params.connectionId) : connections.find((candidate) => candidate.isDefault) ?? connections[0];
-				const args = params.arguments ?? {};
-				const argsHash = connectorArgumentsHash(args);
-				let confirmed = false;
-				if (params.approvalId) {
-					const pending = getConnectorApproval(params.approvalId);
-					if (!pending || pending.principalId !== available.principalId || pending.connectorId !== installation.connectorId || pending.actionId !== action.actionId || pending.sessionKey !== available.context?.sessionKey) return textResult("The connector approval is invalid for this session or action.");
-					confirmed = Boolean(consumeConnectorApproval(params.approvalId, argsHash));
-					if (!confirmed) return textResult("The connector approval is not approved, has expired, or was already used.");
-				}
-				const result = await adapter.executeWithPolicy({
-					context: {
-						principalId: available.principalId,
-						toolkits: [toolkit]
-					},
-					installation,
-					connection,
-					action,
-					args,
-					agentId: available.agentId,
-					sessionKey: available.context?.sessionKey,
-					confirmed
-				});
-				if (result.decision === "confirmation_required") {
-					const approval = createConnectorApproval({
-						principalId: available.principalId,
-						connectorId: installation.connectorId,
-						connectionId: connection?.id,
-						agentId: available.agentId,
-						sessionKey: available.context?.sessionKey,
-						actionId: action.actionId,
-						scope: action.scope,
-						argumentsHash: argsHash,
-						argumentsPreview: connectorArgumentsPreview(args),
-						expiresAt: new Date(Date.now() + 10 * 6e4).toISOString()
-					});
-					return textResult({
-						status: "confirmation_required",
-						approvalId: approval.id,
-						actionId: approval.actionId,
-						scope: approval.scope,
-						argumentsPreview: approval.argumentsPreview,
-						expiresAt: approval.expiresAt,
-						instruction: "Ask the user to approve this exact action in xopc, then retry with the approvalId and unchanged arguments."
-					});
-				}
-				return textResult(result.decision === "allowed" ? result.result : result.reason);
-			}
-		}
-	];
-}
-//#endregion
-export { connectorPrincipalForSession, createComposioTools };