@xopcai/xopc 0.0.142 → 0.0.144

package/dist/src/connectors/composio.js

@@ -1,50 +1,60 @@
 import { CredentialResolver, init_credentials } from "../auth/credentials.js";
+import { getConnectorConnection, getConnectorInstallation, listConnectorConnections, upsertConnectorActionMetadata, upsertConnectorConnection, upsertConnectorInstallation } from "../storage/sqlite/connector-repository.js";
+import { ComposioSessionsAdapter } from "./composio-sessions.js";
+import { COMPOSIO_AGENT_READY_TOOLKITS, COMPOSIO_TOOLKIT_DISPLAY_NAMES, connectorDefinitionFromComposioToolkit } from "./composio-catalog.js";
 import { consumeConnectorSetupSecretRef } from "./setup-secrets.js";
 //#region src/connectors/composio.ts
 init_credentials();
-const COMPOSIO_TOOLKITS = [
-	[
-		"gmail",
-		"Gmail",
-		"Read and send Gmail messages through Composio."
-	],
-	[
-		"googlecalendar",
-		"Google Calendar",
-		"Read and manage Google Calendar events through Composio."
-	],
-	[
-		"googledrive",
-		"Google Drive",
-		"Search and manage Google Drive files through Composio."
-	],
-	[
-		"notion",
-		"Notion",
-		"Search and update Notion pages and databases through Composio."
-	],
-	[
-		"slack",
-		"Slack",
-		"Read and send Slack workspace messages through Composio."
-	],
-	[
-		"github",
-		"GitHub via Composio",
-		"Work with GitHub repositories, issues, and pull requests through Composio."
-	],
-	[
-		"linear",
-		"Linear via Composio",
-		"Manage Linear issues and projects through Composio."
-	]
-];
 const COMPOSIO_API_KEY_PROVIDER = "connector-composio-api-key";
 const COMPOSIO_SCOPE_ORDER = {
 	read: 1,
 	write: 2,
 	admin: 3
 };
