@muxoai/platform 1.2.1 → 1.2.3

package/dist/providers/stripe-projects.js

@@ -195,7 +195,10 @@ export class StripeProjectsAdapter {
                         },
                     },
                 },
-                llmContextUrl: raw.service_metadata?.[svc.id]?.llm_context || undefined,
+                llmContextUrl: raw.service_metadata?.[svc.id]?.llm_context ||
+                    (matchedProvider?.url
+                        ? `${matchedProvider.url.replace(/\/+$/, "")}/llms.txt`
+                        : undefined),
                 providerUrl: matchedProvider?.url || undefined,
                 metadata: {
                     kind: svc.kind,
@@ -203,7 +206,10 @@ export class StripeProjectsAdapter {
                     parentPlans,
                     configurationSchema: svc.configuration_schema || null,
                     providerUrl: matchedProvider?.url || null,
-                    llmContextUrl: raw.service_metadata?.[svc.id]?.llm_context || null,
+                    llmContextUrl: raw.service_metadata?.[svc.id]?.llm_context ||
+                        (matchedProvider?.url
+                            ? `${matchedProvider.url.replace(/\/+$/, "")}/llms.txt`
+                            : null),
                     serviceGroup: raw.service_metadata?.[svc.id]?.group || null,
                 },
             };
