@muxoai/platform 1.3.1 → 1.3.2

package/dist/sdk.d.ts

@@ -1,4 +1,10 @@
-import type { ActionPlan, ByokKeyRecord, ConnectionRecord, ExecutionReceipt, ExecutionRun, MuxoTool, ProviderLane, ProvisionedResource, RiskLevel, SupplierSettlementSummary, Workspace, WorkspaceMemoryRecord } from "./types.js";
+import type { ActionPlan, ByokKeyRecord, ConnectionRecord, ExecutionReceipt, ExecutionRun, GovernancePolicy, MuxoTool, ProviderLane, ProvisionedResource, RiskLevel, SupplierSettlementSummary, TemporalGraphFact, Workspace, WorkspaceMemoryRecord } from "./types.js";
+export interface MuxoTrustScore {
+    overall: number;
+    tier: string;
+    reliability?: number;
+    consistency?: number;
+}
 export interface MuxoClientOptions {
     baseUrl?: string;
     apiKey?: string | (() => string | Promise<string>);
@@ -28,6 +34,50 @@ export declare class MuxoClient {
         governanceDid: string;
         supermemoryNamespace: string;
     }>;
+    static register(params: {
+        email: string;
+        password: string;
+        name?: string;
+        workspaceName?: string;
+    }, baseUrl?: string): Promise<{
+        ok: true;
+        user: Record<string, unknown>;
+        workspace: Workspace;
+        apiKey: string;
+        token: string;
+    }>;
+    static login(params: {
+        email: string;
+        password: string;
+    }, baseUrl?: string): Promise<{
+        ok: true;
+        user: Record<string, unknown>;
+        workspace: Workspace;
+        apiKey: string;
+        token: string;
+    }>;
+    register(params: {
+        email: string;
+        password: string;
+        name?: string;
+        workspaceName?: string;
+    }): Promise<{
+        ok: true;
+        user: Record<string, unknown>;
+        workspace: Workspace;
+        apiKey: string;
+        token: string;
+    }>;
+    login(params: {
+        email: string;
+        password: string;
+    }): Promise<{
+        ok: true;
+        user: Record<string, unknown>;
+        workspace: Workspace;
+        apiKey: string;
+        token: string;
+    }>;
     signupAgent(params: {
         agentName?: string;
         harness?: string;
@@ -65,6 +115,7 @@ export declare class MuxoClient {
         toolSlug: string;
         input: Record<string, unknown>;
         reason?: string;
+        fundingMode?: "muxo_funded" | "byok";
     }): Promise<{
         ok: true;
         plan: ActionPlan;
@@ -79,6 +130,10 @@ export declare class MuxoClient {
             instructions: string;
         };
     }>;
+    getPlan(planId: string): Promise<{
+        ok: true;
+        plan: ActionPlan;
+    }>;
     approvePlan(planId: string): Promise<{
         ok: true;
         plan: ActionPlan;
@@ -88,9 +143,19 @@ export declare class MuxoClient {
         run: ExecutionRun;
         receipt: ExecutionReceipt;
     }>;
+    getRun(runId: string): Promise<{
+        ok: true;
+        run: ExecutionRun;
+    }>;
+    cancelRun(runId: string, reason?: string): Promise<{
+        ok: true;
+        run: ExecutionRun;
+        receipt: ExecutionReceipt;
+    }>;
     exec(toolSlug: string, input?: Record<string, unknown>, options?: {
         reason?: string;
         approve?: boolean;
+        fundingMode?: "muxo_funded" | "byok";
     }): Promise<{
         ok: true;
         plan: ActionPlan;
@@ -152,6 +217,11 @@ export declare class MuxoClient {
     }>;
     getBillingStatus(): Promise<{
         ok: true;
+        workspace?: Workspace;
+        creditsBalance?: number;
+        creditBalance?: number;
+        tier?: string;
+        byokKeys?: ByokKeyRecord[];
         settlementSummary: SupplierSettlementSummary & {
             totalCustomerChargedCredits?: number;
         };
@@ -173,11 +243,105 @@ export declare class MuxoClient {
         ok: true;
         namespace: string;
         records: WorkspaceMemoryRecord[];
+        recentMemories?: WorkspaceMemoryRecord[];
+        memories?: WorkspaceMemoryRecord[];
+    }>;
+    addMemory(paramsOrContent: string | {
+        title?: string;
+        content: string;
+        kind?: WorkspaceMemoryRecord["kind"];
+        subject?: string;
+        predicate?: string;
+        object?: string;
+        confidence?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        ok: true;
+        memory: WorkspaceMemoryRecord;
+        temporalFacts?: Array<Record<string, unknown>>;
+        fundingSource?: string;
+    }>;
+    deleteMemory(id: string): Promise<{
+        ok: true;
+        deleted: boolean;
+        record: WorkspaceMemoryRecord | null;
+    }>;
+    getMemoryFacts(options?: boolean | {
+        includeHistorical?: boolean;
+        query?: string;
+        subject?: string;
+        predicate?: string;
+        limit?: number;
+    }): Promise<{
+        ok: true;
+        activeFacts: TemporalGraphFact[];
+        historicalFacts: TemporalGraphFact[];
+        facts: TemporalGraphFact[];
+    }>;
+    listTemporalFacts(options?: Parameters<MuxoClient["getMemoryFacts"]>[0]): Promise<{
+        ok: true;
+        activeFacts: TemporalGraphFact[];
+        historicalFacts: TemporalGraphFact[];
+        facts: TemporalGraphFact[];
+    }>;
+    forgetMemory(queryOrParams: string | {
+        query: string;
+    }): Promise<{
+        ok: true;
+        query: string;
+        deletedLocalCount: number;
+        invalidatedFactsCount: number;
+        deletedRemoteIds: string[];
+        deletedMemories: WorkspaceMemoryRecord[];
+        invalidatedFacts: TemporalGraphFact[];
+    }>;
+    getGovernanceStatus(): Promise<{
+        ok: true;
+        governance: Record<string, unknown> & {
+            modules?: unknown;
+            trustScore?: MuxoTrustScore;
+            killSwitch?: Record<string, unknown> | null;
+            auditChain?: Record<string, unknown>;
+        };
+        workspacePolicy: GovernancePolicy;
+    }>;
+    setKillSwitch(action: "quarantine" | "terminate" | "suspend" | "resume", reason?: string): Promise<{
+        ok: true;
+        activated?: boolean;
+        resumed?: boolean;
+        killSwitch?: Record<string, unknown>;
+        policy: GovernancePolicy;
+        trustScore: MuxoTrustScore;
+    }>;
+    scanContext(contentOrParams: string | {
+        content: string;
+        sessionId?: string;
+        role?: "user" | "assistant" | "tool" | "system";
+    }): Promise<{
+        ok: true;
+        scan: {
+            safe: boolean;
+            riskLevel: "none" | "low" | "medium" | "high" | "critical";
+            findingsCount: number;
+            findings: Array<{
+                patternId: string;
+                patternName: string;
+                severity: string;
+                description: string;
+            }>;
+            integrityValid: boolean;
+        };
+    }>;
+    updatePolicy(policy: Partial<Omit<GovernancePolicy, "killSwitchActive" | "killSwitchReason">>): Promise<{
+        ok: true;
+        workspace: Workspace;
     }>;
     do(prompt: string, options?: {
         input?: Record<string, unknown>;
         autoApprove?: boolean;
         dryRun?: boolean;
+        planOnly?: boolean;
+        fundingMode?: "muxo_funded" | "byok";
     }): Promise<{
         ok: boolean;
         executed: boolean;
@@ -199,6 +363,8 @@ export declare class MuxoClient {
         input?: Record<string, unknown>;
         autoApprove?: boolean;
         dryRun?: boolean;
+        planOnly?: boolean;
+        fundingMode?: "muxo_funded" | "byok";
     }): Promise<{
         ok: boolean;
         executed: boolean;

package/dist/sdk.js

@@ -52,6 +52,26 @@ export class MuxoClient {
             harness: params.harness || "muxo-sdk",
         });
     }
+    static async register(params, baseUrl = "https://app.muxo.ai") {
+        const client = new MuxoClient({ baseUrl });
+        return client.register(params);
+    }
+    static async login(params, baseUrl = "https://app.muxo.ai") {
+        const client = new MuxoClient({ baseUrl });
+        return client.login(params);
+    }
+    async register(params) {
+        return this.request("/api/v1/auth/register", {
+            method: "POST",
+            body: params,
+        });
+    }
+    async login(params) {
+        return this.request("/api/v1/auth/login", {
+            method: "POST",
+            body: params,
+        });
+    }
     async signupAgent(params) {
         return this.request("/api/v1/agents/signup", {
             method: "POST",
@@ -80,6 +100,10 @@ export class MuxoClient {
         if (rpcRes.error) {
             throw new Error(rpcRes.error.message || "MCP call failed");
         }
+        if (rpcRes.result?.isError) {
+            const errObj = rpcRes.result.structuredContent;
+            throw new Error(String(errObj?.error || rpcRes.result.content?.[0]?.text || "MCP tool execution failed"));
+        }
         if (rpcRes.result?.structuredContent) {
             return rpcRes.result.structuredContent;
         }
@@ -111,6 +135,9 @@ export class MuxoClient {
             body: params,
         });
     }
+    async getPlan(planId) {
+        return this.request(`/api/v1/plans/${encodeURIComponent(planId)}`);
+    }
     async approvePlan(planId) {
         return this.request(`/api/v1/plans/${encodeURIComponent(planId)}/approve`, {
             method: "POST",
@@ -121,11 +148,21 @@ export class MuxoClient {
             method: "POST",
         });
     }
+    async getRun(runId) {
+        return this.request(`/api/v1/runs/${encodeURIComponent(runId)}`);
+    }
+    async cancelRun(runId, reason) {
+        return this.request(`/api/v1/runs/${encodeURIComponent(runId)}/cancel`, {
+            method: "POST",
+            body: reason ? { reason } : {},
+        });
+    }
     async exec(toolSlug, input = {}, options = {}) {
         const planned = await this.planAction({
             toolSlug,
             input,
             reason: options.reason,
+            fundingMode: options.fundingMode,
         });
         let plan = planned.plan;
         if (plan.approvalStatus === "pending_approval" && options.approve) {
@@ -199,7 +236,13 @@ export class MuxoClient {
         };
     }
     async getBillingStatus() {
-        return this.getSettlements();
+        const res = await this.request("/api/v1/billing/status");
+        if (res.settlementSummary &&
+            res.settlementSummary.totalCustomerChargedCredits === undefined) {
+            res.settlementSummary.totalCustomerChargedCredits =
+                res.settlementSummary.totalCreditsConsumed;
+        }
+        return res;
     }
     async settlements() {
         const res = await this.getSettlements();
@@ -221,14 +264,82 @@ export class MuxoClient {
         const suffix = query ? `?query=${encodeURIComponent(query)}` : "";
         return this.request(`/api/v1/memory${suffix}`);
     }
+    async addMemory(paramsOrContent) {
+        const body = typeof paramsOrContent === "string"
+            ? { title: paramsOrContent.slice(0, 60), content: paramsOrContent }
+            : paramsOrContent;
+        return this.request("/api/v1/memory", {
+            method: "POST",
+            body,
+        });
+    }
+    async deleteMemory(id) {
+        return this.request(`/api/v1/memory/${encodeURIComponent(id)}`, {
+            method: "DELETE",
+        });
+    }
+    async getMemoryFacts(options = {}) {
+        const opts = typeof options === "boolean" ? { includeHistorical: options } : options;
+        const params = new URLSearchParams();
+        params.set("historical", opts.includeHistorical === false ? "false" : "true");
+        if (opts.query)
+            params.set("query", opts.query);
+        if (opts.subject)
+            params.set("subject", opts.subject);
+        if (opts.predicate)
+            params.set("predicate", opts.predicate);
+        if (opts.limit)
+            params.set("limit", String(opts.limit));
+        return this.request(`/api/v1/memory/facts?${params.toString()}`);
+    }
+    async listTemporalFacts(options) {
+        return this.getMemoryFacts(options);
+    }
+    async forgetMemory(queryOrParams) {
+        const query = (typeof queryOrParams === "string" ? queryOrParams : queryOrParams.query)?.trim();
+        if (!query) {
+            throw new Error("forgetMemory requires a non-empty query");
+        }
+        return this.request("/api/v1/memory/forget", {
+            method: "POST",
+            body: { query },
+        });
+    }
+    async getGovernanceStatus() {
+        return this.request("/api/v1/governance");
+    }
+    async setKillSwitch(action, reason) {
+        return this.request("/api/v1/governance/kill-switch", {
+            method: "POST",
+            body: reason ? { action, reason } : { action },
+        });
+    }
+    async scanContext(contentOrParams) {
+        const body = typeof contentOrParams === "string"
+            ? { content: contentOrParams }
+            : contentOrParams;
+        return this.request("/api/v1/governance/scan-context", {
+            method: "POST",
+            body,
+        });
+    }
+    async updatePolicy(policy) {
+        return this.request("/api/v1/policy", {
+            method: "POST",
+            body: policy,
+        });
+    }
     async do(prompt, options = {}) {
+        const isDryRun = options.dryRun === true || options.planOnly === true;
         return this.request("/api/v1/do", {
             method: "POST",
             body: {
                 prompt,
                 input: options.input,
                 autoApprove: options.autoApprove !== false,
-                dryRun: options.dryRun === true,
+                dryRun: isDryRun,
+                planOnly: isDryRun,
+                fundingMode: options.fundingMode,
             },
         });
     }