@muxoai/platform 1.3.0 → 1.3.2

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,21 +25,71 @@ import Supermemory from "supermemory";
 export class SupermemoryAdapter {
     config;
     client;
+    byokClients = new Map();
+    unavailableUntil = 0;
     constructor(config) {
         this.config = config;
         if (config.supermemoryApiKey) {
             this.client = new Supermemory({
                 apiKey: config.supermemoryApiKey,
                 baseUrl: config.supermemoryBaseUrl,
-                maxRetries: 1,
+                maxRetries: 0,
+                timeoutInSeconds: 2,
             });
         }
         else {
             this.client = null;
         }
     }
-    isEnabled() {
-        return Boolean(this.client);
+    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) {
+            return Promise.resolve(null);
+        }
+        return Promise.race([
+            fn(),
+            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(apiKeyOverride) {
+        return Boolean(this.resolveClient(apiKeyOverride).client);
     }
     /**
      * Derives a strict Supermemory v5 namespace (`^[a-zA-Z0-9_:-]+$`) scoped to a workspace.
@@ -50,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: [],
             };
@@ -74,50 +149,42 @@ 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(() => client.profile(namespace, {
                 ...(params.query ? { q: params.query } : {}),
-            });
-            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)
-                : [];
-        }
-        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, {
+            }), 1000),
+            params.query && params.query.trim().length > 0
+                ? this.withTimeout(() => 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 = 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;
+            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 = [
@@ -132,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,
@@ -148,36 +227,41 @@ 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.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,
                 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,
+            fundingSource,
         };
     }
     async recordExecutionMemory(params) {
@@ -187,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,
@@ -194,7 +279,7 @@ export class SupermemoryAdapter {
                     status: params.status,
                 },
             });
-            return added.documentId;
+            return added ? added.documentId : null;
         }
         catch {
             return null;
@@ -203,15 +288,16 @@ 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.client.documents.delete(namespace, {
+            const res = await this.withTimeout(() => client.documents.delete(namespace, {
                 ids: [documentId],
-            });
+            }), 1200);
             return {
                 deleted: (res?.count || 0) >= 1,
                 namespace,
@@ -221,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,
+        };
+    }
 }

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;