@muxoai/platform 1.2.3 → 1.3.1

package/dist/providers/supermemory.js

@@ -8,19 +8,39 @@ import Supermemory from "supermemory";
 export class SupermemoryAdapter {
     config;
     client;
+    unavailableUntil = 0;
     constructor(config) {
         this.config = config;
         if (config.supermemoryApiKey) {
             this.client = new Supermemory({
                 apiKey: config.supermemoryApiKey,
                 baseUrl: config.supermemoryBaseUrl,
-                maxRetries: 1,
+                maxRetries: 0,
             });
         }
         else {
             this.client = null;
         }
     }
+    withTimeout(p, ms = 1000) {
+        if (Date.now() < this.unavailableUntil) {
+            p.catch(() => { });
+            return Promise.resolve(null);
+        }
+        return Promise.race([
+            p,
+            new Promise((resolve) => {
+                const t = setTimeout(() => {
+                    this.unavailableUntil = Date.now() + 30_000;
+                    resolve(null);
+                }, ms);
+                t.unref?.();
+            }),
+        ]).catch(() => {
+            this.unavailableUntil = Date.now() + 30_000;
+            return null;
+        });
+    }
     isEnabled() {
         return Boolean(this.client);
     }
@@ -74,10 +94,22 @@ export class SupermemoryAdapter {
         let dynamicFacts = [];
         let preferences = [];
         const relevantMemories = [];
-        try {
-            const profileRes = await this.client.profile(namespace, {
+        const [profileOutcome, searchOutcome] = await Promise.allSettled([
+            this.withTimeout(this.client.profile(namespace, {
                 ...(params.query ? { q: params.query } : {}),
-            });
+            }), 1000),
+            params.query && params.query.trim().length > 0
+                ? this.withTimeout(this.client.search(namespace, {
+                    query: params.query.trim(),
+                    limit,
+                    searchMode: "hybrid",
+                    include: { documents: true, forgotten: false, related: false },
+                    rewriteQuery: false,
+                }), 1000)
+                : Promise.resolve(null),
+        ]);
+        if (profileOutcome.status === "fulfilled" && profileOutcome.value) {
+            const profileRes = profileOutcome.value;
             staticFacts = Array.isArray(profileRes?.profile?.static)
                 ? profileRes.profile.static.map(String)
                 : [];
@@ -88,36 +120,22 @@ export class SupermemoryAdapter {
                 ? profileRes.profile.buckets.preferences.map(String)
                 : [];
         }
-        catch {
-            // Fail-open: never block tool planning if profile endpoint times out
-        }
-        if (params.query && params.query.trim().length > 0) {
-            try {
-                const searchRes = await this.client.search(namespace, {
-                    query: params.query.trim(),
-                    limit,
-                    searchMode: "hybrid",
-                    include: { documents: true, forgotten: false, related: false },
-                    rewriteQuery: false,
+        if (searchOutcome.status === "fulfilled" && searchOutcome.value) {
+            const searchRes = searchOutcome.value;
+            for (const item of (searchRes?.results || []).slice(0, limit)) {
+                const doc = item.included?.document;
+                const title = String(doc?.metadata?.title ||
+                    doc?.title ||
+                    item.memory ||
+                    item.chunk ||
+                    "Workspace Memory").slice(0, 120);
+                const snippet = String(item.memory || item.chunk || doc?.metadata?.summary || "").slice(0, 300);
+                relevantMemories.push({
+                    documentId: String(doc?.id || item.id || ""),
+                    title,
+                    snippet,
+                    similarity: Number(item.similarity || 0),
                 });
-                for (const item of (searchRes?.results || []).slice(0, limit)) {
-                    const doc = item.included?.document;
-                    const title = String(doc?.metadata?.title ||
-                        doc?.title ||
-                        item.memory ||
-                        item.chunk ||
-                        "Workspace Memory").slice(0, 120);
-                    const snippet = String(item.memory || item.chunk || doc?.metadata?.summary || "").slice(0, 300);
-                    relevantMemories.push({
-                        documentId: String(doc?.id || item.id || ""),
-                        title,
-                        snippet,
-                        similarity: Number(item.similarity || 0),
-                    });
-                }
-            }
-            catch {
-                // Fail-open
             }
         }
         const promptLines = [
@@ -162,7 +180,7 @@ export class SupermemoryAdapter {
                 sanitizedContent,
             };
         }
-        const res = await this.client.add(namespace, {
+        const res = await this.withTimeout(this.client.add(namespace, {
             id: docId,
             content: `${params.title}\n\n${sanitizedContent}`,
             taskType: "memory",
@@ -172,11 +190,11 @@ export class SupermemoryAdapter {
                 muxoKind: params.kind,
                 ...(params.metadata || {}),
             },
-        });
+        }), 1500);
         return {
-            documentId: String(res.id || docId),
+            documentId: String(res?.id || docId),
             namespace,
-            status: String(res.status || "queued"),
+            status: String(res?.status || "queued"),
             sanitizedContent,
         };
     }
@@ -194,7 +212,7 @@ export class SupermemoryAdapter {
                     status: params.status,
                 },
             });
-            return added.documentId;
+            return added ? added.documentId : null;
         }
         catch {
             return null;
@@ -209,9 +227,9 @@ export class SupermemoryAdapter {
             return { deleted: true, namespace };
         }
         try {
-            const res = await this.client.documents.delete(namespace, {
+            const res = await this.withTimeout(this.client.documents.delete(namespace, {
                 ids: [documentId],
-            });
+            }), 1200);
             return {
                 deleted: (res?.count || 0) >= 1,
                 namespace,

package/dist/sdk.d.ts

@@ -1,4 +1,4 @@
-import type { ActionPlan, ConnectionRecord, ExecutionReceipt, ExecutionRun, MuxoTool, ProviderLane, ProvisionedResource, RiskLevel, SupplierSettlementSummary, Workspace, WorkspaceMemoryRecord } from "./types.js";
+import type { ActionPlan, ByokKeyRecord, ConnectionRecord, ExecutionReceipt, ExecutionRun, MuxoTool, ProviderLane, ProvisionedResource, RiskLevel, SupplierSettlementSummary, Workspace, WorkspaceMemoryRecord } from "./types.js";
 export interface MuxoClientOptions {
     baseUrl?: string;
     apiKey?: string | (() => string | Promise<string>);
@@ -174,4 +174,80 @@ export declare class MuxoClient {
         namespace: string;
         records: WorkspaceMemoryRecord[];
     }>;
+    do(prompt: string, options?: {
+        input?: Record<string, unknown>;
+        autoApprove?: boolean;
+        dryRun?: boolean;
+    }): Promise<{
+        ok: boolean;
+        executed: boolean;
+        status: string;
+        intent: {
+            toolSlug: string | null;
+            input: Record<string, unknown>;
+            extractedInput: Record<string, unknown>;
+            reason: string;
+            confidence: number;
+        };
+        resolution: Record<string, unknown>;
+        plan?: ActionPlan;
+        run?: ExecutionRun;
+        receipt?: ExecutionReceipt;
+        humanMessage: string;
+    }>;
+    ask(prompt: string, options?: {
+        input?: Record<string, unknown>;
+        autoApprove?: boolean;
+        dryRun?: boolean;
+    }): Promise<{
+        ok: boolean;
+        executed: boolean;
+        status: string;
+        intent: {
+            toolSlug: string | null;
+            input: Record<string, unknown>;
+            extractedInput: Record<string, unknown>;
+            reason: string;
+            confidence: number;
+        };
+        resolution: Record<string, unknown>;
+        plan?: ActionPlan;
+        run?: ExecutionRun;
+        receipt?: ExecutionReceipt;
+        humanMessage: string;
+    }>;
+    listByokKeys(): Promise<{
+        ok: true;
+        workspaceId: string;
+        keys: ByokKeyRecord[];
+    }>;
+    setByokKey(provider: string, secretKey: string): Promise<{
+        ok: true;
+        key: ByokKeyRecord;
+        keys: ByokKeyRecord[];
+    }>;
+    deleteByokKey(provider: string): Promise<{
+        ok: true;
+        deleted: boolean;
+        provider: string;
+        keys: ByokKeyRecord[];
+    }>;
+    upgradePlan(): Promise<{
+        ok: true;
+        tier: string;
+        workspace: Workspace;
+        settlementSummary: SupplierSettlementSummary;
+    }>;
+    createCheckoutSession(kind?: "starter_subscription" | "credit_topup"): Promise<{
+        ok: true;
+        sessionId: string;
+        url: string;
+        mode?: string;
+    }>;
+    verifyCheckoutSession(sessionId: string): Promise<{
+        ok: true;
+        fulfilled: boolean;
+        workspace: Workspace | null;
+        kind: string;
+    }>;
 }

package/dist/sdk.js

@@ -221,4 +221,50 @@ export class MuxoClient {
         const suffix = query ? `?query=${encodeURIComponent(query)}` : "";
         return this.request(`/api/v1/memory${suffix}`);
     }
+    async do(prompt, options = {}) {
+        return this.request("/api/v1/do", {
+            method: "POST",
+            body: {
+                prompt,
+                input: options.input,
+                autoApprove: options.autoApprove !== false,
+                dryRun: options.dryRun === true,
+            },
+        });
+    }
+    async ask(prompt, options) {
+        return this.do(prompt, options);
+    }
+    async listByokKeys() {
+        return this.request("/api/v1/byok");
+    }
+    async setByokKey(provider, secretKey) {
+        return this.request("/api/v1/byok", {
+            method: "POST",
+            body: { provider, secretKey },
+        });
+    }
+    async deleteByokKey(provider) {
+        return this.request(`/api/v1/byok/${encodeURIComponent(provider)}`, {
+            method: "DELETE",
+        });
+    }
+    async upgradePlan() {
+        return this.request("/api/v1/billing/upgrade", {
+            method: "POST",
+            body: {},
+        });
+    }
+    async createCheckoutSession(kind = "credit_topup") {
+        return this.request("/api/v1/billing/checkout", {
+            method: "POST",
+            body: { kind },
+        });
+    }
+    async verifyCheckoutSession(sessionId) {
+        return this.request("/api/v1/billing/verify-session", {
+            method: "POST",
+            body: { sessionId },
+        });
+    }
 }