@muxoai/sdk 1.2.2 → 1.3.0

package/dist/nl.d.ts

@@ -0,0 +1,34 @@
+import type { ToolDescriptor } from "./types.js";
+export interface NaturalLanguageResolution {
+    resolved: boolean;
+    tool: ToolDescriptor | null;
+    toolSlug: string | null;
+    input: Record<string, unknown>;
+    extractedInput: Record<string, unknown>;
+    reason: string;
+    confidence: number;
+    resolutionMethod: "exact_slug" | "byok_llm" | "semantic_router";
+    byokUsed: string | null;
+    humanSummary: string;
+    missingInputs: string[];
+    needsConnection: boolean;
+    suggestedByokProvider: string | null;
+    alternatives: Array<{
+        slug: string;
+        name: string;
+        riskLevel: string;
+        creditCost: number;
+    }>;
+}
+export declare function extractParametersFromNaturalLanguage(prompt: string, tool: ToolDescriptor, explicitInput?: Record<string, unknown>): {
+    input: Record<string, unknown>;
+    missingInputs: string[];
+};
+export declare function resolveNaturalLanguageIntent(params: {
+    prompt: string;
+    tools: ToolDescriptor[];
+    explicitInput?: Record<string, unknown>;
+    byokKeys?: Record<string, string>;
+    activeConnectionProviders?: Set<string>;
+    preferByokLlm?: boolean;
+}): Promise<NaturalLanguageResolution>;

package/dist/nl.js

