@muxoai/platform 1.3.1 → 1.3.2

package/dist/providers/stripe-projects.js

@@ -4,6 +4,22 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { ROOT_DIR } from "../config.js";
 const execFileAsync = promisify(execFile);
+export function isPaidCloudProvisioning(tool, input) {
+    if (tool.lane !== "stripe_projects")
+        return false;
+    if (Boolean(tool.metadata?.isPaidService) || tool.creditCost >= 15) {
+        return true;
+    }
+    const requestedPlan = String(input?.plan || "")
+        .trim()
+        .toLowerCase();
+    if (!requestedPlan)
+        return false;
+    const planLeaf = requestedPlan.includes("/")
+        ? requestedPlan.split("/").pop() || requestedPlan
+        : requestedPlan;
+    return /^(pro|scaler|paid|scale|business|team|grow|credits|launch|enterprise|plus)$/i.test(planLeaf);
+}
 export class StripeProjectsAdapter {
     config;
     tools = new Map();
@@ -152,6 +168,13 @@ export class StripeProjectsAdapter {
             const hasConfigProps = svc.configuration_schema &&
                 typeof svc.configuration_schema === "object" &&
                 Object.keys(svc.configuration_schema.properties || {}).length > 0;
+            const pricingType = String(svc.pricing?.type || "")
+                .trim()
+                .toLowerCase();
+            const isPaidService = (svc.kind === "plan" &&
+                ((pricingType.length > 0 && pricingType !== "free") ||
+                    /^(pro|scaler|paid|scale|business|team|grow|credits|launch|enterprise|plus)$/i.test(svc.service_id))) ||
+                /^(credits|workers_paid)$/i.test(svc.service_id);
             const tool = {
                 slug: muxoSlug,
                 upstreamSlug,
@@ -164,7 +187,7 @@ export class StripeProjectsAdapter {
                 categories: Array.from(new Set([...(svc.categories || []), "infrastructure"])),
                 riskLevel: "provisioning",
                 requiresAuth: false,
-                creditCost: 5,
+                creditCost: isPaidService ? 25 : 5,
                 billingMode: "resource_provisioning",
                 inputSchema: {
                     type: "object",
@@ -203,6 +226,8 @@ export class StripeProjectsAdapter {
                 metadata: {
                     kind: svc.kind,
                     serviceId: svc.service_id,
+                    isPaidService,
+                    pricingType: pricingType || (isPaidService ? "paid" : "free"),
                     parentPlans,
                     configurationSchema: svc.configuration_schema || null,
                     providerUrl: matchedProvider?.url || null,
@@ -375,9 +400,13 @@ export class StripeProjectsAdapter {
                 : `Provider ${slug} is linked and ready in Stripe Projects.`,
         };
     }
-    async pullEnvVarsFromWorkdir() {
-        await this.runStripeProjectsCli(["env", "--pull"], 20000).catch(() => null);
+    async pullEnvVarsFromWorkdir(syncFromCli = false) {
+        if (!this.hasLocalProjectsWorkdir)
+            return {};
         const envPath = path.join(this.config.stripeProjectsWorkdir, ".env");
+        if (syncFromCli || !fs.existsSync(envPath)) {
+            await this.runStripeProjectsCli(["env", "--pull"], 10000).catch(() => null);
+        }
         if (!fs.existsSync(envPath))
             return {};
         const raw = fs.readFileSync(envPath, "utf8");
@@ -403,6 +432,15 @@ export class StripeProjectsAdapter {
     }
     async executeTool(params) {
         const { tool, input } = params;
+        const isPaidPlan = isPaidCloudProvisioning(tool, input);
+        const requestedPlanRaw = input.plan ? String(input.plan).trim() : "";
+        const hasCustomerStripeByok = Boolean(params.stripeApiKey && params.stripeApiKey.trim());
+        const isMasterWalletEmpty = Boolean(params.masterWalletDepleted) ||
+            process.env.MUXO_MASTER_WALLET_DEPLETED === "true" ||
+            input._simulateMasterWalletEmpty === true;
+        if (isPaidPlan && !hasCustomerStripeByok && isMasterWalletEmpty) {
+            throw new Error(`MUXO_MASTER_WALLET_DEPLETED: Cannot provision paid cloud plan '${requestedPlanRaw || tool.upstreamSlug}' via Muxo Master Wallet because master supplier funds are depleted. 0 credits were charged to your workspace. Configure your own Stripe key via 'muxo byok set stripe <rk_live_...>' to provision paid plans at 0 Muxo credits, or select a 'free' plan.`);
+        }
         if (tool.slug === "resource.projects.status") {
             const status = await this.getLiveStatus();
             return {
@@ -440,7 +478,7 @@ export class StripeProjectsAdapter {
                 };
             }
             const res = await this.runStripeProjectsCli(["rotate", resourceName, "--yes"], 45000);
-            const secrets = await this.pullEnvVarsFromWorkdir();
+            const secrets = await this.pullEnvVarsFromWorkdir(true);
             return {
                 output: {
                     provider: "stripe_projects",
@@ -523,6 +561,8 @@ export class StripeProjectsAdapter {
                     [`${prefix}_URL`]: `https://${resourceName}.${tool.providerSlug}.muxo.cloud`,
                     [`${prefix}_API_KEY`]: `muxo_secret_${tool.providerSlug}_${Date.now()}`,
                 };
+            const resolvedPlanSlug = requestedPlanRaw ||
+                (isPaidPlan ? serviceId : tool.metadata?.parentPlans?.[0] || "free");
             return {
                 output: {
                     provider: "stripe_projects",
@@ -530,7 +570,9 @@ export class StripeProjectsAdapter {
                     tool: tool.slug,
                     upstreamService: tool.upstreamSlug,
                     resourceName,
-                    provisionedPlan: tool.metadata?.parentPlans?.[0] || "free",
+                    provisionedPlan: resolvedPlanSlug,
+                    billingTier: isPaidPlan ? "paid" : "free",
+                    fundingSource: hasCustomerStripeByok ? "customer_byok_stripe" : "muxo_master_wallet",
                     envVarKeys: Object.keys(secrets),
                     details: {
                         id: `ext_${tool.providerSlug}_${Date.now()}`,
@@ -543,7 +585,7 @@ export class StripeProjectsAdapter {
                     providerSlug: tool.providerSlug,
                     providerName: tool.providerName,
                     serviceSlug: serviceId,
-                    planSlug: tool.metadata?.parentPlans?.[0] || "free",
+                    planSlug: resolvedPlanSlug,
                     status: "active",
                     secrets,
                     externalResourceId: `ext_${tool.providerSlug}_${Date.now()}`,
@@ -552,7 +594,7 @@ export class StripeProjectsAdapter {
         }
         // Check if a parent plan is required first
         const parentPlans = tool.metadata?.parentPlans || [];
-        let provisionedPlan = null;
+        let provisionedPlan = requestedPlanRaw || null;
         // Auto-fill required config fields (e.g. name, location/region) from configurationSchema if omitted
         const configSchema = (tool.metadata?.configurationSchema || {});
         const mergedConfig = input.config && typeof input.config === "object"
@@ -608,6 +650,11 @@ export class StripeProjectsAdapter {
             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)) {
+                if (isPaidPlan &&
+                    !hasCustomerStripeByok &&
+                    /payment_method_required|insufficient_funds|card_declined|402|billing_required|master_wallet_depleted/i.test(msg)) {
+                    throw new Error(`MUXO_MASTER_WALLET_DEPLETED: Upstream supplier billing failed for paid plan '${provisionedPlan || tool.upstreamSlug}' (${msg}). 0 credits were charged to your workspace. Configure your own Stripe key via 'muxo byok set stripe <rk_live_...>' to provision paid plans at 0 Muxo credits.`);
+                }
                 // Fallback to Muxo Cloud Infrastructure managed provisioning when local CLI requires browser auth or provider account linking
                 const prefix = tool.providerSlug.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
                 const fallbackSecrets = tool.providerSlug === "turso"
@@ -623,6 +670,7 @@ export class StripeProjectsAdapter {
                     };
                 const authUrlMatch = msg.match(/https?:\/\/[^\s"'<>]+/i);
                 const fallbackKeys = Object.keys(fallbackSecrets);
+                const resolvedFallbackPlan = provisionedPlan || (isPaidPlan ? serviceId : parentPlans[0] || "free");
                 return {
                     output: {
                         provider: "stripe_projects",
@@ -630,7 +678,11 @@ export class StripeProjectsAdapter {
                         tool: tool.slug,
                         upstreamService: tool.upstreamSlug,
                         resourceName,
-                        provisionedPlan: provisionedPlan || parentPlans[0] || "free",
+                        provisionedPlan: resolvedFallbackPlan,
+                        billingTier: isPaidPlan ? "paid" : "free",
+                        fundingSource: hasCustomerStripeByok
+                            ? "customer_byok_stripe"
+                            : "muxo_master_wallet",
                         envVarKeys: fallbackKeys,
                         vaultSavedKeys: fallbackKeys,
                         secretKeysSaved: fallbackKeys,
@@ -646,7 +698,7 @@ export class StripeProjectsAdapter {
                         providerSlug: tool.providerSlug,
                         providerName: tool.providerName,
                         serviceSlug: serviceId,
-                        planSlug: provisionedPlan || parentPlans[0] || "free",
+                        planSlug: resolvedFallbackPlan,
                         status: "active",
                         secrets: fallbackSecrets,
                         externalResourceId: `ext_${tool.providerSlug}_${Date.now()}`,
@@ -672,7 +724,9 @@ export class StripeProjectsAdapter {
                 tool: tool.slug,
                 upstreamService: tool.upstreamSlug,
                 resourceName,
-                provisionedPlan,
+                provisionedPlan: provisionedPlan || (isPaidPlan ? serviceId : parentPlans[0] || "free"),
+                billingTier: isPaidPlan ? "paid" : "free",
+                fundingSource: hasCustomerStripeByok ? "customer_byok_stripe" : "muxo_master_wallet",
                 envVarKeys,
                 vaultSavedKeys: envVarKeys,
                 secretKeysSaved: envVarKeys,

package/dist/providers/supermemory.d.ts

@@ -8,10 +8,12 @@ import type { MemoryContextSummary, MemoryRecordKind } from "../types.js";
 export declare class SupermemoryAdapter {
     private readonly config;
     private readonly client;
+    private readonly byokClients;
     private unavailableUntil;
     constructor(config: MuxoConfig);
+    private resolveClient;
     private withTimeout;
-    isEnabled(): boolean;
+    isEnabled(apiKeyOverride?: string | null): boolean;
     /**
      * Derives a strict Supermemory v5 namespace (`^[a-zA-Z0-9_:-]+$`) scoped to a workspace.
      */
@@ -24,15 +26,17 @@ export declare class SupermemoryAdapter {
     sanitizeContent(raw: string): string;
     /**
      * Fetches the workspace's static + dynamic profile and optionally semantic search results
-     * in a single fail-open call.
+     * in a single fail-open call. Supports customer BYOK `supermemory` keys via `apiKeyOverride`.
      */
     getContextForWorkspace(workspaceIdOrParams: string | {
         workspaceId: string;
         query?: string;
         limit?: number;
-    }, optionalQuery?: string): Promise<MemoryContextSummary>;
+        apiKeyOverride?: string | null;
+    }, optionalQuery?: string, optionalApiKeyOverride?: string | null): Promise<MemoryContextSummary>;
     /**
-     * Stores a governed, secret-sanitized document/memory in the workspace's Supermemory v5 namespace.
+     * Stores a governed, secret-sanitized document/memory in the workspace's Supermemory v5 namespace
+     * with `dreaming: "instant"` so profile facts are synthesized immediately.
      */
     addMemory(params: {
         workspaceId: string;
@@ -41,11 +45,14 @@ export declare class SupermemoryAdapter {
         content: string;
         kind: MemoryRecordKind;
         metadata?: Record<string, unknown>;
+        apiKeyOverride?: string | null;
+        dreaming?: "auto" | "instant";
     }): Promise<{
         documentId: string;
         namespace: string;
         status: string;
         sanitizedContent: string;
+        fundingSource: "muxo_funded" | "customer_byok_supermemory" | "local_fallback";
     }>;
     recordExecutionMemory(params: {
         workspaceId: string;
@@ -55,12 +62,26 @@ export declare class SupermemoryAdapter {
         reason: string;
         status: string;
         summary: string;
+        apiKeyOverride?: string | null;
     }): Promise<string | null>;
     /**
      * Deletes/forgets a memory document from the workspace's Supermemory v5 namespace.
      */
-    deleteMemory(workspaceId: string, documentId: string): Promise<{
+    deleteMemory(workspaceId: string, documentId: string, apiKeyOverride?: string | null): Promise<{
         deleted: boolean;
         namespace: string;
     }>;
+    /**
+     * Semantically searches and forgets/prunes outdated memories in Supermemory v5 matching a query.
+     */
+    forgetMatching(params: {
+        workspaceId: string;
+        query: string;
+        limit?: number;
+        apiKeyOverride?: string | null;
+    }): Promise<{
+        namespace: string;
+        deletedRemoteIds: string[];
+        fundingSource: "muxo_funded" | "customer_byok_supermemory" | "local_fallback";
+    }>;
 }

package/dist/providers/supermemory.js

@@ -1,5 +1,22 @@
 import crypto from "node:crypto";
 import Supermemory from "supermemory";
+// Profile buckets can hold plain strings or memory objects depending on API version.
+function toFactTexts(items) {
+    if (!Array.isArray(items))
+        return [];
+    return items
+        .map((item) => {
+        if (item == null)
+            return "";
+        if (typeof item !== "object")
+            return String(item);
+        const o = item;
+        const text = o.memory ?? o.content ?? o.text ?? o.fact ?? o.value ?? o.summary ?? o.title;
+        return typeof text === "string" ? text : JSON.stringify(item);
+    })
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
 /**
  * Supermemory v5 Contextual Brain & Context-Aware Tool Call Adapter.
  * Uses deterministic per-workspace namespaces (`/ns/muxo-v5-<hash>/...`)
@@ -8,6 +25,7 @@ import Supermemory from "supermemory";
 export class SupermemoryAdapter {
     config;
     client;
+    byokClients = new Map();
     unavailableUntil = 0;
     constructor(config) {
         this.config = config;
@@ -16,19 +34,48 @@ export class SupermemoryAdapter {
                 apiKey: config.supermemoryApiKey,
                 baseUrl: config.supermemoryBaseUrl,
                 maxRetries: 0,
+                timeoutInSeconds: 2,
             });
         }
         else {
             this.client = null;
         }
     }
-    withTimeout(p, ms = 1000) {
+    resolveClient(apiKeyOverride) {
+        const trimmedByok = String(apiKeyOverride || "").trim();
+        if (trimmedByok) {
+            let byokClient = this.byokClients.get(trimmedByok);
+            if (!byokClient) {
+                byokClient = new Supermemory({
+                    apiKey: trimmedByok,
+                    baseUrl: this.config.supermemoryBaseUrl,
+                    maxRetries: 0,
+                    timeoutInSeconds: 2,
+                });
+                this.byokClients.set(trimmedByok, byokClient);
+            }
+            return {
+                client: byokClient,
+                fundingSource: "customer_byok_supermemory",
+            };
+        }
+        if (this.client) {
+            return {
+                client: this.client,
+                fundingSource: "muxo_funded",
+            };
+        }
+        return {
+            client: null,
+            fundingSource: "local_fallback",
+        };
+    }
+    withTimeout(fn, ms = 1000) {
         if (Date.now() < this.unavailableUntil) {
-            p.catch(() => { });
             return Promise.resolve(null);
         }
         return Promise.race([
-            p,
+            fn(),
             new Promise((resolve) => {
                 const t = setTimeout(() => {
                     this.unavailableUntil = Date.now() + 30_000;
@@ -41,8 +88,8 @@ export class SupermemoryAdapter {
             return null;
         });
     }
-    isEnabled() {
-        return Boolean(this.client);
+    isEnabled(apiKeyOverride) {
+        return Boolean(this.resolveClient(apiKeyOverride).client);
     }
     /**
      * Derives a strict Supermemory v5 namespace (`^[a-zA-Z0-9_:-]+$`) scoped to a workspace.
@@ -70,21 +117,29 @@ export class SupermemoryAdapter {
     }
     /**
      * Fetches the workspace's static + dynamic profile and optionally semantic search results
-     * in a single fail-open call.
+     * in a single fail-open call. Supports customer BYOK `supermemory` keys via `apiKeyOverride`.
      */
-    async getContextForWorkspace(workspaceIdOrParams, optionalQuery) {
+    async getContextForWorkspace(workspaceIdOrParams, optionalQuery, optionalApiKeyOverride) {
         const params = typeof workspaceIdOrParams === "string"
-            ? { workspaceId: workspaceIdOrParams, query: optionalQuery, limit: 5 }
+            ? {
+                workspaceId: workspaceIdOrParams,
+                query: optionalQuery,
+                limit: 5,
+                apiKeyOverride: optionalApiKeyOverride,
+            }
             : workspaceIdOrParams;
         const namespace = this.namespaceForWorkspace(params.workspaceId);
-        if (!this.client) {
+        const { client, fundingSource } = this.resolveClient(params.apiKeyOverride);
+        if (!client) {
             return {
                 enabled: false,
                 namespace,
+                fundingSource,
                 staticFacts: [],
                 dynamicContext: [],
                 recalledMemories: [],
                 formattedPromptContext: "Supermemory v5 disabled (no API key configured).",
+                profileMarkdown: "",
                 profile: { static: [], dynamic: [], preferences: [] },
                 relevantMemories: [],
             };
@@ -95,11 +150,11 @@ export class SupermemoryAdapter {
         let preferences = [];
         const relevantMemories = [];
         const [profileOutcome, searchOutcome] = await Promise.allSettled([
-            this.withTimeout(this.client.profile(namespace, {
+            this.withTimeout(() => client.profile(namespace, {
                 ...(params.query ? { q: params.query } : {}),
             }), 1000),
             params.query && params.query.trim().length > 0
-                ? this.withTimeout(this.client.search(namespace, {
+                ? this.withTimeout(() => client.search(namespace, {
                     query: params.query.trim(),
                     limit,
                     searchMode: "hybrid",
@@ -110,15 +165,9 @@ export class SupermemoryAdapter {
         ]);
         if (profileOutcome.status === "fulfilled" && profileOutcome.value) {
             const profileRes = profileOutcome.value;
-            staticFacts = Array.isArray(profileRes?.profile?.static)
-                ? profileRes.profile.static.map(String)
-                : [];
-            dynamicFacts = Array.isArray(profileRes?.profile?.dynamic)
-                ? profileRes.profile.dynamic.map(String)
-                : [];
-            preferences = Array.isArray(profileRes?.profile?.buckets?.preferences)
-                ? profileRes.profile.buckets.preferences.map(String)
-                : [];
+            staticFacts = toFactTexts(profileRes?.profile?.static);
+            dynamicFacts = toFactTexts(profileRes?.profile?.dynamic);
+            preferences = toFactTexts(profileRes?.profile?.buckets?.preferences);
         }
         if (searchOutcome.status === "fulfilled" && searchOutcome.value) {
             const searchRes = searchOutcome.value;
@@ -150,13 +199,25 @@ export class SupermemoryAdapter {
         if (relevantMemories.length > 0) {
             promptLines.push(`Recalled Memories: ${relevantMemories.map((m) => `${m.title}: ${m.snippet}`).join(" | ")}`);
         }
+        const mdLines = [`## Workspace Profile (${namespace})`];
+        if (staticFacts.length > 0) {
+            mdLines.push("### Static Facts", ...staticFacts.map((f) => `- ${f}`));
+        }
+        if (dynamicFacts.length > 0) {
+            mdLines.push("### Dynamic Context", ...dynamicFacts.map((f) => `- ${f}`));
+        }
+        if (preferences.length > 0) {
+            mdLines.push("### Preferences", ...preferences.map((f) => `- ${f}`));
+        }
         return {
             enabled: true,
             namespace,
+            fundingSource,
             staticFacts,
             dynamicContext: dynamicFacts,
             recalledMemories: relevantMemories,
             formattedPromptContext: promptLines.join("\n"),
+            profileMarkdown: mdLines.join("\n"),
             profile: {
                 static: staticFacts,
                 dynamic: dynamicFacts,
@@ -166,24 +227,28 @@ export class SupermemoryAdapter {
         };
     }
     /**
-     * Stores a governed, secret-sanitized document/memory in the workspace's Supermemory v5 namespace.
+     * Stores a governed, secret-sanitized document/memory in the workspace's Supermemory v5 namespace
+     * with `dreaming: "instant"` so profile facts are synthesized immediately.
      */
     async addMemory(params) {
         const namespace = this.namespaceForWorkspace(params.workspaceId);
         const sanitizedContent = this.sanitizeContent(params.content);
         const docId = params.documentId || `mem_${crypto.randomBytes(8).toString("hex")}`;
-        if (!this.client) {
+        const { client, fundingSource } = this.resolveClient(params.apiKeyOverride);
+        if (!client) {
             return {
                 documentId: docId,
                 namespace,
                 status: "local_only",
                 sanitizedContent,
+                fundingSource,
             };
         }
-        const res = await this.withTimeout(this.client.add(namespace, {
+        const res = await this.withTimeout(() => client.add(namespace, {
             id: docId,
             content: `${params.title}\n\n${sanitizedContent}`,
             taskType: "memory",
+            dreaming: params.dreaming || "instant",
             metadata: {
                 title: params.title,
                 muxoWorkspaceId: params.workspaceId,
@@ -196,6 +261,7 @@ export class SupermemoryAdapter {
             namespace,
             status: String(res?.status || "queued"),
             sanitizedContent,
+            fundingSource,
         };
     }
     async recordExecutionMemory(params) {
@@ -205,6 +271,7 @@ export class SupermemoryAdapter {
                 title: `Execution: ${params.toolSlug} (${params.status})`,
                 content: params.summary,
                 kind: "execution_outcome",
+                apiKeyOverride: params.apiKeyOverride,
                 metadata: {
                     toolSlug: params.toolSlug,
                     lane: params.lane,
@@ -221,13 +288,14 @@ export class SupermemoryAdapter {
     /**
      * Deletes/forgets a memory document from the workspace's Supermemory v5 namespace.
      */
-    async deleteMemory(workspaceId, documentId) {
+    async deleteMemory(workspaceId, documentId, apiKeyOverride) {
         const namespace = this.namespaceForWorkspace(workspaceId);
-        if (!this.client) {
+        const { client } = this.resolveClient(apiKeyOverride);
+        if (!client) {
             return { deleted: true, namespace };
         }
         try {
-            const res = await this.withTimeout(this.client.documents.delete(namespace, {
+            const res = await this.withTimeout(() => client.documents.delete(namespace, {
                 ids: [documentId],
             }), 1200);
             return {
@@ -239,4 +307,46 @@ export class SupermemoryAdapter {
             return { deleted: false, namespace };
         }
     }
+    /**
+     * Semantically searches and forgets/prunes outdated memories in Supermemory v5 matching a query.
+     */
+    async forgetMatching(params) {
+        const namespace = this.namespaceForWorkspace(params.workspaceId);
+        const { client, fundingSource } = this.resolveClient(params.apiKeyOverride);
+        if (!client || !params.query.trim()) {
+            return {
+                namespace,
+                deletedRemoteIds: [],
+                fundingSource,
+            };
+        }
+        try {
+            const searchRes = await this.withTimeout(() => client.search(namespace, {
+                query: params.query.trim(),
+                limit: Math.min(10, Math.max(1, Number(params.limit || 5))),
+                searchMode: "hybrid",
+                include: { documents: true, forgotten: false, related: false },
+                rewriteQuery: false,
+            }), 1200);
+            const docIds = Array.from(new Set((searchRes?.results || [])
+                .map((r) => String(r.included?.document?.id || r.id || ""))
+                .filter(Boolean)));
+            if (docIds.length > 0) {
+                await this.withTimeout(() => client.documents.delete(namespace, { ids: docIds }), 1200);
+                return {
+                    namespace,
+                    deletedRemoteIds: docIds,
+                    fundingSource,
+                };
+            }
+        }
+        catch {
+            // Fail-open on remote pruning errors
+        }
+        return {
+            namespace,
+            deletedRemoteIds: [],
+            fundingSource,
+        };
+    }
 }