+const COMPOSIO_AGENT_READY = new Set(COMPOSIO_AGENT_READY_TOOLKITS);
+const STRICT_CURATED_TOOLKITS = new Set(["github"]);
+const READ_ACTION_TOKENS = [
+	"GET",
+	"LIST",
+	"SEARCH",
+	"FETCH",
+	"FIND",
+	"LOOKUP",
+	"RETRIEVE",
+	"READ",
+	"QUERY",
+	"CHECK",
+	"DESCRIBE",
+	"DOWNLOAD"
+];
+const WRITE_ACTION_TOKENS = [
+	"CREATE",
+	"UPDATE",
+	"SEND",
+	"POST",
+	"ADD",
+	"UPLOAD",
+	"REPLY",
+	"DRAFT",
+	"INVITE",
+	"ASSIGN",
+	"MOVE",
+	"COPY",
+	"EDIT",
+	"WRITE",
+	"PUBLISH",
+	"SCHEDULE"
+];
+const ADMIN_ACTION_TOKENS = [
+	"DELETE",
+	"REMOVE",
+	"REVOKE",
+	"TRASH",
+	"ARCHIVE",
+	"CANCEL",
+	"DISCONNECT",
+	"DEACTIVATE"
+];
 const COMPOSIO_CURATED_ACTIONS = {
 	gmail: {
 		GMAIL_FETCH_EMAILS: "read",
@@ -82,10 +92,45 @@ const COMPOSIO_CURATED_ACTIONS = {
 		SLACK_SEND_DIRECT_MESSAGE: "write"
 	},
 	github: {
+		GITHUB_GET_THE_AUTHENTICATED_USER: "read",
+		GITHUB_LIST_REPOSITORIES_FOR_THE_AUTHENTICATED_USER: "read",
+		GITHUB_GET_A_REPOSITORY: "read",
 		GITHUB_GET_REPOSITORY: "read",
+		GITHUB_LIST_REPOSITORY_COLLABORATORS: "read",
+		GITHUB_SEARCH_REPOSITORIES: "read",
+		GITHUB_SEARCH_CODE: "read",
+		GITHUB_SEARCH_ISSUES_AND_PULL_REQUESTS: "read",
+		GITHUB_SEARCH_USERS: "read",
 		GITHUB_LIST_REPOSITORY_ISSUES: "read",
+		GITHUB_GET_AN_ISSUE: "read",
+		GITHUB_LIST_ISSUE_COMMENTS: "read",
+		GITHUB_LIST_PULL_REQUESTS: "read",
+		GITHUB_GET_A_PULL_REQUEST: "read",
+		GITHUB_LIST_BRANCHES: "read",
+		GITHUB_GET_A_BRANCH: "read",
+		GITHUB_LIST_COMMITS: "read",
+		GITHUB_GET_A_COMMIT: "read",
+		GITHUB_CREATE_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER: "write",
+		GITHUB_CREATE_OR_UPDATE_FILE_CONTENTS: "write",
+		GITHUB_CREATE_A_COMMIT: "write",
+		GITHUB_CREATE_A_COMMIT_COMMENT: "write",
 		GITHUB_CREATE_AN_ISSUE: "write",
-		GITHUB_CREATE_PULL_REQUEST: "write"
+		GITHUB_UPDATE_AN_ISSUE: "write",
+		GITHUB_CREATE_AN_ISSUE_COMMENT: "write",
+		GITHUB_ADD_LABELS_TO_AN_ISSUE: "write",
+		GITHUB_ADD_ASSIGNEES_TO_AN_ISSUE: "write",
+		GITHUB_CREATE_A_PULL_REQUEST: "write",
+		GITHUB_CREATE_PULL_REQUEST: "write",
+		GITHUB_UPDATE_A_PULL_REQUEST: "write",
+		GITHUB_MERGE_A_PULL_REQUEST: "write",
+		GITHUB_CREATE_A_REVIEW_FOR_A_PULL_REQUEST: "write",
+		GITHUB_CREATE_A_REVIEW_COMMENT_FOR_A_PULL_REQUEST: "write",
+		GITHUB_CREATE_A_GIST: "write",
+		GITHUB_DELETE_A_REPOSITORY: "admin",
+		GITHUB_DELETE_A_REFERENCE: "admin",
+		GITHUB_DELETE_A_FILE: "admin",
+		GITHUB_ADD_A_REPOSITORY_COLLABORATOR: "admin",
+		GITHUB_CANCEL_A_WORKFLOW_RUN: "admin"
 	},
 	linear: {
 		LINEAR_LIST_ISSUES: "read",
@@ -94,42 +139,11 @@ const COMPOSIO_CURATED_ACTIONS = {
 		LINEAR_UPDATE_ISSUE: "write"
 	}
 };
-function composioBaseUrl() {
-	return process.env.XOPC_COMPOSIO_BASE_URL?.trim().replace(/\/+$/, "") || "https://backend.composio.dev/api/v3";
-}
-async function composioApiKey(resolver = new CredentialResolver()) {
-	const key = (await resolver.resolveApiKey(COMPOSIO_API_KEY_PROVIDER).catch(() => void 0))?.trim() || process.env.XOPC_COMPOSIO_API_KEY?.trim() || process.env.COMPOSIO_API_KEY?.trim();
-	if (!key) throw new Error("Composio API key is not configured. Set XOPC_COMPOSIO_API_KEY or connect the Composio API Key connector.");
-	return key;
-}
-async function composioFetch(path, init = {}, resolver = new CredentialResolver()) {
-	const apiKey = await composioApiKey(resolver);
-	const response = await fetch(`${composioBaseUrl()}${path}`, {
-		...init,
-		headers: {
-			Accept: "application/json",
-			"Content-Type": "application/json",
-			"x-api-key": apiKey,
-			Authorization: `Bearer ${apiKey}`,
-			...init.headers ?? {}
-		}
-	});
-	const data = await response.json().catch(async () => ({ error: await response.text().catch(() => response.statusText) }));
-	if (!response.ok) {
-		const record = data && typeof data === "object" && !Array.isArray(data) ? data : {};
-		throw new Error(String(record.error ?? record.message ?? response.statusText));
-	}
-	return data;
-}
-function arrayAt(payload, keys) {
-	if (Array.isArray(payload)) return payload;
-	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return [];
-	const record = payload;
-	for (const key of keys) if (Array.isArray(record[key])) return record[key];
-	return [];
-}
-function readString(value) {
-	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+const LOCAL_OWNER_PRINCIPAL = "local-owner";
+function toolkitFromConnectionMetadata(connection) {
+	const toolkit = connection.metadata.toolkit;
+	if (typeof toolkit !== "string" || !toolkit.trim()) throw new Error(`Composio connection "${connection.id}" does not contain toolkit metadata.`);
+	return toolkit;
 }
 function normalizeToolkit(toolkit) {
 	return toolkit.trim().toLowerCase().replace(/[^a-z0-9_]+/g, "");
@@ -137,8 +151,8 @@ function normalizeToolkit(toolkit) {
 function toolkitFromComposioSlug(slug) {
 	const upper = slug.trim().toUpperCase();
 	if (!upper) return void 0;
-	if (upper.startsWith("GOOGLECALENDAR_")) return "googlecalendar";
-	if (upper.startsWith("GOOGLEDRIVE_")) return "googledrive";
+	const known = [...COMPOSIO_AGENT_READY].sort((left, right) => right.length - left.length).find((toolkit) => upper === toolkit.toUpperCase() || upper.startsWith(`${toolkit.toUpperCase()}_`));
+	if (known) return known;
 	return upper.split("_")[0]?.toLowerCase() || void 0;
 }
 function scopeForComposioAction(slug) {
@@ -153,12 +167,39 @@ function scopeForComposioAction(slug) {
 		scope,
 		curated: true
 	};
+	if (STRICT_CURATED_TOOLKITS.has(toolkit)) return {
+		toolkit,
+		scope: "write",
+		curated: false
+	};
+	if (COMPOSIO_AGENT_READY.has(toolkit)) {
+		const tokens = slug.trim().toUpperCase().split("_");
+		if (tokens.some((token) => ADMIN_ACTION_TOKENS.some((verb) => token.startsWith(verb)))) return {
+			toolkit,
+			scope: "admin",
+			curated: true
+		};
+		if (tokens.some((token) => READ_ACTION_TOKENS.some((verb) => token.startsWith(verb)))) return {
+			toolkit,
+			scope: "read",
+			curated: true
+		};
+		if (tokens.some((token) => WRITE_ACTION_TOKENS.some((verb) => token.startsWith(verb)))) return {
+			toolkit,
+			scope: "write",
+			curated: true
+		};
+	}
 	return {
 		toolkit,
 		scope: "write",
 		curated: false
 	};
 }
+function isComposioActionAllowedByCatalog(slug) {
+	const action = scopeForComposioAction(slug);
+	return Boolean(action.toolkit && (action.curated || !STRICT_CURATED_TOOLKITS.has(action.toolkit)));
+}
 function getComposioToolkitScope(config, toolkit) {
 	const record = config?.connectors?.instances?.[`composio-${normalizeToolkit(toolkit)}`];
 	const raw = record && typeof record === "object" && !Array.isArray(record) ? record.scope : void 0;
@@ -177,6 +218,12 @@ function canUseComposioAction(config, slug) {
 		reason: `Unknown Composio toolkit for action: ${slug}`,
 		scope: action.scope
 	};
+	if (!isComposioActionAllowedByCatalog(slug)) return {
+		ok: false,
+		reason: `Composio action ${slug} is not in the curated ${action.toolkit} action catalog.`,
+		toolkit: action.toolkit,
+		scope: action.scope
+	};
 	if (!config?.connectors?.instances?.[`composio-${action.toolkit}`]) return {
 		ok: false,
 		reason: `Composio connector is not installed: ${action.toolkit}`,
@@ -210,6 +257,11 @@ const COMPOSIO_CONNECTORS = [{
 	category: "automation",
 	kind: "composio",
 	source: "builtin",
+	branding: {
+		logoUrl: "/connector-icons/composio.svg",
+		source: "composio-catalog"
+	},
+	verificationLevel: "verified",
 	capabilities: [
 		"auth.apiKey",
 		"tools",
@@ -229,92 +281,228 @@ const COMPOSIO_CONNECTORS = [{
 	}] },
 	runtime: {
 		type: "composio",
-		toolkit: "composio"
-	}
-}, ...COMPOSIO_TOOLKITS.map(([toolkit, displayName, description]) => ({
-	id: `composio-${toolkit}`,
-	version: "1.0.0",
-	displayName,
-	description,
-	category: "automation",
-	kind: "composio",
-	source: "builtin",
-	capabilities: [
-		"tools",
-		"auth.oauth",
-		"events",
-		"workflows"
-	],
-	tags: ["composio", toolkit],
-	auth: { mode: "none" },
-	setup: {},
-	runtime: {
-		type: "composio",
-		toolkit
+		toolkit: "composio",
+		role: "credential"
+	},
+	integrationStrategy: {
+		lane: "composio",
+		workload: "long_tail",
+		preferred: true
 	}
-}))];
+}, ...COMPOSIO_AGENT_READY_TOOLKITS.map((toolkit) => {
+	return {
+		...connectorDefinitionFromComposioToolkit({
+			slug: toolkit,
+			name: COMPOSIO_TOOLKIT_DISPLAY_NAMES[toolkit],
+			isNoAuth: false,
+			connected: false
+		}),
+		version: "1.0.0"
+	};
+})];
 async function saveComposioApiKey(input, resolver = new CredentialResolver()) {
 	const raw = input.secrets?.COMPOSIO_API_KEY;
 	const resolved = typeof raw === "string" && raw.trim().startsWith("secret://") ? consumeConnectorSetupSecretRef(raw) : raw;
-	if (typeof resolved === "string" && resolved.trim()) await resolver.saveApiKey(COMPOSIO_API_KEY_PROVIDER, resolved.trim(), { profileName: "default" });
+	if (typeof resolved !== "string" || !resolved.trim()) throw new Error("Composio API key is required.");
+	await resolver.saveApiKey(COMPOSIO_API_KEY_PROVIDER, resolved.trim(), { profileName: "default" });
 }
 async function listComposioConnections(resolver = new CredentialResolver()) {
-	return arrayAt(await composioFetch("/connected_accounts", {}, resolver), [
-		"items",
-		"connected_accounts",
-		"connections",
-		"data"
-	]).flatMap((item) => {
-		if (!item || typeof item !== "object" || Array.isArray(item)) return [];
-		const row = item;
-		const toolkit = readString(row.toolkit_slug ?? row.toolkit ?? row.appName ?? row.app_name);
-		const id = readString(row.id ?? row.uuid ?? row.connectedAccountId ?? row.connected_account_id);
-		if (!toolkit || !id) return [];
-		return [{
-			id,
-			toolkit,
-			status: readString(row.status) ?? "unknown",
-			accountEmail: readString(row.accountEmail ?? row.account_email ?? row.email),
-			workspace: readString(row.workspace ?? row.teamName ?? row.team_name),
-			username: readString(row.username ?? row.name)
-		}];
+	await new ComposioSessionsAdapter({ resolver }).syncConnections({ principalId: LOCAL_OWNER_PRINCIPAL });
+	return listConnectorConnections({ principalId: LOCAL_OWNER_PRINCIPAL }).filter((connection) => connection.provider === "composio").map((connection) => ({
+		id: connection.id,
+		providerConnectionId: connection.providerConnectionId,
+		toolkit: toolkitFromConnectionMetadata(connection),
+		status: connection.status,
+		alias: connection.alias,
+		isDefault: connection.isDefault,
+		accountEmail: typeof connection.identity.email === "string" ? connection.identity.email : void 0,
+		workspace: typeof connection.identity.workspace === "string" ? connection.identity.workspace : void 0,
+		username: typeof connection.identity.username === "string" ? connection.identity.username : void 0,
+		connectedAt: connection.connectedAt,
+		lastError: connection.lastError
+	}));
+}
+async function inspectComposioConnectorHealth(toolkit, resolver = new CredentialResolver()) {
+	const normalizedToolkit = normalizeToolkit(toolkit);
+	try {
+		const connections = (await listComposioConnections(resolver)).filter((connection) => connection.toolkit.toLowerCase() === normalizedToolkit);
+		const activeConnections = connections.filter((connection) => connection.status === "active").length;
+		const affectedConnections = connections.filter((connection) => connection.status === "expired" || connection.status === "failed").length;
+		if (activeConnections > 0) return {
+			toolkit: normalizedToolkit,
+			status: "connected",
+			activeConnections,
+			affectedConnections,
+			checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			message: `${activeConnections} active account connection${activeConnections === 1 ? "" : "s"}.`,
+			recovery: "none"
+		};
+		if (affectedConnections > 0) return {
+			toolkit: normalizedToolkit,
+			status: "reauthorization_required",
+			activeConnections: 0,
+			affectedConnections,
+			checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			message: "The account connection expired or failed and must be authorized again.",
+			recovery: "reconnect"
+		};
+		return {
+			toolkit: normalizedToolkit,
+			status: "disconnected",
+			activeConnections: 0,
+			affectedConnections: 0,
+			checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			message: "No active account is connected.",
+			recovery: "connect"
+		};
+	} catch (error) {
+		const failure = classifyComposioHealthError(error);
+		return {
+			toolkit: normalizedToolkit,
+			status: "degraded",
+			activeConnections: 0,
+			affectedConnections: 0,
+			checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			message: failure.message,
+			recovery: "retry",
+			errorCode: failure.code
+		};
+	}
+}
+function classifyComposioHealthError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	if (/api key is not configured|missing.*api key/i.test(message)) return {
+		code: "missing_credential",
+		message
+	};
+	if (/\b401\b|unauthori[sz]ed|invalid api key|authentication failed/i.test(message)) return {
+		code: "unauthorized",
+		message: "Composio rejected the configured project API key."
+	};
+	if (/\b403\b|forbidden|insufficient permission|permission denied/i.test(message)) return {
+		code: "forbidden",
+		message: "The Composio project API key does not have the required permissions."
+	};
+	if (/timed?\s*out|timeout|aborterror/i.test(message)) return {
+		code: "timeout",
+		message: "The Composio health request timed out."
+	};
+	if (/fetch failed|network|econn|enotfound|eai_again|socket|tls/i.test(message)) return {
+		code: "network",
+		message: "The gateway could not reach the Composio API."
+	};
+	return {
+		code: "provider_error",
+		message
+	};
+}
+function getComposioInstallationPolicy(config, toolkit) {
+	const normalizedToolkit = normalizeToolkit(toolkit);
+	const connectorId = `composio-${normalizedToolkit}`;
+	const id = `${connectorId}-${LOCAL_OWNER_PRINCIPAL}`;
+	const existing = getConnectorInstallation(id);
+	return upsertConnectorInstallation({
+		id,
+		connectorId,
+		principalId: LOCAL_OWNER_PRINCIPAL,
+		enabled: existing?.enabled ?? true,
+		allowedAgentIds: existing?.allowedAgentIds ?? [],
+		maxScope: getComposioToolkitScope(config, normalizedToolkit),
+		confirmationPolicy: existing?.confirmationPolicy ?? "writes",
+		selectedConnectionIds: existing?.selectedConnectionIds ?? [],
+		createdAt: existing?.createdAt
 	});
 }
-async function startComposioAuthorize(toolkit, resolver = new CredentialResolver()) {
-	const payload = await composioFetch("/connected_accounts", {
-		method: "POST",
-		body: JSON.stringify({
-			toolkit_slug: toolkit,
-			toolkit,
-			auth_config: {}
-		})
-	}, resolver);
-	const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-	const connectUrl = readString(record.redirect_url ?? record.redirectUrl ?? record.connect_url ?? record.connectUrl);
-	if (!connectUrl) throw new Error("Composio authorize did not return a connect URL.");
+function updateComposioInstallationPolicy(config, toolkit, patch) {
+	const current = getComposioInstallationPolicy(config, toolkit);
+	return upsertConnectorInstallation({
+		...current,
+		allowedAgentIds: patch.allowedAgentIds ?? current.allowedAgentIds,
+		confirmationPolicy: patch.confirmationPolicy ?? current.confirmationPolicy,
+		selectedConnectionIds: patch.selectedConnectionIds ?? current.selectedConnectionIds
+	});
+}
+function updateComposioConnection(id, patch) {
+	const connection = getConnectorConnection(id);
+	if (!connection || connection.provider !== "composio" || connection.principalId !== LOCAL_OWNER_PRINCIPAL) throw new Error("Composio connection not found.");
+	upsertConnectorConnection({
+		...connection,
+		alias: patch.alias === void 0 ? connection.alias : patch.alias.trim() || void 0,
+		isDefault: patch.isDefault ?? connection.isDefault
+	});
+	const updated = getConnectorConnection(id);
 	return {
-		toolkit,
-		connectUrl,
-		connectionId: readString(record.id ?? record.connectionId ?? record.connected_account_id)
+		id: updated.id,
+		providerConnectionId: updated.providerConnectionId,
+		toolkit: toolkitFromConnectionMetadata(updated),
+		status: updated.status,
+		alias: updated.alias,
+		isDefault: updated.isDefault,
+		accountEmail: typeof updated.identity.email === "string" ? updated.identity.email : void 0,
+		workspace: typeof updated.identity.workspace === "string" ? updated.identity.workspace : void 0,
+		username: typeof updated.identity.username === "string" ? updated.identity.username : void 0,
+		connectedAt: updated.connectedAt,
+		lastError: updated.lastError
+	};
+}
+async function refreshComposioConnection(id, resolver = new CredentialResolver()) {
+	const connection = getConnectorConnection(id);
+	if (!connection || connection.provider !== "composio" || connection.principalId !== LOCAL_OWNER_PRINCIPAL) throw new Error("Composio connection not found.");
+	await new ComposioSessionsAdapter({ resolver }).refreshConnection(connection);
+}
+async function revokeComposioConnection(id, resolver = new CredentialResolver()) {
+	const connection = getConnectorConnection(id);
+	if (!connection || connection.provider !== "composio" || connection.principalId !== LOCAL_OWNER_PRINCIPAL) throw new Error("Composio connection not found.");
+	await new ComposioSessionsAdapter({ resolver }).revokeConnection(connection);
+}
+async function startComposioAuthorize(connectorId, toolkit, resolver = new CredentialResolver()) {
+	const normalizedToolkit = normalizeToolkit(toolkit);
+	const authorization = await new ComposioSessionsAdapter({ resolver }).authorize({
+		principalId: LOCAL_OWNER_PRINCIPAL,
+		toolkit: normalizedToolkit,
+		installationId: getConnectorInstallation(`${connectorId}-${LOCAL_OWNER_PRINCIPAL}`)?.id
+	});
+	if (!authorization.connectUrl) throw new Error("Composio authorize did not return a connect URL.");
+	return {
+		toolkit: authorization.toolkit,
+		connectUrl: authorization.connectUrl,
+		connectionId: authorization.connectionId
 	};
 }
 async function listComposioTools(toolkit, config, resolver = new CredentialResolver()) {
-	return arrayAt(await composioFetch(`/tools?toolkit_slug=${encodeURIComponent(toolkit)}`, {}, resolver), [
-		"items",
-		"tools",
-		"data"
-	]).flatMap((item) => {
-		if (!item || typeof item !== "object" || Array.isArray(item)) return [];
-		const row = item;
-		const slug = readString(row.slug ?? row.name);
+	const normalizedToolkit = normalizeToolkit(toolkit);
+	const payload = await (await new ComposioSessionsAdapter({ resolver }).createSession({
+		principalId: LOCAL_OWNER_PRINCIPAL,
+		toolkits: [normalizedToolkit]
+	})).search({
+		query: `List the available ${normalizedToolkit} actions and their exact input contracts.`,
+		toolkits: [normalizedToolkit]
+	});
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return [];
+	const schemas = payload.toolSchemas;
+	if (!schemas || typeof schemas !== "object" || Array.isArray(schemas)) return [];
+	return Object.values(schemas).flatMap((value) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+		const row = value;
+		const slug = typeof row.toolSlug === "string" ? row.toolSlug : void 0;
 		if (!slug) return [];
 		const action = scopeForComposioAction(slug);
-		if (!(config ? canUseComposioAction(config, slug).ok : true)) return [];
+		if (config && !canUseComposioAction(config, slug).ok) return [];
+		const inputSchema = row.inputSchema;
+		upsertConnectorActionMetadata({
+			connectorId: `composio-${normalizedToolkit}`,
+			actionId: slug,
+			toolkit: normalizedToolkit,
+			scope: action.scope,
+			curated: action.curated,
+			inputSchema,
+			cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
 		return [{
 			slug,
-			name: readString(row.name),
-			description: readString(row.description),
-			inputSchema: row.inputSchema ?? row.input_schema ?? row.parameters,
+			name: slug,
+			description: typeof row.description === "string" ? row.description : void 0,
+			inputSchema,
 			scope: action.scope,
 			curated: action.curated
 		}];
@@ -323,12 +511,47 @@ async function listComposioTools(toolkit, config, resolver = new CredentialResol
 async function executeComposioTool(params, resolver = new CredentialResolver()) {
 	const allowed = canUseComposioAction(params.config, params.slug);
 	if (allowed.ok === false) throw new Error(allowed.reason);
-	return composioFetch(`/tools/${encodeURIComponent(params.slug)}/execute`, {
-		method: "POST",
-		body: JSON.stringify({ arguments: params.arguments ?? {} })
-	}, resolver);
+	if (!allowed.toolkit) throw new Error(`Unknown Composio toolkit for action: ${params.slug}`);
+	const connectorId = `composio-${allowed.toolkit}`;
+	const installation = upsertConnectorInstallation({
+		id: `${connectorId}-${LOCAL_OWNER_PRINCIPAL}`,
+		connectorId,
+		principalId: LOCAL_OWNER_PRINCIPAL,
+		enabled: true,
+		allowedAgentIds: [],
+		maxScope: getComposioToolkitScope(params.config, allowed.toolkit),
+		confirmationPolicy: "writes",
+		selectedConnectionIds: []
+	});
+	const connection = listConnectorConnections({
+		principalId: LOCAL_OWNER_PRINCIPAL,
+		connectorId
+	}).find((candidate) => candidate.status === "active" && candidate.isDefault) ?? listConnectorConnections({
+		principalId: LOCAL_OWNER_PRINCIPAL,
+		connectorId
+	}).find((candidate) => candidate.status === "active");
+	const result = await new ComposioSessionsAdapter({ resolver }).executeWithPolicy({
+		context: {
+			principalId: LOCAL_OWNER_PRINCIPAL,
+			toolkits: [allowed.toolkit]
+		},
+		installation,
+		connection,
+		action: {
+			connectorId,
+			actionId: params.slug,
+			toolkit: allowed.toolkit,
+			scope: allowed.scope,
+			curated: scopeForComposioAction(params.slug).curated,
+			cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+		},
+		args: params.arguments && typeof params.arguments === "object" && !Array.isArray(params.arguments) ? params.arguments : {},
+		confirmed: true
+	});
+	if (result.decision !== "allowed") throw new Error(result.reason);
+	return result.result;
 }
 //#endregion
-export { COMPOSIO_CONNECTORS, canUseComposioAction, executeComposioTool, getComposioToolkitScope, listComposioConnections, listComposioTools, saveComposioApiKey, scopeForComposioAction, setComposioToolkitScope, startComposioAuthorize, toolkitFromComposioSlug };
+export { COMPOSIO_CONNECTORS, canUseComposioAction, executeComposioTool, getComposioInstallationPolicy, getComposioToolkitScope, inspectComposioConnectorHealth, isComposioActionAllowedByCatalog, listComposioConnections, listComposioTools, refreshComposioConnection, revokeComposioConnection, saveComposioApiKey, scopeForComposioAction, setComposioToolkitScope, startComposioAuthorize, toolkitFromComposioSlug, updateComposioConnection, updateComposioInstallationPolicy };
 
 //# sourceMappingURL=composio.js.map