@@ -243,13 +249,18 @@ export class StripeProjectsAdapter {
         if (this.tools.has(slug)) {
             return this.tools.get(slug);
         }
-        // If given a 2-part slug like "resource.neon", resolve to the provider's primary deployable service
+        // If given a 2-part slug like "resource.neon", or a 3-part alias like "resource.turso.create_database" / "resource.turso.provision"
         const parts = slug.split(".");
-        if (parts[0] === "resource" && parts.length === 2) {
+        if (parts[0] === "resource" && parts.length >= 2) {
             const providerSlug = parts[1].toLowerCase();
-            for (const tool of this.tools.values()) {
-                if (tool.providerSlug === providerSlug && tool.metadata?.kind === "deployable") {
-                    return tool;
+            const actionPart = parts[2]?.toLowerCase() || "";
+            if (parts.length === 2 ||
+                actionPart === "provision" ||
+                actionPart.startsWith("create")) {
+                for (const tool of this.tools.values()) {
+                    if (tool.providerSlug === providerSlug && tool.metadata?.kind === "deployable") {
+                        return tool;
+                    }
                 }
             }
         }
@@ -495,10 +506,17 @@ export class StripeProjectsAdapter {
             .replace(/[^a-z0-9-]+/g, "-");
         if (!this.hasLocalProjectsWorkdir) {
             const prefix = tool.providerSlug.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
-            const secrets = {
-                [`${prefix}_URL`]: `https://${resourceName}.${tool.providerSlug}.muxo.cloud`,
-                [`${prefix}_API_KEY`]: `muxo_secret_${tool.providerSlug}_${Date.now()}`,
-            };
+            const secrets = tool.providerSlug === "turso"
+                ? {
+                    TURSO_DATABASE_URL: `libsql://${resourceName}-muxo.turso.io`,
+                    TURSO_AUTH_TOKEN: `muxo_secret_turso_${Date.now()}`,
+                    [`${prefix}_URL`]: `https://${resourceName}.${tool.providerSlug}.muxo.cloud`,
+                    [`${prefix}_API_KEY`]: `muxo_secret_${tool.providerSlug}_${Date.now()}`,
+                }
+                : {
+                    [`${prefix}_URL`]: `https://${resourceName}.${tool.providerSlug}.muxo.cloud`,
+                    [`${prefix}_API_KEY`]: `muxo_secret_${tool.providerSlug}_${Date.now()}`,
+                };
             return {
                 output: {
                     provider: "stripe_projects",
@@ -563,24 +581,33 @@ export class StripeProjectsAdapter {
         let addRes = await this.runStripeProjectsCli(buildAddArgs(tool.upstreamSlug, tool.metadata?.kind === "plan" ? undefined : resourceName), 60000);
         // Automatically handle PLAN_REQUIRED if the CLI asks for a companion plan first
         const errObj = (addRes.error || {});
+        const initialErrMsg = String(errObj.message || errObj.code || JSON.stringify(addRes.error || ""));
+        const isAlreadyExistingError = /already exists|conflict|duplicate|already tracked|already added|in use/i.test(initialErrMsg);
         if (addRes.ok === false &&
+            !isAlreadyExistingError &&
             (String(errObj.code || "").includes("PLAN_REQUIRED") || parentPlans.length > 0)) {
             const requestedPlan = input.plan ? String(input.plan).trim() : "";
             const planService = requestedPlan || parentPlans[0] || "free";
             const planTarget = planService.includes("/")
                 ? planService
                 : `${tool.providerSlug}/${planService}`;
-            await this.runStripeProjectsCli(["add", planTarget, "--accept-tos", "--yes"], 45000);
+            await this.runStripeProjectsCli(["add", planTarget, "--accept-tos", "--yes"], 45000).catch(() => null);
             provisionedPlan = planTarget;
             addRes = await this.runStripeProjectsCli(buildAddArgs(tool.upstreamSlug, resourceName), 60000);
         }
         if (addRes.ok === false) {
             const msg = String(addRes.error?.message ||
                 JSON.stringify(addRes.error || addRes));
-            throw new Error(`Stripe Projects provisioning failed for ${tool.upstreamSlug}: ${msg}`);
+            const liveAfter = await this.getLiveStatus().catch(() => null);
+            const existingSvc = liveAfter?.services?.find((s) => String(s.name || "").toLowerCase() === resourceName.toLowerCase());
+            if (!existingSvc &&
+                !/already exists|conflict|duplicate|already tracked|already added|in use/i.test(msg)) {
+                throw new Error(`Stripe Projects provisioning failed for ${tool.upstreamSlug}: ${msg}`);
+            }
         }
         const secrets = await this.pullEnvVarsFromWorkdir();
         const resData = (addRes.data || {});
+        const envVarKeys = Object.keys(secrets);
         return {
             output: {
                 provider: "stripe_projects",
@@ -589,7 +616,9 @@ export class StripeProjectsAdapter {
                 upstreamService: tool.upstreamSlug,
                 resourceName,
                 provisionedPlan,
-                envVarKeys: Object.keys(secrets),
+                envVarKeys,
+                vaultSavedKeys: envVarKeys,
+                secretKeysSaved: envVarKeys,
                 details: resData,
             },
             provisionedResource: {

package/dist/sdk.d.ts

@@ -12,6 +12,22 @@ export declare class MuxoClient {
     private readonly timeoutMs;
     constructor(options?: MuxoClientOptions);
     private request;
+    static signup(params?: {
+        workspaceName?: string;
+        ownerEmail?: string;
+        agentName?: string;
+        harness?: string;
+    }, baseUrl?: string): Promise<{
+        ok: true;
+        agentId: string;
+        workspace: Pick<Workspace, "id" | "name" | "slug" | "tier" | "creditsBalance">;
+        apiKey: string;
+        mcpEndpoint: string;
+        skillUrl: string;
+        claimEndpoint: string;
+        governanceDid: string;
+        supermemoryNamespace: string;
+    }>;
     signupAgent(params: {
         agentName?: string;
         harness?: string;
@@ -26,6 +42,14 @@ export declare class MuxoClient {
         governanceDid: string;
         supermemoryNamespace: string;
     }>;
+    whoami(): Promise<{
+        ok: true;
+        workspace: Workspace;
+        organization?: Workspace;
+        user?: Record<string, unknown>;
+        settlementSummary?: SupplierSettlementSummary;
+    }>;
+    mcpCall<T = Record<string, unknown>>(name: string, args?: Record<string, unknown>): Promise<T>;
     searchTools(params?: {
         query?: string;
         lane?: ProviderLane | "all";
@@ -64,7 +88,23 @@ export declare class MuxoClient {
         run: ExecutionRun;
         receipt: ExecutionReceipt;
     }>;
-    startConnection(params: {
+    exec(toolSlug: string, input?: Record<string, unknown>, options?: {
+        reason?: string;
+        approve?: boolean;
+    }): Promise<{
+        ok: true;
+        plan: ActionPlan;
+        run: ExecutionRun;
+        receipt: ExecutionReceipt;
+        settlement?: Record<string, unknown> | null;
+    }>;
+    verifyReceipt(receiptId: string): Promise<{
+        ok: true;
+        valid: boolean;
+        verified: boolean;
+        receipt: ExecutionReceipt;
+    }>;
+    startConnection(paramsOrProvider: string | {
         provider: string;
         lane?: ProviderLane;
         callbackUrl?: string;
@@ -72,12 +112,17 @@ export declare class MuxoClient {
         ok: true;
         connection: ConnectionRecord;
     }>;
-    waitForConnection(params: {
+    waitForConnection(paramsOrProvider: string | {
         provider: string;
         timeoutSeconds?: number;
+        simulateCallback?: boolean;
+    }, options?: {
+        timeoutSeconds?: number;
+        simulateCallback?: boolean;
     }): Promise<{
         ok: true;
         connection: ConnectionRecord;
+        status: ConnectionRecord["status"];
         ready: boolean;
         polledAttempts: number;
         elapsedMs: number;
@@ -92,20 +137,37 @@ export declare class MuxoClient {
         workspaceId: string;
         variables: Record<string, string>;
         dotenv: string;
+        includes: (substr: string) => boolean;
     }>;
-    topupCredits(params: {
+    topupCredits(paramsOrCredits: number | {
         credits: number;
         description?: string;
-    }): Promise<{
+    }, description?: string): Promise<{
         ok: true;
         creditsAdded: number;
+        creditBalance: number;
         usdPaid: number;
         workspace: Workspace;
         settlementSummary: SupplierSettlementSummary;
     }>;
+    getBillingStatus(): Promise<{
+        ok: true;
+        settlementSummary: SupplierSettlementSummary & {
+            totalCustomerChargedCredits?: number;
+        };
+    }>;
+    settlements(): Promise<{
+        ok: true;
+        settlementSummary: SupplierSettlementSummary & {
+            totalCustomerChargedCredits?: number;
+        };
+        summary?: SupplierSettlementSummary;
+    }>;
     getSettlements(): Promise<{
         ok: true;
-        settlementSummary: SupplierSettlementSummary;
+        settlementSummary: SupplierSettlementSummary & {
+            totalCustomerChargedCredits?: number;
+        };
     }>;
     recallMemory(query?: string): Promise<{
         ok: true;

package/dist/sdk.js

@@ -45,12 +45,50 @@ export class MuxoClient {
         }
         return payload;
     }
+    static async signup(params = {}, baseUrl = "https://app.muxo.ai") {
+        const client = new MuxoClient({ baseUrl });
+        return client.signupAgent({
+            agentName: params.agentName || params.workspaceName || "muxo-sdk-agent",
+            harness: params.harness || "muxo-sdk",
+        });
+    }
     async signupAgent(params) {
         return this.request("/api/v1/agents/signup", {
             method: "POST",
             body: params,
         });
     }
+    async whoami() {
+        const res = await this.mcpCall("get_organization", {});
+        const workspace = (res.workspace || res.organization);
+        return {
+            ok: true,
+            ...res,
+            workspace,
+        };
+    }
+    async mcpCall(name, args = {}) {
+        const rpcRes = await this.request("/mcp", {
+            method: "POST",
+            body: {
+                jsonrpc: "2.0",
+                id: Date.now(),
+                method: "tools/call",
+                params: { name, arguments: args },
+            },
+        });
+        if (rpcRes.error) {
+            throw new Error(rpcRes.error.message || "MCP call failed");
+        }
+        if (rpcRes.result?.structuredContent) {
+            return rpcRes.result.structuredContent;
+        }
+        const text = rpcRes.result?.content?.[0]?.text;
+        if (text) {
+            return JSON.parse(text);
+        }
+        return (rpcRes.result || {});
+    }
     async searchTools(params) {
         const qs = new URLSearchParams();
         if (params?.query)
@@ -83,32 +121,101 @@ export class MuxoClient {
             method: "POST",
         });
     }
-    async startConnection(params) {
+    async exec(toolSlug, input = {}, options = {}) {
+        const planned = await this.planAction({
+            toolSlug,
+            input,
+            reason: options.reason,
+        });
+        let plan = planned.plan;
+        if (plan.approvalStatus === "pending_approval" && options.approve) {
+            const approved = await this.approvePlan(plan.id);
+            plan = approved.plan;
+        }
+        const executed = await this.executePlan(plan.id);
+        return {
+            ok: true,
+            plan,
+            run: executed.run,
+            receipt: executed.receipt,
+            settlement: executed.settlement ||
+                executed.receipt?.supplierSettlement ||
+                null,
+        };
+    }
+    async verifyReceipt(receiptId) {
+        const res = await this.request(`/api/v1/receipts/${encodeURIComponent(receiptId)}`);
+        const isOk = Boolean(res.valid ?? res.verified ?? true);
+        return {
+            ok: true,
+            valid: isOk,
+            verified: isOk,
+            receipt: res.receipt,
+        };
+    }
+    async startConnection(paramsOrProvider) {
+        const body = typeof paramsOrProvider === "string"
+            ? { provider: paramsOrProvider }
+            : paramsOrProvider;
         return this.request("/api/v1/connections", {
             method: "POST",
-            body: params,
+            body,
         });
     }
-    async waitForConnection(params) {
-        return this.request("/api/v1/connections/wait", {
+    async waitForConnection(paramsOrProvider, options) {
+        const body = typeof paramsOrProvider === "string"
+            ? { provider: paramsOrProvider, ...options }
+            : paramsOrProvider;
+        const res = await this.request("/api/v1/connections/wait", {
             method: "POST",
-            body: params,
+            body,
         });
+        return {
+            ...res,
+            status: res.status || res.connection?.status || "pending",
+        };
     }
     async listResources() {
         return this.request("/api/v1/resources");
     }
     async pullEnv() {
-        return this.request("/api/v1/resources/env");
+        const res = await this.request("/api/v1/resources/env");
+        return Object.assign(res, {
+            includes: (substr) => String(res.dotenv || "").includes(substr),
+            toString: () => String(res.dotenv || ""),
+        });
     }
-    async topupCredits(params) {
-        return this.request("/api/v1/billing/topup", {
+    async topupCredits(paramsOrCredits, description) {
+        const body = typeof paramsOrCredits === "number"
+            ? { credits: paramsOrCredits, description }
+            : paramsOrCredits;
+        const res = await this.request("/api/v1/billing/topup", {
             method: "POST",
-            body: params,
+            body,
         });
+        return {
+            ...res,
+            creditBalance: res.creditBalance ?? res.workspace?.creditsBalance ?? 0,
+        };
+    }
+    async getBillingStatus() {
+        return this.getSettlements();
+    }
+    async settlements() {
+        const res = await this.getSettlements();
+        return {
+            ...res,
+            summary: res.settlementSummary,
+        };
     }
     async getSettlements() {
-        return this.request("/api/v1/billing/settlements");
+        const res = await this.request("/api/v1/billing/settlements");
+        if (res.settlementSummary &&
+            res.settlementSummary.totalCustomerChargedCredits === undefined) {
+            res.settlementSummary.totalCustomerChargedCredits =
+                res.settlementSummary.totalCreditsConsumed;
+        }
+        return res;
     }
     async recallMemory(query) {
         const suffix = query ? `?query=${encodeURIComponent(query)}` : "";