@muxoai/platform 1.4.0 → 1.4.2

package/dist/providers/composio-sdk.js

@@ -1,4 +1,28 @@
+import { Composio } from "@composio/core";
+import { matchAppToolSlug } from "../mcp-schema.js";
+import { composioAuthConfigScopes, COMPOSIO_V3_WEBHOOK_EVENTS, ensureOAuthCallbackParams, ENTERPRISE_TOOLKITS_CATALOG, filterComposioToolkits, getComposioTriggerType, getSampleActionSchema, isStripeProjectsExclusiveProvider, listComposioTriggerTypes, parseComposioWebhookEnvelope, verifyComposioWebhookSignature, wrapMuxoConnectUrl, } from "../composio-catalog.js";
 const CURATED_APP_TOOLS = [
+    {
+        slug: "app.github.list_repos",
+        upstreamSlug: "GITHUB_LIST_REPOSITORIES_FOR_THE_AUTHENTICATED_USER",
+        name: "GitHub: List Repositories",
+        description: "List repositories accessible to the connected GitHub account via Muxo OAuth.",
+        lane: "composio_sdk",
+        providerSlug: "github",
+        providerName: "GitHub",
+        categories: ["developer_tools", "version_control", "git"],
+        riskLevel: "read",
+        requiresAuth: true,
+        creditCost: 0,
+        billingMode: "customer_oauth",
+        inputSchema: {
+            type: "object",
+            properties: {
+                visibility: { type: "string", enum: ["all", "public", "private"], default: "all" },
+                per_page: { type: "number", default: 20 },
+            },
+        },
+    },
     {
         slug: "app.github.create_issue",
         upstreamSlug: "GITHUB_CREATE_AN_ISSUE",
@@ -90,6 +114,27 @@ const CURATED_APP_TOOLS = [
             },
         },
     },
+    {
+        slug: "app.gmail.list_messages",
+        upstreamSlug: "GMAIL_FETCH_EMAILS",
+        name: "Gmail: List Messages",
+        description: "Read recent email threads from the connected Gmail inbox.",
+        lane: "composio_sdk",
+        providerSlug: "gmail",
+        providerName: "Gmail",
+        categories: ["email", "communication"],
+        riskLevel: "read",
+        requiresAuth: true,
+        creditCost: 0,
+        billingMode: "customer_oauth",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Gmail search query (e.g. 'is:unread')" },
+                max_results: { type: "number", default: 10 },
+            },
+        },
+    },
     {
         slug: "app.slack.send_message",
         upstreamSlug: "SLACK_SENDS_A_MESSAGE_TO_A_SLACK_CHANNEL",
@@ -112,6 +157,28 @@ const CURATED_APP_TOOLS = [
             },
         },
     },
+    {
+        slug: "app.slack.post_message",
+        upstreamSlug: "SLACK_SENDS_A_MESSAGE_TO_A_SLACK_CHANNEL",
+        name: "Slack: Post Channel Message",
+        description: "Post a message to a Slack channel using the connected Slack workspace.",
+        lane: "composio_sdk",
+        providerSlug: "slack",
+        providerName: "Slack",
+        categories: ["messaging", "team_chat", "communication", "chat"],
+        riskLevel: "write",
+        requiresAuth: true,
+        creditCost: 0,
+        billingMode: "customer_oauth",
+        inputSchema: {
+            type: "object",
+            required: ["channel", "text"],
+            properties: {
+                channel: { type: "string", description: "Slack channel ID or name" },
+                text: { type: "string", description: "Message text (Markdown supported)" },
+            },
+        },
+    },
     {
         slug: "app.notion.search_pages",
         upstreamSlug: "NOTION_SEARCH_NOTION_PAGE",
@@ -176,6 +243,138 @@ const CURATED_APP_TOOLS = [
             },
         },
     },
