@muxoai/platform 1.2.3 → 1.3.0

package/dist/engine.js

@@ -1,3 +1,4 @@
+import { resolveNaturalLanguageIntent, } from "./nl.js";
 import { ComposioInstantAdapter } from "./providers/composio-instant.js";
 import { ComposioSdkAdapter } from "./providers/composio-sdk.js";
 import { MicrosoftGovernanceAdapter } from "./providers/microsoft-governance.js";
@@ -79,6 +80,14 @@ export class MuxoEngine {
         }
         if (lane === "all" || lane === "stripe_projects") {
             results.push(...this.stripeProjects.searchTools(query, limit));
+            const billingTools = this.stripeBilling.listTools().filter((t) => {
+                if (!query)
+                    return true;
+                const q = query.toLowerCase();
+                const hay = `${t.slug} ${t.name} ${t.description} ${t.categories.join(" ")}`.toLowerCase();
+                return q.split(/\s+/).some((tok) => hay.includes(tok));
+            });
+            results.push(...billingTools);
         }
         const filtered = params.riskLevel
             ? results.filter((t) => t.riskLevel === params.riskLevel)
@@ -88,9 +97,22 @@ export class MuxoEngine {
             total: filtered.length,
         };
     }
+    async listAllCatalogTools() {
+        const instant = this.composioInstant.searchTools(undefined, 100);
+        const sdk = await this.composioSdk.searchTools(undefined, 100);
+        const proj = this.stripeProjects.searchTools(undefined, 100);
+        const billing = this.stripeBilling.listTools();
+        return [...instant, ...billing, ...sdk, ...proj];
+    }
     // 4. inspect_tool
     async inspectTool(slug) {
         const normalized = slug.trim();
+        const billing = this.stripeBilling
+            .listTools()
+            .find((t) => t.slug.toLowerCase() === normalized.toLowerCase() ||
+            t.upstreamSlug.toLowerCase() === normalized.toLowerCase());
+        if (billing)
+            return billing;
         const instant = this.composioInstant.inspectTool(normalized);
         if (instant)
             return instant;
@@ -346,15 +368,40 @@ export class MuxoEngine {
     // 7. plan_action
     async planAction(ctx, params) {
         const ws = this.store.getWorkspace(ctx.workspace.id);
-        const tool = await this.inspectTool(params.toolSlug);
+        let tool;
+        let resolvedInput = { ...(params.input || {}) };
+        let resolvedReason = params.reason || `Planned execution of ${params.toolSlug}`;
+        try {
+            tool = await this.inspectTool(params.toolSlug);
+        }
+        catch (inspectErr) {
+            // Natural-language fallback: if an agent or human passed plain English as toolSlug/instruction, resolve it!
+            const nlSource = `${params.toolSlug} ${params.reason || ""}`.trim();
+            const allTools = await this.listAllCatalogTools();
+            const byokEnv = this.store.getDecryptedWorkspaceEnv(ws.id);
+            const nl = await resolveNaturalLanguageIntent({
+                prompt: nlSource,
+                tools: allTools,
+                explicitInput: resolvedInput,
+                byokKeys: byokEnv,
+            });
+            if (!nl.resolved || !nl.tool) {
+                throw inspectErr;
+            }
+            tool = nl.tool;
+            resolvedInput = nl.input;
+            resolvedReason = params.reason || nl.reason || nlSource;
+        }
+        const byokActive = this.store.hasByokForLane(ws.id, tool.lane, tool.slug);
+        const effectiveCreditCost = byokActive ? 0 : tool.creditCost;
         if (ws.monthlyActionsUsed >= ws.monthlyActionsLimit) {
             throw new Error(`Monthly action limit reached (${ws.monthlyActionsUsed}/${ws.monthlyActionsLimit}). Upgrade to Starter ($29/mo) to unlock 5,000 actions/mo.`);
         }
-        if (tool.creditCost > ws.creditsBalance) {
-            throw new Error(`Insufficient workspace credits for ${tool.slug} (requires ${tool.creditCost}, available ${ws.creditsBalance}). Top up credits or upgrade plan.`);
+        if (effectiveCreditCost > ws.creditsBalance) {
+            throw new Error(`Insufficient workspace credits for ${tool.slug} (requires ${effectiveCreditCost}, available ${ws.creditsBalance}). Top up credits or configure a BYOK key.`);
         }
-        if (tool.creditCost > ws.policy.maxCreditsPerRun) {
-            throw new Error(`Tool credit cost (${tool.creditCost}) exceeds workspace policy maxCreditsPerRun (${ws.policy.maxCreditsPerRun}).`);
+        if (effectiveCreditCost > ws.policy.maxCreditsPerRun) {
+            throw new Error(`Tool credit cost (${effectiveCreditCost}) exceeds workspace policy maxCreditsPerRun (${ws.policy.maxCreditsPerRun}).`);
         }
         // 1. Evaluate Microsoft Agent Governance Pipeline:
         // Agent -> McpSecurityScanner -> PolicyEngine -> AgentIdentity (Ed25519 DID) -> AuditLogger -> DecisionRecord
@@ -362,14 +409,14 @@ export class MuxoEngine {
             workspace: ws,
             actorId: ctx.actorId,
             tool,
-            input: params.input || {},
-            reason: params.reason || `Planned execution of ${tool.slug}`,
+            input: resolvedInput,
+            reason: resolvedReason,
         });
         if (decisionRecord.verdict === "deny") {
             throw new Error(`Microsoft Agent Governance denied plan for ${tool.slug} (rule: ${decisionRecord.matchedRule}): ${decisionRecord.reason}`);
         }
         // 2. Recall Supermemory v5 contextual brain for this workspace + tool intent
-        const memoryQuery = `${tool.slug} ${tool.name} ${params.reason || ""}`.trim();
+        const memoryQuery = `${tool.slug} ${tool.name} ${resolvedReason}`.trim();
         const memoryContext = await this.supermemory.getContextForWorkspace(ws.id, memoryQuery);
         const requiresHumanApproval = decisionRecord.verdict === "escalate" ||
             (ws.policy.mode === "enforce" &&
@@ -384,9 +431,9 @@ export class MuxoEngine {
             upstreamSlug: tool.upstreamSlug,
             lane: tool.lane,
             riskLevel: tool.riskLevel,
-            input: params.input || {},
-            reason: params.reason || `Planned execution of ${tool.slug}`,
-            creditCost: tool.creditCost,
+            input: resolvedInput,
+            reason: resolvedReason,
+            creditCost: effectiveCreditCost,
             approvalStatus,
             decisionRecord,
             memoryContext,
@@ -583,7 +630,15 @@ export class MuxoEngine {
         const startedMs = Date.now();
         try {
             let output;
-            if (plan.lane === "composio_instant") {
+            if (plan.toolSlug.startsWith("billing.")) {
+                output = await this.stripeBilling.executeTool({
+                    workspace: ws,
+                    customerEmail: ctx.user.email,
+                    toolSlug: plan.toolSlug,
+                    input: plan.input,
+                });
+            }
+            else if (plan.lane === "composio_instant") {
                 output = await this.composioInstant.executeTool({
                     workspaceId: ctx.workspace.id,
                     tool,
@@ -716,4 +771,106 @@ export class MuxoEngine {
             : true;
         return { receipt, signatureValid, governanceSignatureValid };
     }
+    // 19. Natural Language Router & End-to-End Executor (`muxo do` / `POST /api/v1/do`)
+    async doNaturalLanguage(ctx, params) {
+        const allTools = await this.listAllCatalogTools();
+        const byokEnv = this.store.getDecryptedWorkspaceEnv(ctx.workspace.id);
+        const activeConns = new Set(this.store
+            .listConnections(ctx.workspace.id)
+            .filter((c) => c.status === "active")
+            .map((c) => c.providerSlug.toLowerCase()));
+        const resolution = await resolveNaturalLanguageIntent({
+            prompt: params.prompt,
+            tools: allTools,
+            explicitInput: params.input,
+            byokKeys: byokEnv,
+            activeConnectionProviders: activeConns,
+        });
+        if (!resolution.resolved || !resolution.tool) {
+            return {
+                ok: false,
+                executed: false,
+                status: "unresolved",
+                intent: resolution,
+                resolution,
+                byokPrompt: {
+                    needed: !byokEnv.OPENAI_API_KEY && !byokEnv.ANTHROPIC_API_KEY && !byokEnv.OPENROUTER_API_KEY,
+                    provider: "openai",
+                    envVarName: "OPENAI_API_KEY",
+                    cliCommand: "muxo byok set openai <sk-...>",
+                    message: "Tip: Add an OpenAI, Anthropic, or OpenRouter BYOK key (`muxo byok set openai <key>`) for unrestricted natural-language LLM routing.",
+                },
+                humanMessage: resolution.humanSummary,
+            };
+        }
+        if (resolution.missingInputs.length > 0) {
+            return {
+                ok: false,
+                executed: false,
+                status: "missing_inputs",
+                intent: resolution,
+                resolution,
+                humanMessage: `Matched ${resolution.tool.name} (${resolution.tool.slug}), but missing required parameter(s): ${resolution.missingInputs.join(", ")}. Please include them in your request.`,
+            };
+        }
+        const planned = await this.planAction(ctx, {
+            toolSlug: resolution.tool.slug,
+            input: resolution.input,
+            reason: params.prompt,
+        });
+        if (planned.authHandoff?.required) {
+            return {
+                ok: false,
+                executed: false,
+                status: "awaiting_oauth_connection",
+                intent: resolution,
+                resolution,
+                plan: planned.plan,
+                authHandoff: planned.authHandoff,
+                humanMessage: planned.authHandoff.instructions,
+            };
+        }
+        if (params.dryRun || params.planOnly) {
+            return {
+                ok: true,
+                executed: false,
+                status: "planned_dry_run",
+                intent: resolution,
+                resolution,
+                plan: planned.plan,
+                humanMessage: `Planned ${planned.tool.name} (${planned.plan.id}) with risk=${planned.plan.riskLevel} and cost=${planned.plan.creditCost} credits.`,
+            };
+        }
+        let currentPlan = planned.plan;
+        if (currentPlan.approvalStatus === "pending_approval" &&
+            params.autoApprove !== false) {
+            currentPlan = this.approvePlan(ctx, currentPlan.id, "approved");
+        }
+        if (currentPlan.approvalStatus === "pending_approval") {
+            return {
+                ok: true,
+                executed: false,
+                status: "awaiting_approval",
+                intent: resolution,
+                resolution,
+                plan: currentPlan,
+                humanMessage: `Plan ${currentPlan.id} (${currentPlan.toolSlug}, risk=${currentPlan.riskLevel}) requires owner approval. Run 'muxo approve ${currentPlan.id}' or pass --yes to auto-approve.`,
+            };
+        }
+        const executed = await this.executePlanForRisk(ctx, currentPlan.id, currentPlan.riskLevel);
+        const isSuccess = executed.run.status === "succeeded";
+        return {
+            ok: isSuccess,
+            executed: isSuccess,
+            status: "executed",
+            intent: resolution,
+            resolution,
+            plan: currentPlan,
+            run: executed.run,
+            receipt: executed.receipt,
+            humanMessage: isSuccess
+                ? `Completed ${resolution.tool.name} (${resolution.tool.slug}) in ${executed.run.durationMs ?? 0}ms [receipt: ${executed.receipt.id}, funding: ${executed.receipt.supplierSettlement?.fundingMode || "muxo_funded"}].`
+                : `Execution of ${resolution.tool.slug} failed: ${executed.run.error || "Unknown error"}`,
+        };
+    }
 }

package/dist/mcp.js

@@ -195,15 +195,18 @@ export const MUXO_MCP_TOOLS = [
     {
         name: "plan_action",
         title: "Create Governed Action Plan",
-        description: "Create a governed execution plan (plan_*) for any tool or infrastructure provisioning operation. Evaluates workspace policy, risk level, Supermemory v5 recall, Ed25519 signature, and credit balance.",
+        description: "Create a governed execution plan (plan_*) for any tool, billing operation, or infrastructure provisioning operation. Accepts either an exact tool_slug (e.g. 'instant.seo.audit', 'billing.credits.topup', 'resource.turso.database') or a natural-language instruction (e.g. 'audit seo for https://muxo.ai'). Evaluates workspace policy, risk level, Supermemory v5 recall, Ed25519 signature, BYOK vs Muxo-funded mode, and credit balance.",
         inputSchema: {
             type: "object",
             required: ["tool_slug"],
             properties: {
-                tool_slug: { type: "string", description: "Muxo tool slug to plan" },
+                tool_slug: {
+                    type: "string",
+                    description: "Muxo tool slug (e.g. 'instant.seo.audit', 'billing.credits.topup') or natural-language request",
+                },
                 input: {
                     type: "object",
-                    description: "Arguments matching the tool's inputSchema",
+                    description: "Arguments matching the tool's inputSchema (auto-extracted when tool_slug is natural language)",
                 },
                 reason: {
                     type: "string",
@@ -627,8 +630,13 @@ export async function dispatchMcpToolCall(engine, ctx, toolName, args = {}) {
             });
         case "plan_action":
             return engine.planAction(ctx, {
-                toolSlug: String(args.tool_slug || args.slug || ""),
-                input: args.input || {},
+                toolSlug: String(args.tool_slug ||
+                    args.slug ||
+                    args.tool_id ||
+                    args.prompt ||
+                    args.instruction ||
+                    ""),
+                input: (args.input || args.arguments) || {},
                 reason: args.reason ? String(args.reason) : undefined,
             });
         case "get_plan":
@@ -738,7 +746,7 @@ export async function handleJsonRpcMcpRequest(engine, ctx, rpc) {
                     instructions: MUXO_MCP_SERVER_INSTRUCTIONS,
                     serverInfo: {
                         name: "muxo-mcp-server",
-                        version: "1.2.3",
+                        version: "1.3.0",
                     },
                     capabilities: {
                         tools: { listChanged: false },

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>;