@@ -0,0 +1,577 @@
+function extractUrlFromText(text) {
+    const fullMatch = text.match(/https?:\/\/[^\s"'<>]+/i);
+    if (fullMatch) {
+        return fullMatch[0].replace(/[.,;!?)]+$/, "");
+    }
+    const domainMatch = text.match(/\b((?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+(?:ai|com|io|dev|org|net|app|co|xyz)(?:\/[^\s"'<>]*)?)\b/i);
+    if (domainMatch && !text.includes(`@${domainMatch[1]}`)) {
+        return `https://${domainMatch[1].replace(/[.,;!?)]+$/, "")}`;
+    }
+    return null;
+}
+function extractEmailFromText(text) {
+    const m = text.match(/\b([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})\b/);
+    return m ? m[1] : null;
+}
+function extractNumberAfterKeyword(text, keywords, fallback) {
+    for (const kw of keywords) {
+        const reAfter = new RegExp(`\\b${kw}\\s+(?:of\\s+|to\\s+|=\\s*)?(\\d[\\d,]*)`, "i");
+        const m1 = text.match(reAfter);
+        if (m1) {
+            const n = Number(m1[1].replace(/,/g, ""));
+            if (!Number.isNaN(n) && n > 0)
+                return n;
+        }
+        const reBefore = new RegExp(`(\\d[\\d,]*)\\s+${kw}\\b`, "i");
+        const m2 = text.match(reBefore);
+        if (m2) {
+            const n = Number(m2[1].replace(/,/g, ""));
+            if (!Number.isNaN(n) && n > 0)
+                return n;
+        }
+    }
+    return fallback;
+}
+export function extractParametersFromNaturalLanguage(prompt, tool, explicitInput) {
+    const input = { ...(explicitInput || {}) };
+    const slug = tool.slug;
+    const text = prompt.trim();
+    if (slug === "instant.seo.audit") {
+        if (!input.url) {
+            const url = extractUrlFromText(text);
+            if (url)
+                input.url = url;
+        }
+        if (input.checkBrokenLinks === undefined) {
+            input.checkBrokenLinks = !/\b(skip|no)\s+broken\s+links\b/i.test(text);
+        }
+    }
+    else if (slug === "instant.web.crawl") {
+        if (!input.url) {
+            const url = extractUrlFromText(text);
+            if (url)
+                input.url = url;
+        }
+        if (input.maxPages === undefined) {
+            input.maxPages = extractNumberAfterKeyword(text, ["maxPages", "pages", "limit"], 5);
+        }
+        if (input.maxDepth === undefined) {
+            input.maxDepth = extractNumberAfterKeyword(text, ["maxDepth", "depth"], 2);
+        }
+    }
+    else if (slug === "instant.web.scrape") {
+        if (!input.url) {
+            const url = extractUrlFromText(text);
+            if (url)
+                input.url = url;
+        }
+        if (!input.formats) {
+            input.formats = ["markdown"];
+        }
+    }
+    else if (slug === "instant.web.search") {
+        if (!input.query) {
+            const cleaned = text
+                .replace(/^(?:please\s+)?(?:can\s+you\s+)?(?:search\s+(?:the\s+)?web\s+(?:for|about)|search\s+(?:for|about)|find\s+(?:info|information|articles)\s+(?:on|about|for)|google|lookup|look\s+up)\s+/i, "")
+                .trim();
+            input.query = cleaned || text;
+        }
+        if (input.numResults === undefined) {
+            input.numResults = extractNumberAfterKeyword(text, ["results", "limit", "top"], 5);
+        }
+    }
+    else if (slug === "instant.code.execute") {
+        if (!input.language) {
+            input.language = /\b(javascript|js|node|typescript|ts)\b/i.test(text)
+                ? "javascript"
+                : "python";
+        }
+        if (!input.code) {
+            const codeBlock = text.match(/```(?:\w+)?\n([\s\S]*?)```/);
+            if (codeBlock) {
+                input.code = codeBlock[1].trim();
+            }
+            else {
+                const inlineCode = text.match(/`([^`]+)`/);
+                if (inlineCode)
+                    input.code = inlineCode[1].trim();
+            }
+        }
+    }
+    else if (slug.startsWith("resource.")) {
+        if (!input.resource_name && !input.name) {
+            const namedMatch = text.match(/\b(?:named|called|name|resource)\s+["']?([a-zA-Z0-9_-]+)["']?/i);
+            const defaultPrefix = slug.split(".")[1] || "app";
+            const resolvedName = namedMatch ? namedMatch[1] : `${defaultPrefix}-main`;
+            input.resource_name = resolvedName;
+        }
+        else if (input.name && !input.resource_name) {
+            input.resource_name = input.name;
+        }
+    }
+    else if (slug === "billing.credits.topup") {
+        if (input.credits === undefined) {
+            input.credits = extractNumberAfterKeyword(text, ["credits", "credit", "pack", "topup", "top-up", "add"], 1000);
+        }
+        if (!input.description) {
+            input.description = `Natural language top-up: ${text.slice(0, 80)}`;
+        }
+    }
+    else if (slug === "billing.subscription.upgrade") {
+        if (!input.tier) {
+            input.tier = "starter";
+        }
+    }
+    else if (slug === "billing.checkout.create") {
+        if (!input.kind) {
+            input.kind = /\b(starter|subscription|upgrade|monthly|plan)\b/i.test(text)
+                ? "starter_subscription"
+                : "credit_topup";
+        }
+    }
+    else if (slug === "app.gmail.send_email") {
+        if (!input.recipient_email) {
+            const email = extractEmailFromText(text);
+            if (email)
+                input.recipient_email = email;
+        }
+        if (!input.subject) {
+            const subjMatch = text.match(/\bsubject\s*[:=]?\s*["']([^"']+)["']|\bsubject\s+([^\n]+?)(?:\s+body\b|\s+saying\b|$)/i);
+            input.subject = subjMatch
+                ? (subjMatch[1] || subjMatch[2]).trim()
+                : "Message from Muxo Agent";
+        }
+        if (!input.body) {
+            const bodyMatch = text.match(/\b(?:body|saying|message)\s*[:=]?\s*["']?([\s\S]+?)["']?$/i);
+            input.body = bodyMatch ? bodyMatch[1].trim() : text;
+        }
+    }
+    else if (slug === "app.gmail.fetch_emails" || slug === "app.gmail.list_messages") {
+        if (!input.query) {
+            const qMatch = text.match(/\b(?:matching|query|from|about)\s+["']?([^"'\n]+)["']?/i);
+            if (qMatch)
+                input.query = qMatch[1].trim();
+        }
+        if (input.max_results === undefined) {
+            input.max_results = extractNumberAfterKeyword(text, ["emails", "messages", "limit", "last"], 10);
+        }
+    }
+    else if (slug === "app.slack.send_message" || slug === "app.slack.post_message") {
+        if (!input.channel) {
+            const chMatch = text.match(/#([a-zA-Z0-9_-]+)|\bchannel\s+([a-zA-Z0-9_-]+)/i);
+            input.channel = chMatch ? chMatch[1] || chMatch[2] : "general";
+        }
+        if (!input.text) {
+            const msgMatch = text.match(/\b(?:saying|message|text)\s*[:=]?\s*["']?([\s\S]+?)["']?$/i);
+            input.text = msgMatch ? msgMatch[1].trim() : text;
+        }
+    }
+    else if (slug === "app.github.create_issue" || slug === "app.github.list_pull_requests" || slug === "app.github.list_issues") {
+        const repoMatch = text.match(/\b([a-zA-Z0-9_.-]+)\/([a-zA-Z0-9_.-]+)\b/);
+        if (repoMatch && !repoMatch[0].includes(".ai") && !repoMatch[0].includes(".com")) {
+            if (!input.owner)
+                input.owner = repoMatch[1];
+            if (!input.repo)
+                input.repo = repoMatch[2];
+        }
+        if (slug === "app.github.create_issue" && !input.title) {
+            const titleMatch = text.match(/\b(?:titled|title)\s*[:=]?\s*["']?([^"'\n]+)["']?/i);
+            input.title = titleMatch ? titleMatch[1].trim() : text.slice(0, 80);
+        }
+    }
+    else if (slug === "app.notion.search_pages") {
+        if (!input.query) {
+            const cleaned = text
+                .replace(/^(?:search\s+notion\s+(?:pages\s+)?(?:for)?|find\s+in\s+notion)\s*/i, "")
+                .trim();
+            input.query = cleaned || text;
+        }
+    }
+    else if (slug === "instant.dns.lookup") {
+        if (!input.domain) {
+            const domainMatch = text.match(/\b((?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+(?:ai|com|io|dev|org|net|app|co|xyz))\b/i);
+            if (domainMatch) {
+                input.domain = domainMatch[1].toLowerCase();
+            }
+            else if (typeof input.hostname === "string") {
+                input.domain = input.hostname;
+            }
+        }
+        if (!input.type) {
+            const typeMatch = text.match(/\b(AAAA|CNAME|TXT|MX|NS|A)\b/i);
+            input.type = typeMatch ? typeMatch[1].toUpperCase() : "A";
+        }
+    }
+    else if (slug === "instant.hackernews.top_stories") {
+        if (input.limit === undefined) {
+            input.limit = extractNumberAfterKeyword(text, ["top", "stories", "items", "limit", "posts"], 5);
+        }
+    }
+    const schemaReq = Array.isArray(tool.inputSchema?.required)
+        ? tool.inputSchema.required
+        : [];
+    const missingInputs = schemaReq.filter((k) => input[k] === undefined || input[k] === null || input[k] === "");
+    return { input, missingInputs };
+}
+function scoreToolForPrompt(prompt, tool) {
+    const q = prompt.trim().toLowerCase();
+    if (!q)
+        return 0;
+    if (q === tool.slug.toLowerCase() || q === tool.upstreamSlug.toLowerCase()) {
+        return 1000;
+    }
+    let score = 0;
+    const slug = tool.slug.toLowerCase();
+    // High-signal intent rules
+    if (/\b(seo|meta\s+tag|open\s*graph|json-ld|jsonld|canonical|heading\s+hierarchy|audit\s+site|audit\s+page|seo\s+audit)\b/i.test(q)) {
+        if (slug === "instant.seo.audit")
+            score += 120;
+    }
+    if (/\b(crawl|spider|multi-page|sitemap|discover\s+links|all\s+pages)\b/i.test(q)) {
+        if (slug === "instant.web.crawl")
+            score += 110;
+    }
+    if (/\b(scrape|extract\s+markdown|fetch\s+page|read\s+url|read\s+webpage|scrape\s+url)\b/i.test(q)) {
+        if (slug === "instant.web.scrape")
+            score += 110;
+    }
+    if (/\b(search\s+the\s+web|web\s+search|search\s+for|look\s+up|find\s+news|exa|google)\b/i.test(q)) {
+        if (slug === "instant.web.search")
+            score += 105;
+    }
+    if (/\b(run\s+python|execute\s+code|run\s+script|sandbox|calculate|e2b)\b/i.test(q)) {
+        if (slug === "instant.code.execute")
+            score += 105;
+    }
+    if (/\b(top\s*up|add\s+credits|buy\s+credits|refill\s+credits|more\s+credits|\d+\s+credits)\b/i.test(q)) {
+        if (slug === "billing.credits.topup")
+            score += 130;
+    }
+    if (/\b(upgrade\s+to\s+starter|upgrade\s+plan|starter\s+plan|starter\s+tier|upgrade\s+subscription|upgrade\s+workspace)\b/i.test(q)) {
+        if (slug === "billing.subscription.upgrade")
+            score += 130;
+    }
+    if (/\b(stripe\s+checkout|checkout\s+session|payment\s+link|billing\s+link)\b/i.test(q)) {
+        if (slug === "billing.checkout.create")
+            score += 125;
+    }
+    if (/\b(turso|libsql|sqlite\s+database|sqlite\s+db)\b/i.test(q)) {
+        if (slug.startsWith("resource.turso."))
+            score += 120;
+        if (slug.includes("database"))
+            score += 15;
+    }
+    if (/\b(neon|postgres|postgresql|pg\s+database)\b/i.test(q)) {
+        if (slug.startsWith("resource.neon."))
+            score += 120;
+    }
+    if (/\b(upstash|redis|cache\s+store|kv\s+store)\b/i.test(q)) {
+        if (slug.startsWith("resource.upstash."))
+            score += 120;
+    }
+    if (/\b(supabase)\b/i.test(q)) {
+        if (slug.startsWith("resource.supabase."))
+            score += 120;
+    }
+    if (/\b(mongodb|mongo)\b/i.test(q)) {
+        if (slug.startsWith("resource.mongodb."))
+            score += 120;
+    }
+    if (/\b(hacker\s*news|hn\s+stories|top\s+stories)\b/i.test(q)) {
+        if (slug === "instant.hackernews.top_stories")
+            score += 125;
+    }
+    if (/\b(dns|doh|txt\s+records?|mx\s+records?|a\s+records?|cname|nameserver|lookup\s+dns|check\s+dns)\b/i.test(q)) {
+        if (slug === "instant.dns.lookup")
+            score += 135;
+    }
+    if (/\b(send\s+an?\s+email|send\s+email|email\s+to|compose\s+email)\b/i.test(q)) {
+        if (slug === "app.gmail.send_email")
+            score += 120;
+    }
+    if (/\b(list\s+emails|read\s+emails|check\s+inbox|recent\s+emails|list\s+messages|fetch\s+emails|gmail\s+inbox)\b/i.test(q)) {
+        if (slug === "app.gmail.fetch_emails" || slug === "app.gmail.list_messages")
+            score += 115;
+    }
+    if (/\b(post\s+to\s+slack|send\s+slack|slack\s+message|message\s+#)\b/i.test(q)) {
+        if (slug === "app.slack.send_message" || slug === "app.slack.post_message")
+            score += 120;
+    }
+    if (/\b(create\s+(?:a\s+)?github\s+issue|open\s+(?:a\s+)?github\s+issue|file\s+an?\s+issue)\b/i.test(q)) {
+        if (slug === "app.github.create_issue")
+            score += 120;
+    }
+    if (/\b(list\s+github\s+(?:issues|prs|pull\s+requests)|check\s+github|pull\s+requests)\b/i.test(q)) {
+        if (slug === "app.github.list_pull_requests" || slug === "app.github.list_issues")
+            score += 110;
+    }
+    if (/\b(notion\s+page|search\s+notion)\b/i.test(q)) {
+        if (slug === "app.notion.search_pages")
+            score += 115;
+    }
+    if (/\b(linear\s+issue|create\s+linear)\b/i.test(q)) {
+        if (slug === "app.linear.create_issue")
+            score += 115;
+    }
+    if (/\b(google\s+calendar|schedule\s+meeting|list\s+events|calendar\s+events)\b/i.test(q)) {
+        if (slug.includes("calendar") || slug.includes("gcal"))
+            score += 110;
+    }
+    // Generic token overlap fallback
+    const haystack = `${tool.slug} ${tool.name} ${tool.description} ${tool.providerSlug} ${(tool.categories || []).join(" ")}`.toLowerCase();
+    const tokens = q.split(/[^a-z0-9_.-]+/).filter((t) => t.length >= 2);
+    for (const token of tokens) {
+        if (slug.includes(token))
+            score += 18;
+        else if (tool.providerSlug.toLowerCase().includes(token))
+            score += 14;
+        else if (haystack.includes(token))
+            score += 6;
+    }
+    // If prompt contains a URL and no specific verb was matched, default toward scrape/audit
+    if (extractUrlFromText(prompt) && score < 40) {
+        if (slug === "instant.web.scrape")
+            score += 45;
+        if (slug === "instant.seo.audit")
+            score += 40;
+        if (slug === "instant.web.crawl")
+            score += 38;
+    }
+    return score;
+}
+async function tryByokLlmClassification(params) {
+    const openaiKey = params.byokKeys.OPENAI_API_KEY || "";
+    const openrouterKey = params.byokKeys.OPENROUTER_API_KEY || "";
+    const anthropicKey = params.byokKeys.ANTHROPIC_API_KEY || "";
+    if (!openaiKey && !openrouterKey && !anthropicKey) {
+        return null;
+    }
+    const catalogBrief = params.tools
+        .slice(0, 35)
+        .map((t) => `- ${t.slug} (${t.riskLevel}, ${t.creditCost}cr): ${t.description} | schema keys: ${Object.keys(t.inputSchema?.properties || {}).join(", ")}`)
+        .join("\n");
+    const systemPrompt = [
+        "You are the Muxo Natural Language Intent Router.",
+        "Map the user's natural language request to the single best toolSlug from the catalog below and extract its JSON arguments.",
+        "Return ONLY valid JSON with shape: {\"toolSlug\": string, \"input\": object, \"reason\": string}.",
+        "Catalog:",
+        catalogBrief,
+    ].join("\n");
+    try {
+        if (openaiKey || openrouterKey) {
+            const isOpenRouter = !openaiKey && Boolean(openrouterKey);
+            const endpoint = isOpenRouter
+                ? "https://openrouter.ai/api/v1/chat/completions"
+                : "https://api.openai.com/v1/chat/completions";
+            const res = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${openaiKey || openrouterKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    model: isOpenRouter ? "openai/gpt-4o-mini" : "gpt-4o-mini",
+                    temperature: 0,
+                    response_format: { type: "json_object" },
+                    messages: [
+                        { role: "system", content: systemPrompt },
+                        { role: "user", content: params.prompt },
+                    ],
+                }),
+                signal: AbortSignal.timeout(4500),
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                const content = data?.choices?.[0]?.message?.content;
+                if (typeof content === "string") {
+                    const parsed = JSON.parse(content);
+                    if (parsed && typeof parsed.toolSlug === "string") {
+                        return {
+                            toolSlug: parsed.toolSlug,
+                            input: parsed.input && typeof parsed.input === "object"
+                                ? parsed.input
+                                : {},
+                            reason: String(parsed.reason || params.prompt),
+                            providerUsed: isOpenRouter ? "openrouter" : "openai",
+                        };
+                    }
+                }
+            }
+        }
+        else if (anthropicKey) {
+            const res = await fetch("https://api.anthropic.com/v1/messages", {
+                method: "POST",
+                headers: {
+                    "x-api-key": anthropicKey,
+                    "anthropic-version": "2023-06-01",
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    model: "claude-3-5-haiku-latest",
+                    max_tokens: 400,
+                    system: systemPrompt,
+                    messages: [{ role: "user", content: params.prompt }],
+                }),
+                signal: AbortSignal.timeout(4500),
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                const text = data?.content?.[0]?.text;
+                if (typeof text === "string") {
+                    const jsonMatch = text.match(/\{[\s\S]*\}/);
+                    if (jsonMatch) {
+                        const parsed = JSON.parse(jsonMatch[0]);
+                        if (parsed && typeof parsed.toolSlug === "string") {
+                            return {
+                                toolSlug: parsed.toolSlug,
+                                input: parsed.input && typeof parsed.input === "object"
+                                    ? parsed.input
+                                    : {},
+                                reason: String(parsed.reason || params.prompt),
+                                providerUsed: "anthropic",
+                            };
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Fall back to deterministic semantic router
+    }
+    return null;
+}
+export async function resolveNaturalLanguageIntent(params) {
+    const prompt = params.prompt.trim();
+    const tools = params.tools;
+    // 1. Check exact slug match first
+    const exactTool = tools.find((t) => t.slug.toLowerCase() === prompt.toLowerCase() ||
+        t.upstreamSlug.toLowerCase() === prompt.toLowerCase());
+    if (exactTool) {
+        const { input, missingInputs } = extractParametersFromNaturalLanguage(prompt, exactTool, params.explicitInput);
+        const needsConnection = exactTool.requiresAuth &&
+            !(params.activeConnectionProviders?.has(exactTool.providerSlug) ?? false);
+        return {
+            resolved: true,
+            tool: exactTool,
+            toolSlug: exactTool.slug,
+            input,
+            extractedInput: input,
+            reason: `Direct execution of ${exactTool.slug}`,
+            confidence: 1.0,
+            resolutionMethod: "exact_slug",
+            byokUsed: null,
+            humanSummary: `${exactTool.name} (${exactTool.slug})`,
+            missingInputs,
+            needsConnection,
+            suggestedByokProvider: suggestByokProviderForTool(exactTool),
+            alternatives: [],
+        };
+    }
+    // 2. Try BYOK LLM router if a user LLM key is configured in the workspace vault
+    if (params.preferByokLlm !== false && params.byokKeys) {
+        const llmRes = await tryByokLlmClassification({
+            prompt,
+            tools,
+            byokKeys: params.byokKeys,
+        });
+        if (llmRes) {
+            const matchedTool = tools.find((t) => t.slug.toLowerCase() === llmRes.toolSlug.toLowerCase());
+            if (matchedTool) {
+                const mergedExplicit = {
+                    ...llmRes.input,
+                    ...(params.explicitInput || {}),
+                };
+                const { input, missingInputs } = extractParametersFromNaturalLanguage(prompt, matchedTool, mergedExplicit);
+                const needsConnection = matchedTool.requiresAuth &&
+                    !(params.activeConnectionProviders?.has(matchedTool.providerSlug) ?? false);
+                return {
+                    resolved: true,
+                    tool: matchedTool,
+                    toolSlug: matchedTool.slug,
+                    input,
+                    extractedInput: input,
+                    reason: llmRes.reason || prompt,
+                    confidence: 0.96,
+                    resolutionMethod: "byok_llm",
+                    byokUsed: llmRes.providerUsed,
+                    humanSummary: `${matchedTool.name} via ${matchedTool.slug}`,
+                    missingInputs,
+                    needsConnection,
+                    suggestedByokProvider: suggestByokProviderForTool(matchedTool),
+                    alternatives: [],
+                };
+            }
+        }
+    }
+    // 3. Deterministic Semantic + Regex Router (0 latency, works without LLM API keys)
+    const scored = tools
+        .map((tool) => ({ tool, score: scoreToolForPrompt(prompt, tool) }))
+        .filter((item) => item.score > 0)
+        .sort((a, b) => b.score - a.score);
+    const best = scored[0]?.tool || null;
+    const bestScore = scored[0]?.score || 0;
+    const alternatives = scored.slice(1, 5).map((s) => ({
+        slug: s.tool.slug,
+        name: s.tool.name,
+        riskLevel: s.tool.riskLevel,
+        creditCost: s.tool.creditCost,
+    }));
+    if (!best || bestScore < 12) {
+        return {
+            resolved: false,
+            tool: null,
+            toolSlug: null,
+            input: params.explicitInput || {},
+            extractedInput: params.explicitInput || {},
+            reason: prompt,
+            confidence: 0,
+            resolutionMethod: "semantic_router",
+            byokUsed: null,
+            humanSummary: `Could not confidently match "${prompt}" to a Muxo tool. Try specifying a tool keyword (e.g. "audit seo https://muxo.ai", "search web for AI agents", "top up 1000 credits", "create turso database").`,
+            missingInputs: [],
+            needsConnection: false,
+            suggestedByokProvider: "openai",
+            alternatives: tools.slice(0, 5).map((t) => ({
+                slug: t.slug,
+                name: t.name,
+                riskLevel: t.riskLevel,
+                creditCost: t.creditCost,
+            })),
+        };
+    }
+    const { input, missingInputs } = extractParametersFromNaturalLanguage(prompt, best, params.explicitInput);
+    const needsConnection = best.requiresAuth &&
+        !(params.activeConnectionProviders?.has(best.providerSlug) ?? false);
+    const confidence = Math.min(0.95, Math.round((bestScore / 130) * 100) / 100);
+    return {
+        resolved: true,
+        tool: best,
+        toolSlug: best.slug,
+        input,
+        extractedInput: input,
+        reason: prompt,
+        confidence,
+        resolutionMethod: "semantic_router",
+        byokUsed: null,
+        humanSummary: `${best.name} (${best.slug})`,
+        missingInputs,
+        needsConnection,
+        suggestedByokProvider: suggestByokProviderForTool(best),
+        alternatives,
+    };
+}
+function suggestByokProviderForTool(tool) {
+    if (tool.slug.startsWith("billing."))
+        return "stripe";
+    if (tool.lane === "composio_sdk")
+        return "composio";
+    if (tool.lane === "stripe_projects")
+        return "stripe";
+    if (tool.slug.includes("scrape") || tool.slug.includes("crawl") || tool.slug.includes("seo")) {
+        return "firecrawl";
+    }
+    if (tool.slug.includes("search"))
+        return "exa";
+    return "composio";
+}

package/dist/providers/composio-instant.d.ts

@@ -0,0 +1,14 @@
+import type { MuxoConfig } from "../config.js";
+import type { MuxoTool } from "../types.js";
+export declare class ComposioInstantAdapter {
+    private readonly config;
+    constructor(config: MuxoConfig);
+    getTools(): MuxoTool[];
+    searchTools(query?: string, limit?: number): MuxoTool[];
+    inspectTool(slug: string): MuxoTool | null;
+    executeTool(params: {
+        workspaceId: string;
+        tool: MuxoTool;
+        input: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+}