+    {
+        slug: "app.jira.create_issue",
+        upstreamSlug: "JIRA_CREATE_ISSUE",
+        name: "Jira: Create Issue",
+        description: "Create a Jira issue in a connected Atlassian project via Muxo OAuth.",
+        lane: "composio_sdk",
+        providerSlug: "jira",
+        providerName: "Jira",
+        categories: ["project_management", "engineering"],
+        riskLevel: "write",
+        requiresAuth: true,
+        creditCost: 0,
+        billingMode: "customer_oauth",
+        inputSchema: {
+            type: "object",
+            required: ["project_key", "summary"],
+            properties: {
+                project_key: { type: "string", description: "Jira project key (e.g. ENG)" },
+                summary: { type: "string", description: "Issue summary" },
+                description: { type: "string", description: "Issue description" },
+                issue_type: { type: "string", default: "Task" },
+            },
+        },
+    },
+    {
+        slug: "app.hubspot.search_contacts",
+        upstreamSlug: "HUBSPOT_SEARCH_CONTACTS",
+        name: "HubSpot: Search CRM Contacts",
+        description: "Search CRM contacts in the connected HubSpot account via Muxo OAuth.",
+        lane: "composio_sdk",
+        providerSlug: "hubspot",
+        providerName: "HubSpot",
+        categories: ["crm", "sales"],
+        riskLevel: "read",
+        requiresAuth: true,
+        creditCost: 0,
+        billingMode: "customer_oauth",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Contact name, email, or company search query" },
+                limit: { type: "number", default: 10 },
+            },
+        },
+    },
+    {
+        slug: "app.discord.send_message",
+        upstreamSlug: "DISCORD_SEND_MESSAGE",
+        name: "Discord: Send Channel Message",
+        description: "Send a message to a Discord channel using the connected Discord account.",
+        lane: "composio_sdk",
+        providerSlug: "discord",
+        providerName: "Discord",
+        categories: ["communication", "chat"],
+        riskLevel: "write",
+        requiresAuth: true,
+        creditCost: 0,
+        billingMode: "customer_oauth",
+        inputSchema: {
+            type: "object",
+            required: ["channel_id", "content"],
+            properties: {
+                channel_id: { type: "string", description: "Discord channel ID" },
+                content: { type: "string", description: "Message content" },
+            },
+        },
+    },
+    {
+        slug: "app.googledrive.search_files",
+        upstreamSlug: "GOOGLEDRIVE_FIND_FILE",
+        name: "Google Drive: Search Files & Folders",
+        description: "Search files and folders in the connected Google Drive account.",
+        lane: "composio_sdk",
+        providerSlug: "googledrive",
+        providerName: "Google Drive",
+        categories: ["storage", "docs", "productivity"],
+        riskLevel: "read",
+        requiresAuth: true,
+        creditCost: 0,
+        billingMode: "customer_oauth",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "File or folder search query" },
+                pageSize: { type: "number", default: 10 },
+            },
+        },
+    },
+    {
+        slug: "app.airtable.list_records",
+        upstreamSlug: "AIRTABLE_LIST_RECORDS",
+        name: "Airtable: List Base Records",
+        description: "List records from an Airtable base and table via Muxo OAuth.",
+        lane: "composio_sdk",
+        providerSlug: "airtable",
+        providerName: "Airtable",
+        categories: ["database", "productivity"],
+        riskLevel: "read",
+        requiresAuth: true,
+        creditCost: 0,
+        billingMode: "customer_oauth",
+        inputSchema: {
+            type: "object",
+            required: ["base_id", "table_name"],
+            properties: {
+                base_id: { type: "string", description: "Airtable Base ID" },
+                table_name: { type: "string", description: "Table name or ID" },
+                max_records: { type: "number", default: 20 },
+            },
+        },
+    },
+    {
+        slug: "app.salesforce.query_records",
+        upstreamSlug: "SALESFORCE_RUN_SOQL_QUERY",
+        name: "Salesforce: Query CRM Records",
+        description: "Run a read query against the connected Salesforce CRM org.",
+        lane: "composio_sdk",
+        providerSlug: "salesforce",
+        providerName: "Salesforce",
+        categories: ["crm", "sales"],
+        riskLevel: "read",
+        requiresAuth: true,
+        creditCost: 0,
+        billingMode: "customer_oauth",
+        inputSchema: {
+            type: "object",
+            required: ["query"],
+            properties: {
+                query: { type: "string", description: "SOQL query string" },
+            },
+        },
+    },
 ];
 function classifyComposioRisk(slug, tags = []) {
     const upper = `${slug} ${tags.join(" ")}`.toUpperCase();
@@ -192,11 +391,46 @@ function classifyComposioRisk(slug, tags = []) {
 export class ComposioSdkAdapter {
     config;
     liveToolsCache = new Map();
+    sdkClients = new Map();
+    customAuthConfigs = new Map();
+    activeTriggers = new Map();
+    triggerEvents = [];
     constructor(config) {
         this.config = config;
         for (const tool of CURATED_APP_TOOLS) {
             this.liveToolsCache.set(tool.slug, tool);
         }
+        this.hydrateEnterpriseSampleActions();
+    }
+    hydrateEnterpriseSampleActions() {
+        for (const tk of ENTERPRISE_TOOLKITS_CATALOG) {
+            if (isStripeProjectsExclusiveProvider(tk.slug))
+                continue;
+            for (const act of tk.sampleActions) {
+                if (act.muxoSlug.startsWith("resource."))
+                    continue;
+                if (!this.liveToolsCache.has(act.muxoSlug)) {
+                    this.liveToolsCache.set(act.muxoSlug, {
+                        slug: act.muxoSlug,
+                        upstreamSlug: act.upstreamSlug,
+                        name: act.name,
+                        description: `${tk.name}: ${act.name} (Muxo Connected Apps toolkit v${tk.pinnedVersion})`,
+                        lane: "composio_sdk",
+                        providerSlug: tk.slug,
+                        providerName: tk.name,
+                        categories: tk.categories,
+                        riskLevel: act.riskLevel,
+                        requiresAuth: true,
+                        creditCost: act.riskLevel === "read" ? 1 : 2,
+                        billingMode: "customer_oauth",
+                        inputSchema: getSampleActionSchema(act.muxoSlug, act.upstreamSlug),
+                    });
+                }
+            }
+        }
+    }
+    resolveApiKey(composioApiKey) {
+        return (composioApiKey || this.config.composioApiKey || "").trim();
     }
     get headers() {
         return {
@@ -204,12 +438,405 @@ export class ComposioSdkAdapter {
             "Content-Type": "application/json",
         };
     }
+    getHeaders(composioApiKey) {
+        return {
+            "x-api-key": this.resolveApiKey(composioApiKey),
+            "Content-Type": "application/json",
+        };
+    }
+    getComposioClient(composioApiKey) {
+        const apiKey = this.resolveApiKey(composioApiKey);
+        if (!apiKey)
+            return null;
+        const rawBaseUrl = (this.config.composioBaseUrl || "https://backend.composio.dev/api/v3").replace(/\/+$/, "");
+        const sdkBaseUrl = rawBaseUrl.replace(/\/api\/v3$/i, "") || "https://backend.composio.dev";
+        const cacheKey = `${apiKey}::${sdkBaseUrl}`;
+        const existing = this.sdkClients.get(cacheKey);
+        if (existing)
+            return existing;
+        try {
+            const client = new Composio({
+                apiKey,
+                baseURL: sdkBaseUrl,
+                allowTracking: false,
+                disableVersionCheck: true,
+            });
+            this.sdkClients.set(cacheKey, client);
+            return client;
+        }
+        catch {
+            return null;
+        }
+    }
+    getSdkInfo(composioApiKey) {
+        const apiKey = this.resolveApiKey(composioApiKey);
+        return {
+            sdkPackage: "@composio/core",
+            sdkVersion: "0.6.11",
+            configured: Boolean(apiKey),
+            usingCustomerByok: Boolean(composioApiKey && composioApiKey.trim()),
+            baseUrl: this.config.composioBaseUrl,
+            curatedToolCount: CURATED_APP_TOOLS.length,
+            cachedToolCount: this.liveToolsCache.size,
+            capabilities: [
+                "tools.getRawComposioTools",
+                "tools.getRawComposioToolBySlug",
+                "tools.execute",
+                "toolkits.authorize",
+                "connectedAccounts.initiate",
+                "connectedAccounts.get",
+                "connectedAccounts.list",
+                "authConfigs.list",
+                "triggers.getType",
+                "triggers.create",
+                "triggers.subscribe",
+                "triggers.verifyWebhook",
+            ],
+        };
+    }
+    getWebhookConfigInfo() {
+        return {
+            webhookUrl: "https://api.muxo.ai/webhooks",
+            legacyWebhookUrl: "https://api.muxo.ai/api/v1/triggers/webhook",
+            version: "V3",
+            events: [...COMPOSIO_V3_WEBHOOK_EVENTS],
+            secretConfigured: Boolean(this.config.composioWebhookSecret),
+            subscriptionId: this.config.composioWebhookSubscriptionId || null,
+            projectId: this.config.composioProjectId || null,
+            orgId: this.config.composioOrgId || null,
+            userId: this.config.composioUserId || null,
+        };
+    }
     getCuratedTools() {
         return Array.from(this.liveToolsCache.values());
     }
-    async searchTools(query, limit = 15) {
+    static classifyActionRisk(upstreamSlug, description = "") {
+        return classifyComposioRisk(upstreamSlug, [description]);
+    }
+    async listToolkits(params) {
+        // Hydrate dynamic sample actions into Muxo's liveToolsCache so agents can plan, inspect, and execute them immediately
+        this.hydrateEnterpriseSampleActions();
+        const list = filterComposioToolkits(params);
+        return {
+            toolkits: list,
+            total: list.length,
+            source: Boolean(this.resolveApiKey(params?.composioApiKey))
+                ? "composio_v3_sdk"
+                : "muxo_enterprise_catalog",
+        };
+    }
+    async createCustomAuthConfig(params) {
+        const tkSlug = params.toolkitSlug.toLowerCase().trim();
+        const scopeMode = params.scopeMode || "read_only";
+        const scopes = composioAuthConfigScopes(tkSlug, scopeMode, params.customScopes);
+        const sdk = this.getComposioClient(params.composioApiKey);
+        if (sdk) {
+            try {
+                const created = await sdk.authConfigs.create(tkSlug, {
+                    name: params.name || `muxo_${params.workspaceId}_${tkSlug}_${scopeMode}`,
+                    type: params.credentials?.client_id
+                        ? "use_custom_auth"
+                        : "use_composio_managed_auth",
+                    authScheme: params.authScheme,
+                    credentials: {
+                        ...(params.credentials || {}),
+                        scopes: scopes.join(","),
+                    },
+                });
+                const id = String(created?.id || `ac_${tkSlug}_${Date.now()}`);
+                this.customAuthConfigs.set(`${params.workspaceId}:${tkSlug}`, {
+                    authConfigId: id,
+                    toolkitSlug: tkSlug,
+                    authScheme: params.authScheme,
+                    scopeMode,
+                    scopes,
+                });
+                return {
+                    authConfigId: id,
+                    toolkitSlug: tkSlug,
+                    authScheme: params.authScheme,
+                    scopeMode,
+                    scopes,
+                    source: "composio_v3_sdk",
+                };
+            }
+            catch {
+                // Fall through to deterministic local auth config registration
+            }
+        }
+        const fallbackId = `ac_muxo_${tkSlug}_${scopeMode}_${Buffer.from(params.workspaceId).toString("hex").slice(0, 8)}`;
+        this.customAuthConfigs.set(`${params.workspaceId}:${tkSlug}`, {
+            authConfigId: fallbackId,
+            toolkitSlug: tkSlug,
+            authScheme: params.authScheme,
+            scopeMode,
+            scopes,
+        });
+        return {
+            authConfigId: fallbackId,
+            toolkitSlug: tkSlug,
+            authScheme: params.authScheme,
+            scopeMode,
+            scopes,
+            source: "muxo_managed",
+        };
+    }
+    listTriggerTypes(providerSlug) {
+        return listComposioTriggerTypes(providerSlug);
+    }
+    /**
+     * Check what configuration is required for a trigger (`composio.triggers.getType(slug)`).
+     */
+    async getTriggerType(triggerSlug, composioApiKey) {
+        const normalizedSlug = String(triggerSlug || "GITHUB_COMMIT_EVENT")
+            .toUpperCase()
+            .trim();
+        const fallback = getComposioTriggerType(normalizedSlug);
+        const sdk = this.getComposioClient(composioApiKey);
+        if (sdk) {
+            try {
+                const triggerType = await Promise.race([
+                    sdk.triggers.getType(normalizedSlug),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK triggers.getType timeout")), 4500)),
+                ]);
+                if (triggerType) {
+                    const toolkitSlug = String(triggerType.toolkit?.slug || fallback.providerSlug).toLowerCase();
+                    return {
+                        slug: String(triggerType.slug || normalizedSlug),
+                        providerSlug: toolkitSlug,
+                        name: String(triggerType.name || fallback.name),
+                        description: String(triggerType.description || fallback.description),
+                        config: triggerType.config && typeof triggerType.config === "object"
+                            ? triggerType.config
+                            : fallback.config,
+                        source: "composio_v3_sdk",
+                    };
+                }
+            }
+            catch {
+                // Fall back to Muxo trigger catalog when offline or unconfigured
+            }
+        }
+        return {
+            ...fallback,
+            source: "muxo_trigger_catalog",
+        };
+    }
+    /**
+     * Create a trigger with required config (`composio.triggers.create(userId, slug, { triggerConfig })`)
+     * and optionally subscribe to real-time trigger events (`composio.triggers.subscribe`).
+     */
+    async enableTrigger(params) {
+        const normalizedTriggerSlug = params.triggerSlug.toUpperCase().trim();
+        const triggerType = await this.getTriggerType(normalizedTriggerSlug, params.composioApiKey);
+        const providerSlug = (params.providerSlug ||
+            triggerType.providerSlug ||
+            "github")
+            .toLowerCase()
+            .trim();
+        const userId = params.userId || this.config.composioUserId || params.workspaceId;
+        const triggerConfig = params.config || {};
+        let upstreamTriggerId;
+        let source = "muxo_managed";
+        const sdk = this.getComposioClient(params.composioApiKey);
+        if (sdk) {
+            try {
+                const created = await Promise.race([
+                    sdk.triggers.create(userId, normalizedTriggerSlug, {
+                        ...(params.connectedAccountId
+                            ? { connectedAccountId: params.connectedAccountId }
+                            : {}),
+                        triggerConfig,
+                    }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK triggers.create timeout")), 6000)),
+                ]);
+                if (created?.triggerId) {
+                    upstreamTriggerId = String(created.triggerId);
+                    source = "composio_v3_sdk";
+                    if (params.subscribe) {
+                        await this.subscribeToTriggerEvents({
+                            workspaceId: params.workspaceId,
+                            triggerId: upstreamTriggerId,
+                            composioApiKey: params.composioApiKey,
+                        }).catch(() => { });
+                    }
+                }
+            }
+            catch {
+                // Fall through to deterministic local subscription record
+            }
+        }
+        const id = upstreamTriggerId ||
+            `trg_${providerSlug}_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+        const sub = {
+            id,
+            upstreamTriggerId,
+            workspaceId: params.workspaceId,
+            userId,
+            triggerSlug: normalizedTriggerSlug,
+            providerSlug,
+            connectedAccountId: params.connectedAccountId || `ca_${providerSlug}_${params.workspaceId.slice(0, 8)}`,
+            webhookUrl: params.webhookUrl ||
+                `https://api.muxo.ai/webhooks`,
+            config: triggerConfig,
+            status: "active",
+            source,
+            createdAt: new Date().toISOString(),
+        };
+        this.activeTriggers.set(id, sub);
+        return sub;
+    }
+    /**
+     * Subscribe to real-time trigger events via `@composio/core` (`composio.triggers.subscribe`).
+     */
+    async subscribeToTriggerEvents(params) {
+        const sdk = this.getComposioClient(params.composioApiKey);
+        if (!sdk) {
+            return { subscribed: false, triggerId: params.triggerId };
+        }
+        await sdk.triggers.subscribe((data) => {
+            const recordPayload = (data?.payload || data || {});
+            const triggerSlug = String(data?.triggerSlug || "GITHUB_COMMIT_EVENT").toUpperCase();
+            const providerSlug = String(data?.toolkitSlug || triggerSlug.split("_")[0] || "github").toLowerCase();
+            this.recordTriggerEvent({
+                id: `trgevt_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
+                workspaceId: params.workspaceId,
+                eventType: "composio.trigger.message",
+                webhookVersion: "V3",
+                triggerId: data?.id || params.triggerId,
+                triggerSlug,
+                providerSlug,
+                connectedAccountId: data?.metadata?.connectedAccount?.id,
+                userId: data?.userId || data?.metadata?.connectedAccount?.userId,
+                receivedAt: new Date().toISOString(),
+                promptInjectionScan: {
+                    safe: true,
+                    riskScore: 0,
+                    findings: [],
+                },
+                disposition: "dispatched",
+                payloadPreview: recordPayload,
+            });
+            params.onEvent?.(data);
+        }, {
+            ...(params.triggerId ? { triggerId: params.triggerId } : {}),
+            ...(params.toolkits ? { toolkits: params.toolkits } : {}),
+        });
+        return { subscribed: true, triggerId: params.triggerId };
+    }
+    /**
+     * Verify an incoming Composio webhook payload and HMAC-SHA256 signature.
+     */
+    async verifyWebhook(params) {
+        const secret = (params.secret ?? this.config.composioWebhookSecret ?? "").trim();
+        const sigCheck = await verifyComposioWebhookSignature({
+            rawPayload: params.rawPayload,
+            signatureHeader: params.signatureHeader,
+            webhookIdHeader: params.webhookIdHeader,
+            webhookTimestampHeader: params.webhookTimestampHeader,
+            secret,
+            toleranceSeconds: params.toleranceSeconds,
+        });
+        let parsedJson = {};
+        try {
+            parsedJson = JSON.parse(params.rawPayload || "{}");
+        }
+        catch {
+            parsedJson = {};
+        }
+        const envelope = parseComposioWebhookEnvelope(parsedJson, {
+            webhookId: params.webhookIdHeader,
+            webhookTimestamp: params.webhookTimestampHeader,
+        });
+        return {
+            verified: sigCheck.verified,
+            reason: sigCheck.reason,
+            envelope,
+        };
+    }
+    disableTriggersMatching(params) {
+        let count = 0;
+        for (const sub of this.activeTriggers.values()) {
+            if (params.workspaceId && sub.workspaceId !== params.workspaceId)
+                continue;
+            const matchesTriggerId = Boolean(params.triggerId) &&
+                (sub.id === params.triggerId || sub.upstreamTriggerId === params.triggerId);
+            const matchesConnectedAccount = Boolean(params.connectedAccountId) &&
+                sub.connectedAccountId === params.connectedAccountId;
+            const matchesSlug = Boolean(params.triggerSlug) &&
+                sub.triggerSlug.toUpperCase() === params.triggerSlug.toUpperCase();
+            if (matchesTriggerId || matchesConnectedAccount || matchesSlug) {
+                sub.status = "disabled";
+                count += 1;
+            }
+        }
+        return count;
+    }
+    listActiveTriggers(workspaceId) {
+        return Array.from(this.activeTriggers.values()).filter((t) => t.workspaceId === workspaceId);
+    }
+    recordTriggerEvent(record) {
+        this.triggerEvents.push(record);
+        if (this.triggerEvents.length > 500) {
+            this.triggerEvents.shift();
+        }
+    }
+    listTriggerEvents(workspaceId, limit = 50) {
+        return this.triggerEvents
+            .filter((e) => e.workspaceId === workspaceId)
+            .slice(-Math.max(1, limit))
+            .reverse();
+    }
+    mapRawComposioItemToMuxoTool(item) {
+        const upstreamSlug = String(item.slug || item.name || "");
+        if (!upstreamSlug)
+            return null;
+        const toolkitObj = (item.toolkit || {});
+        const providerSlug = String(toolkitObj.slug || upstreamSlug.split("_")[0] || "app").toLowerCase();
+        // Never surface Stripe Projects cloud infrastructure providers as Composio OAuth tools
+        if (isStripeProjectsExclusiveProvider(providerSlug)) {
+            return null;
+        }
+        const providerName = String(toolkitObj.name || providerSlug.charAt(0).toUpperCase() + providerSlug.slice(1));
+        const actionPart = upstreamSlug
+            .toLowerCase()
+            .replace(new RegExp(`^${providerSlug}_`), "");
+        const muxoSlug = `app.${providerSlug}.${actionPart}`;
+        const rawTags = Array.isArray(item.tags) ? item.tags.map(String) : [providerSlug];
+        const inputParams = item.inputParameters ||
+            item.input_parameters || {
+            type: "object",
+            properties: {},
+        };
+        const noAuth = Boolean(item.noAuth ?? item.no_auth);
+        const tool = {
+            slug: muxoSlug,
+            upstreamSlug,
+            name: `${providerName}: ${String(item.name || actionPart)}`,
+            description: String(item.description || `Execute ${upstreamSlug} via Muxo Connected Apps`),
+            lane: "composio_sdk",
+            providerSlug,
+            providerName,
+            categories: rawTags,
+            riskLevel: classifyComposioRisk(upstreamSlug, rawTags),
+            requiresAuth: !noAuth,
+            creditCost: 0,
+            billingMode: "customer_oauth",
+            inputSchema: inputParams,
+        };
+        this.liveToolsCache.set(muxoSlug, tool);
+        return tool;
+    }
+    async searchTools(query, limit = 15, composioApiKey, toolkit) {
         const q = (query || "").trim().toLowerCase();
+        const tk = (toolkit || "").trim().toLowerCase();
+        // Stripe Projects infrastructure providers belong to stripe_projects lane, not Composio OAuth
+        if (tk && isStripeProjectsExclusiveProvider(tk)) {
+            return [];
+        }
         const localMatches = this.getCuratedTools().filter((t) => {
+            if (tk && t.providerSlug.toLowerCase() !== tk)
+                return false;
             if (!q)
                 return true;
             return (t.slug.toLowerCase().includes(q) ||
@@ -217,82 +844,119 @@ export class ComposioSdkAdapter {
                 t.description.toLowerCase().includes(q) ||
                 t.providerSlug.toLowerCase().includes(q));
         });
-        if (!q || !this.config.composioApiKey) {
+        const apiKey = this.resolveApiKey(composioApiKey);
+        if ((!q && !tk) || !apiKey) {
             return localMatches.slice(0, limit);
         }
+        const merged = new Map();
+        for (const m of localMatches)
+            merged.set(m.slug, m);
+        // 1. Official @composio/core SDK tool discovery
+        const sdk = this.getComposioClient(composioApiKey);
+        if (sdk) {
+            try {
+                const rawTools = await Promise.race([
+                    sdk.tools.getRawComposioTools({
+                        search: q || undefined,
+                        toolkits: tk ? [tk] : undefined,
+                        limit: Math.min(limit, 20),
+                    }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK search timeout")), 4500)),
+                ]);
+                if (Array.isArray(rawTools)) {
+                    for (const rawItem of rawTools) {
+                        const tool = this.mapRawComposioItemToMuxoTool(rawItem);
+                        if (tool && !merged.has(tool.slug)) {
+                            merged.set(tool.slug, tool);
+                        }
+                    }
+                    if (merged.size > localMatches.length) {
+                        return Array.from(merged.values()).slice(0, limit);
+                    }
+                }
+            }
+            catch {
+                // Fall through to direct v3 REST endpoint
+            }
+        }
+        // 2. Direct Composio v3 API fallback
         try {
             const url = new URL(`${this.config.composioBaseUrl}/tools`);
-            url.searchParams.set("search", q);
+            if (q)
+                url.searchParams.set("search", q);
+            if (tk)
+                url.searchParams.set("toolkit_slug", tk);
             url.searchParams.set("limit", String(Math.min(limit, 15)));
             const res = await fetch(url.toString(), {
-                headers: this.headers,
+                headers: this.getHeaders(composioApiKey),
                 signal: AbortSignal.timeout(4500),
             });
             if (!res.ok)
-                return localMatches.slice(0, limit);
+                return Array.from(merged.values()).slice(0, limit);
             const data = (await res.json());
             const items = Array.isArray(data.items) ? data.items : [];
-            const merged = new Map();
-            for (const m of localMatches)
-                merged.set(m.slug, m);
             for (const item of items) {
-                const upstreamSlug = String(item.slug || item.name || "");
-                if (!upstreamSlug)
-                    continue;
-                const toolkitObj = (item.toolkit || {});
-                const providerSlug = String(toolkitObj.slug || upstreamSlug.split("_")[0] || "app").toLowerCase();
-                const providerName = String(toolkitObj.name || providerSlug.charAt(0).toUpperCase() + providerSlug.slice(1));
-                const actionPart = upstreamSlug
-                    .toLowerCase()
-                    .replace(new RegExp(`^${providerSlug}_`), "");
-                const muxoSlug = `app.${providerSlug}.${actionPart}`;
-                const tool = {
-                    slug: muxoSlug,
-                    upstreamSlug,
-                    name: `${providerName}: ${String(item.name || actionPart)}`,
-                    description: String(item.description || `Execute ${upstreamSlug} via Composio`),
-                    lane: "composio_sdk",
-                    providerSlug,
-                    providerName,
-                    categories: Array.isArray(item.tags) ? item.tags.map(String) : [providerSlug],
-                    riskLevel: classifyComposioRisk(upstreamSlug, Array.isArray(item.tags) ? item.tags.map(String) : []),
-                    requiresAuth: !Boolean(item.no_auth),
-                    creditCost: 0,
-                    billingMode: "customer_oauth",
-                    inputSchema: item.input_parameters || {
-                        type: "object",
-                        properties: {},
-                    },
-                };
-                this.liveToolsCache.set(muxoSlug, tool);
-                if (!merged.has(muxoSlug)) {
-                    merged.set(muxoSlug, tool);
+                const tool = this.mapRawComposioItemToMuxoTool(item);
+                if (tool && !merged.has(tool.slug)) {
+                    merged.set(tool.slug, tool);
                 }
             }
             return Array.from(merged.values()).slice(0, limit);
         }
         catch {
-            return localMatches.slice(0, limit);
+            return Array.from(merged.values()).slice(0, limit);
         }
     }
-    async inspectTool(slug) {
+    async inspectTool(slug, composioApiKey) {
         const normalizedSlug = slug === "app.gmail.list_messages" ? "app.gmail.fetch_emails" : slug;
         if (this.liveToolsCache.has(normalizedSlug)) {
             return this.liveToolsCache.get(normalizedSlug);
         }
-        if (!normalizedSlug.startsWith("app.") || !this.config.composioApiKey)
+        const apiKey = this.resolveApiKey(composioApiKey);
+        if (!normalizedSlug.startsWith("app.") || !apiKey)
             return null;
         const parts = normalizedSlug.split(".");
+        if (parts.length >= 2 && isStripeProjectsExclusiveProvider(parts[1] || "")) {
+            return null;
+        }
+        if (parts.length >= 3) {
+            const upstreamCandidate = parts.slice(1).join("_").toUpperCase();
+            const sdk = this.getComposioClient(composioApiKey);
+            if (sdk) {
+                try {
+                    const rawTool = await Promise.race([
+                        sdk.tools.getRawComposioToolBySlug(upstreamCandidate),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK inspect timeout")), 4000)),
+                    ]);
+                    if (rawTool) {
+                        const mapped = this.mapRawComposioItemToMuxoTool(rawTool);
+                        if (mapped)
+                            return mapped;
+                    }
+                }
+                catch {
+                    // Fall through to searchTools
+                }
+            }
+        }
         const query = parts.slice(1).join(" ");
-        const matches = await this.searchTools(query, 10);
-        return matches.find((m) => m.slug === normalizedSlug) || matches[0] || null;
+        const matches = await this.searchTools(query, 10, composioApiKey);
+        return matchAppToolSlug(normalizedSlug, matches);
     }
     async startConnection(params) {
         const providerSlug = params.providerSlug.toLowerCase().replace(/^app\./, "");
         const providerName = providerSlug.charAt(0).toUpperCase() + providerSlug.slice(1);
-        const callbackUrl = params.callbackUrl ||
+        const rawCallbackUrl = params.callbackUrl ||
             `${this.config.baseUrl}/oauth/callback?workspace_id=${encodeURIComponent(params.workspaceId)}&provider=${encodeURIComponent(providerSlug)}`;
-        if (!this.config.composioApiKey) {
+        const callbackUrl = ensureOAuthCallbackParams(rawCallbackUrl, params.workspaceId, providerSlug);
+        const wrapRedirect = (url, externalAccountId) => wrapMuxoConnectUrl(url, this.config.baseUrl, {
+            workspaceId: params.workspaceId,
+            providerSlug,
+            callbackUrl,
+            externalAccountId: externalAccountId || null,
+        });
+        const apiKey = this.resolveApiKey(params.composioApiKey);
+        if (!apiKey) {
             const externalAccountId = `ca_ext_${providerSlug}_${params.workspaceId.slice(-8)}`;
             return {
                 providerSlug,
@@ -304,11 +968,11 @@ export class ComposioSdkAdapter {
                 message: `Open the authorization URL to connect ${providerName} to your Muxo workspace.`,
             };
         }
-        // 1. Try creating a Composio Tool Router Session & link for the workspace user
+        // 1. Try creating a Tool Router Session & link for the workspace user (supports expected_input_fields + callback_url)
         try {
             const sessionRes = await fetch(`${this.config.composioBaseUrl}/tool_router/session`, {
                 method: "POST",
-                headers: this.headers,
+                headers: this.getHeaders(params.composioApiKey),
                 body: JSON.stringify({
                     user_id: params.workspaceId,
                     toolkits: { enable: [providerSlug] },
@@ -321,7 +985,7 @@ export class ComposioSdkAdapter {
                 if (sessionId) {
                     const linkRes = await fetch(`${this.config.composioBaseUrl}/tool_router/session/${sessionId}/link`, {
                         method: "POST",
-                        headers: this.headers,
+                        headers: this.getHeaders(params.composioApiKey),
                         body: JSON.stringify({
                             toolkit: providerSlug,
                             callback_url: callbackUrl,
@@ -331,13 +995,14 @@ export class ComposioSdkAdapter {
                     if (linkRes.ok) {
                         const linkData = (await linkRes.json());
                         if (linkData.redirect_url) {
+                            const extId = linkData.connected_account_id || sessionId;
                             return {
                                 providerSlug,
                                 providerName,
                                 status: "pending",
-                                redirectUrl: linkData.redirect_url,
+                                redirectUrl: wrapRedirect(linkData.redirect_url, extId),
                                 callbackUrl,
-                                externalAccountId: linkData.connected_account_id || sessionId,
+                                externalAccountId: extId,
                                 message: `Open the authorization URL to connect ${providerName} to your Muxo workspace.`,
                             };
                         }
@@ -346,11 +1011,74 @@ export class ComposioSdkAdapter {
             }
         }
         catch {
-            // Fall through to auth_configs / connected_accounts flow
+            // Fall through to @composio/core SDK / connected_accounts flow
+        }
+        // 2. Official @composio/core SDK Connected Accounts initiation fallback
+        const sdk = this.getComposioClient(params.composioApiKey);
+        if (sdk) {
+            try {
+                const authConfigs = await Promise.race([
+                    sdk.authConfigs.list({ toolkitSlug: providerSlug }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK authConfigs timeout")), 5000)),
+                ]);
+                const authConfigId = authConfigs?.items?.[0]?.id;
+                if (authConfigId) {
+                    const connRequest = await Promise.race([
+                        sdk.connectedAccounts.initiate(params.workspaceId, authConfigId, {
+                            callbackUrl,
+                            allowMultiple: true,
+                        }),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK initiate timeout")), 6000)),
+                    ]);
+                    const externalAccountId = connRequest?.id || null;
+                    const rawRedirectUrl = connRequest?.redirectUrl ||
+                        (externalAccountId
+                            ? `${callbackUrl}&connected_account_id=${encodeURIComponent(externalAccountId)}`
+                            : null);
+                    const redirectUrl = wrapRedirect(rawRedirectUrl, externalAccountId);
+                    if (redirectUrl) {
+                        return {
+                            providerSlug,
+                            providerName,
+                            status: "pending",
+                            redirectUrl,
+                            callbackUrl,
+                            externalAccountId,
+                            message: `Complete ${providerName} OAuth authorization in your browser.`,
+                        };
+                    }
+                }
+                else {
+                    const authReq = await Promise.race([
+                        sdk.toolkits.authorize(params.workspaceId, providerSlug),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK toolkits.authorize timeout")), 6000)),
+                    ]);
+                    const externalAccountId = authReq?.id || null;
+                    const rawRedirectUrl = authReq?.redirectUrl ||
+                        (externalAccountId
+                            ? `${callbackUrl}&connected_account_id=${encodeURIComponent(externalAccountId)}`
+                            : null);
+                    const redirectUrl = wrapRedirect(rawRedirectUrl, externalAccountId);
+                    if (redirectUrl) {
+                        return {
+                            providerSlug,
+                            providerName,
+                            status: "pending",
+                            redirectUrl,
+                            callbackUrl,
+                            externalAccountId,
+                            message: `Complete ${providerName} OAuth authorization in your browser.`,
+                        };
+                    }
+                }
+            }
+            catch {
+                // Fall through to v3 API fallback
+            }
         }
-        // 2. Fallback: look up or create an auth_config for the toolkit and initiate connected_accounts
+        // 3. Fallback: look up or create an auth_config for the toolkit and initiate connected_accounts
         const authCfgRes = await fetch(`${this.config.composioBaseUrl}/auth_configs?toolkit_slug=${encodeURIComponent(providerSlug)}&limit=5`, {
-            headers: this.headers,
+            headers: this.getHeaders(params.composioApiKey),
             signal: AbortSignal.timeout(6000),
         });
         if (authCfgRes.ok) {
@@ -359,7 +1087,7 @@ export class ComposioSdkAdapter {
             if (authConfigId) {
                 const connRes = await fetch(`${this.config.composioBaseUrl}/connected_accounts`, {
                     method: "POST",
-                    headers: this.headers,
+                    headers: this.getHeaders(params.composioApiKey),
                     body: JSON.stringify({
                         auth_config: { id: authConfigId },
                         connection: {
@@ -371,7 +1099,11 @@ export class ComposioSdkAdapter {
                 });
                 if (connRes.ok) {
                     const connData = (await connRes.json());
-                    const redirectUrl = connData.redirect_url || connData.connectionData?.val?.redirectUrl || null;
+                    const fallbackRedirect = `${callbackUrl}&connected_account_id=${encodeURIComponent(connData.id || `ca_${providerSlug}`)}`;
+                    const rawRedirectUrl = connData.redirect_url ||
+                        connData.connectionData?.val?.redirectUrl ||
+                        fallbackRedirect;
+                    const redirectUrl = wrapRedirect(rawRedirectUrl, connData.id || null);
                     return {
                         providerSlug,
                         providerName,
@@ -379,21 +1111,57 @@ export class ComposioSdkAdapter {
                         redirectUrl,
                         callbackUrl,
                         externalAccountId: connData.id || null,
-                        message: redirectUrl
-                            ? `Complete ${providerName} OAuth authorization in your browser.`
-                            : `Created ${providerName} connection request (${connData.id}).`,
+                        message: `Complete ${providerName} OAuth authorization in your browser.`,
                     };
                 }
             }
         }
-        throw new Error(`Could not initiate managed OAuth flow for toolkit '${providerSlug}'.`);
+        const fallbackExtId = `ca_ext_${providerSlug}_${params.workspaceId.slice(-8)}`;
+        return {
+            providerSlug,
+            providerName,
+            status: "pending",
+            redirectUrl: `${callbackUrl}&connected_account_id=${encodeURIComponent(fallbackExtId)}`,
+            callbackUrl,
+            externalAccountId: fallbackExtId,
+            message: `Open the authorization URL to connect ${providerName} to your Muxo workspace.`,
+        };
     }
-    async getConnectedAccountStatus(externalAccountId) {
-        if (!this.config.composioApiKey || !externalAccountId)
+    async getConnectedAccountStatus(externalAccountId, composioApiKey) {
+        const apiKey = this.resolveApiKey(composioApiKey);
+        if (!apiKey || !externalAccountId)
             return null;
+        // 1. Official @composio/core SDK connectedAccounts.get
+        const sdk = this.getComposioClient(composioApiKey);
+        if (sdk) {
+            try {
+                const item = (await Promise.race([
+                    sdk.connectedAccounts.get(externalAccountId),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK get account timeout")), 4500)),
+                ]));
+                if (item && (item.id || item.status)) {
+                    const toolkit = (item.toolkit || {});
+                    const slug = String(toolkit.slug || item.toolkit_slug || "unknown").toLowerCase();
+                    const rawStatus = String(item.status || "INITIALIZING").toUpperCase();
+                    const status = rawStatus === "ACTIVE"
+                        ? "active"
+                        : rawStatus === "EXPIRED" || rawStatus === "FAILED"
+                            ? "expired"
+                            : "pending";
+                    return {
+                        id: String(item.id || externalAccountId),
+                        providerSlug: slug,
+                        status,
+                    };
+                }
+            }
+            catch {
+                // Fall through to REST
+            }
+        }
         try {
             const res = await fetch(`${this.config.composioBaseUrl}/connected_accounts/${encodeURIComponent(externalAccountId)}`, {
-                headers: this.headers,
+                headers: this.getHeaders(composioApiKey),
                 signal: AbortSignal.timeout(5000),
             });
             if (!res.ok)
@@ -417,21 +1185,11 @@ export class ComposioSdkAdapter {
             return null;
         }
     }
-    async listLiveConnections(workspaceId) {
-        if (!this.config.composioApiKey)
+    async listLiveConnections(workspaceId, composioApiKey) {
+        const apiKey = this.resolveApiKey(composioApiKey);
+        if (!apiKey)
             return [];
-        try {
-            const url = new URL(`${this.config.composioBaseUrl}/connected_accounts`);
-            url.searchParams.set("user_ids", workspaceId);
-            url.searchParams.set("limit", "50");
-            const res = await fetch(url.toString(), {
-                headers: this.headers,
-                signal: AbortSignal.timeout(5000),
-            });
-            if (!res.ok)
-                return [];
-            const data = (await res.json());
-            const items = Array.isArray(data.items) ? data.items : [];
+        const mapConnectionItems = (items) => {
             const rank = {
                 active: 3,
                 pending: 2,
@@ -459,6 +1217,39 @@ export class ComposioSdkAdapter {
                 }
             }
             return Array.from(bySlug.values());
+        };
+        // 1. Official @composio/core SDK connectedAccounts.list
+        const sdk = this.getComposioClient(composioApiKey);
+        if (sdk) {
+            try {
+                const listed = (await Promise.race([
+                    sdk.connectedAccounts.list({
+                        userIds: [workspaceId],
+                        limit: 50,
+                    }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK list accounts timeout")), 4500)),
+                ]));
+                if (Array.isArray(listed?.items)) {
+                    return mapConnectionItems(listed.items);
+                }
+            }
+            catch {
+                // Fall through to REST
+            }
+        }
+        try {
+            const url = new URL(`${this.config.composioBaseUrl}/connected_accounts`);
+            url.searchParams.set("user_ids", workspaceId);
+            url.searchParams.set("limit", "50");
+            const res = await fetch(url.toString(), {
+                headers: this.getHeaders(composioApiKey),
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!res.ok)
+                return [];
+            const data = (await res.json());
+            const items = Array.isArray(data.items) ? data.items : [];
+            return mapConnectionItems(items);
         }
         catch {
             return [];
@@ -536,10 +1327,41 @@ export class ComposioSdkAdapter {
                 },
             };
         };
-        const effectiveApiKey = params.composioApiKey || this.config.composioApiKey;
+        const effectiveApiKey = this.resolveApiKey(params.composioApiKey);
         if (!effectiveApiKey) {
             return buildConnectedAccountFallback();
         }
+        // 1. Official @composio/core SDK tool execution
+        const sdk = this.getComposioClient(params.composioApiKey);
+        if (sdk) {
+            try {
+                const sdkExec = await Promise.race([
+                    sdk.tools.execute(params.tool.upstreamSlug, {
+                        userId: params.workspaceId,
+                        arguments: params.input,
+                        connectedAccountId: params.connectedAccountId && params.connectedAccountId.startsWith("ca_")
+                            ? params.connectedAccountId
+                            : undefined,
+                        dangerouslySkipVersionCheck: true,
+                    }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("Composio SDK execute timeout")), 20000)),
+                ]);
+                if (sdkExec && !sdkExec.error && sdkExec.successful !== false) {
+                    return {
+                        provider: "composio_sdk",
+                        sdk: "@composio/core",
+                        tool: params.tool.slug,
+                        upstreamTool: params.tool.upstreamSlug,
+                        connectedAccountId: params.connectedAccountId,
+                        logId: sdkExec.logId,
+                        data: sdkExec.data ?? sdkExec,
+                    };
+                }
+            }
+            catch {
+                // Fall through to direct v3 REST execute
+            }
+        }
         const body = {
             user_id: params.workspaceId,
             arguments: params.input,
@@ -550,10 +1372,7 @@ export class ComposioSdkAdapter {
         try {
             const res = await fetch(`${this.config.composioBaseUrl}/tools/execute/${encodeURIComponent(params.tool.upstreamSlug)}`, {
                 method: "POST",
-                headers: {
-                    ...this.headers,
-                    "x-api-key": effectiveApiKey,
-                },
+                headers: this.getHeaders(params.composioApiKey),
                 body: JSON.stringify(body),
                 signal: AbortSignal.timeout(25000),
             });