@muxoai/sdk 1.2.1 → 1.2.2

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,30 @@ 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;
+        };
+    }>;
     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,94 @@ 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 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)}` : "";

package/package.json

@@ -1,40 +1,31 @@
 {
   "name": "@muxoai/sdk",
-  "version": "1.2.1",
-  "description": "Muxo TypeScript/JavaScript SDK — Typed client for governed agent actions, OAuth handoffs, infrastructure provisioning, and receipts",
-  "license": "MIT",
-  "homepage": "https://muxo.ai",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/muxoai/muxo.git"
-  },
-  "keywords": [
-    "muxo",
-    "sdk",
-    "agents",
-    "mcp",
-    "composio",
-    "stripe",
-    "governance",
-    "supermemory"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
+  "version": "1.2.2",
+  "description": "Muxo TypeScript/JavaScript SDK — Official client for Muxo Unified AI Agent Execution, Infrastructure, Memory & Governance Platform",
   "type": "module",
   "main": "./dist/sdk.js",
   "types": "./dist/sdk.d.ts",
   "exports": {
     ".": {
       "types": "./dist/sdk.d.ts",
-      "default": "./dist/sdk.js"
+      "import": "./dist/sdk.js"
     }
   },
   "files": [
     "dist",
     "README.md"
   ],
+  "keywords": [
+    "muxo",
+    "ai-agents",
+    "mcp",
+    "composio",
+    "stripe-projects",
+    "supermemory",
+    "microsoft-agent-governance"
+  ],
+  "license": "MIT",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   }
 }