@muxoai/platform 1.4.0 → 1.4.1

package/dist/provisioning-managed.js

@@ -0,0 +1,155 @@
+/**
+ * Muxo-managed stand-ins for Stripe v2 Provisioning objects, returned when no Stripe key is
+ * configured so both the Node server and the edge worker answer with the same shapes.
+ */
+function managedId(prefix) {
+    const bytes = new Uint8Array(8);
+    crypto.getRandomValues(bytes);
+    return `${prefix}_muxo_${Array.from(bytes)
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("")}`;
+}
+export function managedProviderConnectionList() {
+    return {
+        object: "v2.list",
+        data: [],
+        next_page_url: null,
+        previous_page_url: null,
+        source: "muxo_managed",
+    };
+}
+export function managedProviderConnectionUnlink(id) {
+    return {
+        id,
+        object: "v2.provisioning.provider_connection",
+        provider: null,
+        status: "unlinked",
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+export function managedProviderConnectionRequest(params) {
+    return {
+        id: params.id || managedId("pcr"),
+        object: "v2.provisioning.provider_connection_request",
+        provider: params.provider || null,
+        request_status: params.requestStatus || "requested",
+        redirect_url: null,
+        needs_information_schema: null,
+        provider_connection: null,
+        created: new Date().toISOString(),
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+export function managedResource(params) {
+    return {
+        id: params.id || managedId("res"),
+        object: "v2.provisioning.resource",
+        provider: params.provider || null,
+        service_ref: params.serviceRef || null,
+        name: params.name ?? null,
+        environment: params.environment === "dev" ? "dev" : "prod",
+        catalog: params.catalog || "prod",
+        status: params.status || "pending",
+        pending_action: null,
+        created: new Date().toISOString(),
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+const ACTION_STATUS = {
+    remove: "removed",
+    unlink: "unlinked",
+    rotate_credentials: "active",
+    submit_information: "provisioning",
+};
+export function managedResourceAction(id, action) {
+    return {
+        ...managedResource({ id, status: ACTION_STATUS[action] }),
+        action,
+        ...(action === "rotate_credentials" ? { credentials_rotated_at: new Date().toISOString() } : {}),
+    };
+}
+function hexOf(text, length) {
+    return Array.from(new TextEncoder().encode(text))
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("")
+        .slice(0, length);
+}
+export function managedConnectedAccount(params) {
+    return {
+        id: params.id || `acct_v2_${hexOf(`${params.contactEmail || ""}:${params.displayName || ""}`, 12)}`,
+        object: "v2.core.account",
+        ...(params.contactEmail ? { contact_email: params.contactEmail } : {}),
+        display_name: params.displayName || "Muxo Tenant Account",
+        identity: { country: params.country || "US", entity_type: params.entityType || "company" },
+        configuration: { developer: { capabilities: { projects: { requested: true, status: "active" } } } },
+        requirements: { currently_due: [], eventually_due: [], past_due: [], entries: [] },
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+export function managedConnectedAccountLink(account) {
+    return {
+        object: "v2.core.account_link",
+        account,
+        url: `https://connect.stripe.com/setup/e/${encodeURIComponent(account)}/onboarding`,
+        created: new Date().toISOString(),
+        expires_at: new Date(Date.now() + 3600_000).toISOString(),
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+export function managedConnectedAccountSession(params) {
+    return {
+        object: "account_session",
+        account: params.account,
+        client_secret: `accs_secret_muxo_${hexOf(params.account, 16)}`,
+        components: {
+            account_onboarding: { enabled: true },
+            ...(params.enableAccountManagement ? { account_management: { enabled: true } } : {}),
+            ...(params.enableNotificationBanner !== false ? { notification_banner: { enabled: true } } : {}),
+        },
+        expires_at: Math.floor(Date.now() / 1000) + 3600,
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+export function managedPaymentMethodRequest(params) {
+    return {
+        object: "v2.provisioning.payment_method_request",
+        checkout_session_url: `${params.publicWebUrl}/?checkout=payment_method_request`,
+        status: "checkout_initiated",
+        livemode: params.livemode,
+        source: "muxo_managed",
+    };
+}
+export const DEFAULT_PROVISIONING_EVENT_TYPES = [
+    "v2.provisioning.resource.completed",
+    "v2.provisioning.resource.errored",
+    "v2.core.account[requirements].updated",
+];
+export function managedEventDestination(params) {
+    return {
+        id: `ed_v2_${hexOf(params.url, 12)}`,
+        object: "v2.core.event_destination",
+        name: params.name || "Muxo Provisioning & Connect v2 Event Stream",
+        status: "enabled",
+        enabled_events: params.events?.length ? params.events : DEFAULT_PROVISIONING_EVENT_TYPES,
+        webhook_endpoint: { url: params.url },
+        livemode: false,
+        source: "muxo_managed",
+    };
+}
+/** What Muxo does with a Stripe v2 thin event, keyed by event type. */
+export function provisioningEventAction(eventType, hasRelatedObject) {
+    if (eventType === "v2.provisioning.resource.completed" && hasRelatedObject) {
+        return "revealed_access_configuration_and_synced_vault";
+    }
+    if (eventType === "v2.provisioning.resource.errored")
+        return "marked_resource_errored";
+    if (eventType === "v2.core.account[requirements].updated")
+        return "flagged_connected_account_requirements_due";
+    return "recorded_v2_event";
+}

package/dist/sdk.d.ts

@@ -1,4 +1,4 @@
-import type { ActionPlan, ByokKeyRecord, ConnectionRecord, ExecutionReceipt, ExecutionRun, GovernancePolicy, MuxoTool, ProviderLane, ProvisionedResource, RiskLevel, SupplierSettlementSummary, TemporalGraphFact, Workspace, WorkspaceMemoryRecord } from "./types.js";
+import type { ActionPlan, ByokKeyRecord, ConnectionRecord, ExecutionReceipt, ExecutionRun, GovernancePolicy, HumanFriendlyExplanation, HumanHandoff, LlmGuidance, MemoryKnowledgeGraph, MuxoTool, ProviderLane, ProvisionedResource, RiskLevel, SupplierSettlementSummary, TeamOnboardingKit, TemporalGraphFact, Workspace, WorkspaceMemoryRecord, WorkspaceRole, WorkspaceSummary } from "./types.js";
 export interface MuxoTrustScore {
     overall: number;
     tier: string;
@@ -115,6 +115,7 @@ export declare class MuxoClient {
         user: Record<string, unknown>;
         workspace: Workspace;
         apiKey: string;
+        sessionToken: string;
         token: string;
     }>;
     static login(params: {
@@ -125,6 +126,7 @@ export declare class MuxoClient {
         user: Record<string, unknown>;
         workspace: Workspace;
         apiKey: string;
+        sessionToken: string;
         token: string;
     }>;
     register(params: {
@@ -137,6 +139,7 @@ export declare class MuxoClient {
         user: Record<string, unknown>;
         workspace: Workspace;
         apiKey: string;
+        sessionToken: string;
         token: string;
     }>;
     login(params: {
@@ -147,6 +150,7 @@ export declare class MuxoClient {
         user: Record<string, unknown>;
         workspace: Workspace;
         apiKey: string;
+        sessionToken: string;
         token: string;
     }>;
     signupAgent(params: {
@@ -200,12 +204,31 @@ export declare class MuxoClient {
             waitTool: string;
             instructions: string;
         };
+        humanHandoff?: HumanHandoff;
+        llmGuidance?: LlmGuidance;
     }>;
-    getPlan(planId: string): Promise<{
+    getPlan(planId: string, options?: {
+        waitForApproval?: boolean;
+        timeoutSeconds?: number;
+    }): Promise<{
         ok: true;
         plan: ActionPlan;
+        approved?: boolean;
+        rejected?: boolean;
+        timedOut?: boolean;
+        humanHandoff?: HumanHandoff;
+        llmGuidance?: LlmGuidance;
     }>;
-    approvePlan(planId: string): Promise<{
+    waitForPlanApproval(planId: string, timeoutSeconds?: number): Promise<{
+        ok: true;
+        plan: ActionPlan;
+        approved: boolean;
+        rejected: boolean;
+        timedOut: boolean;
+        humanHandoff?: HumanHandoff;
+        llmGuidance?: LlmGuidance;
+    }>;
+    approvePlan(planId: string, decision?: "approved" | "rejected"): Promise<{
         ok: true;
         plan: ActionPlan;
     }>;
@@ -239,7 +262,28 @@ export declare class MuxoClient {
         valid: boolean;
         verified: boolean;
         receipt: ExecutionReceipt;
+        agenticReceiptValid?: boolean;
+        explanation?: HumanFriendlyExplanation;
     }>;
+    verifyReceiptChain(limit?: number): Promise<{
+        ok: boolean;
+        valid: boolean;
+        workspaceId: string;
+        totalChecked: number;
+        validCount: number;
+        brokenLinks: Array<{
+            receiptId: string;
+            runId: string;
+            reason: string;
+        }>;
+        headReceiptHash: string;
+        agentDid: string;
+        publicKeyHex: string;
+        explanation: HumanFriendlyExplanation;
+    }>;
+    getMemoryGraph(query?: string): Promise<{
+        ok: true;
+    } & MemoryKnowledgeGraph>;
     startConnection(paramsOrProvider: string | {
         provider: string;
         lane?: ProviderLane;
@@ -375,6 +419,64 @@ export declare class MuxoClient {
             auditChain?: Record<string, unknown>;
         };
         workspacePolicy: GovernancePolicy;
+        plainEnglishGuardrails?: {
+            headline: string;
+            postureLabel: string;
+            rules: string[];
+            badges: Array<{
+                label: string;
+                tone: "safe" | "warn" | "strict";
+            }>;
+        };
+        activeMemoryDefaults?: Record<string, unknown>;
+        activeGuardrails?: string[];
+    }>;
+    getGuardrails(): Promise<{
+        ok: true;
+        workspaceId: string;
+        policy: GovernancePolicy;
+        plainEnglish: {
+            headline: string;
+            postureLabel: string;
+            rules: string[];
+            badges: Array<{
+                label: string;
+                tone: "safe" | "warn" | "strict";
+            }>;
+        };
+        activeDefaults: Record<string, unknown>;
+        activeGuardrails: string[];
+    }>;
+    setGuardrail(promptOrParams: string | {
+        prompt: string;
+    }): Promise<{
+        ok: true;
+        workspace: Workspace;
+        guardrail: Record<string, unknown>;
+        plainEnglish: {
+            headline: string;
+            postureLabel: string;
+            rules: string[];
+            badges: Array<{
+                label: string;
+                tone: "safe" | "warn" | "strict";
+            }>;
+        };
+        humanMessage: string;
+    }>;
+    resetGuardrails(): Promise<{
+        ok: true;
+        workspace: Workspace;
+        plainEnglish: {
+            headline: string;
+            postureLabel: string;
+            rules: string[];
+            badges: Array<{
+                label: string;
+                tone: "safe" | "warn" | "strict";
+            }>;
+        };
+        humanMessage: string;
     }>;
     setKillSwitch(action: "quarantine" | "terminate" | "suspend" | "resume", reason?: string): Promise<{
         ok: true;
@@ -407,6 +509,45 @@ export declare class MuxoClient {
         ok: true;
         workspace: Workspace;
     }>;
+    getPolicy(): Promise<{
+        ok: true;
+        policy: GovernancePolicy;
+        plainEnglish: Record<string, unknown>;
+        explanation?: HumanFriendlyExplanation;
+        activeDefaults: Record<string, unknown>;
+        activeGuardrails: string[];
+    }>;
+    getContext(query?: string): Promise<{
+        ok: true;
+        workspaceId: string;
+        workspaceSlug: string;
+        policy: GovernancePolicy;
+        plainEnglishPolicy?: Record<string, unknown>;
+        languageMode?: string;
+        customInstructions?: string[];
+        activeDefaults?: Record<string, unknown>;
+        activeGuardrails?: string[];
+        creditsBalance: number;
+        llmSystemPrompt?: string;
+        explanation?: HumanFriendlyExplanation;
+        supermemoryBrain?: Record<string, unknown>;
+        [key: string]: unknown;
+    }>;
+    listReceipts(limit?: number): Promise<{
+        ok: true;
+        receipts: Array<ExecutionReceipt & {
+            explanation?: HumanFriendlyExplanation;
+        }>;
+        total: number;
+        explanation?: HumanFriendlyExplanation;
+    }>;
+    remember(instruction: string): Promise<{
+        ok: true;
+        memory: WorkspaceMemoryRecord;
+        activeDefaults?: Record<string, unknown>;
+        explanation?: HumanFriendlyExplanation;
+        humanMessage?: string;
+    }>;
     do(prompt: string, options?: {
         input?: Record<string, unknown>;
         autoApprove?: boolean;
@@ -511,4 +652,300 @@ export declare class MuxoClient {
         workspace: Workspace | null;
         kind: string;
     }>;
+    createProvisioningConnectedAccount(params?: {
+        contact_email?: string;
+        display_name?: string;
+        country?: string;
+        entity_type?: "individual" | "company";
+    }): Promise<{
+        ok: true;
+        apiVersion: string;
+        id: string;
+        object: "v2.core.account";
+        contact_email?: string;
+        display_name?: string;
+        configuration?: Record<string, unknown>;
+        requirements?: Record<string, unknown>;
+        livemode?: boolean;
+    }>;
+    getProvisioningConnectedAccount(accountId?: string): Promise<any>;
+    createProvisioningConnectedAccountLink(params?: {
+        account?: string;
+        type?: "account_onboarding" | "account_update";
+        fields?: "currently_due" | "eventually_due";
+        future_requirements?: "include" | "omit";
+        refresh_url?: string;
+        return_url?: string;
+        auto_create?: boolean;
+    }): Promise<{
+        ok: true;
+        apiVersion: string;
+        object: "v2.core.account_link";
+        account: string;
+        url: string;
+        expires_at?: string;
+        livemode?: boolean;
+    }>;
+    createProvisioningConnectedAccountSession(params?: {
+        account?: string;
+        enable_account_management?: boolean;
+        disable_stripe_user_authentication?: boolean;
+        external_account_collection?: boolean;
+        fields?: "currently_due" | "eventually_due";
+        future_requirements?: "include" | "omit";
+        auto_create?: boolean;
+    }): Promise<{
+        ok: true;
+        apiVersion: string;
+        object: "account_session";
+        account: string;
+        client_secret: string;
+        publishable_key: string | null;
+        embedded_component: "account-onboarding";
+        collection_options: {
+            fields: "currently_due" | "eventually_due";
+            future_requirements: "include" | "omit";
+        };
+        components: Record<string, unknown>;
+        expires_at: number;
+        livemode: boolean;
+    }>;
+    checkProvisioningEligibility(): Promise<{
+        ok: true;
+        apiVersion: string;
+        object: "v2.provisioning.eligibility";
+        is_eligible: boolean;
+        livemode: boolean;
+        requirements: string[];
+        ready?: boolean;
+        platform_action?: string;
+        source: string;
+    }>;
+    listProvisioningProviders(params?: {
+        catalog?: "dev" | "prod" | "testing";
+        limit?: number;
+        page?: string;
+    }): Promise<{
+        ok: true;
+        apiVersion: string;
+        object: "v2.list";
+        data: Array<Record<string, unknown>>;
+        next_page_url: string | null;
+        previous_page_url: string | null;
+        source: string;
+    }>;
+    listProvisioningServices(params?: {
+        catalog?: "dev" | "prod" | "testing";
+        provider_name?: string;
+        provider_id?: string;
+        limit?: number;
+        page?: string;
+    }): Promise<{
+        ok: true;
+        apiVersion: string;
+        object: "v2.list";
+        data: Array<Record<string, unknown>>;
+        next_page_url: string | null;
+        previous_page_url: string | null;
+        source: string;
+    }>;
+    getProvisioningPaymentProfile(params?: {
+        provider?: string;
+        livemode?: boolean;
+    }): Promise<{
+        ok: true;
+        apiVersion: string;
+        object: "v2.provisioning.payment_profile";
+        card_last4: string | null;
+        usage_limits: Record<string, unknown> | null;
+        providers: Array<Record<string, unknown>>;
+        payment_method_owner: string | null;
+        livemode: boolean;
+        has_payment_method?: boolean;
+        source: string;
+    }>;
+    createProvisioningPaymentMethodRequest(params?: {
+        usage_limits?: Record<string, unknown>;
+        livemode?: boolean;
+    }): Promise<Record<string, unknown>>;
+    listProvisioningProviderConnections(params?: {
+        provider?: string;
+        limit?: number;
+        page?: string;
+    }): Promise<{
+        ok: true;
+        apiVersion: string;
+        object: "list";
+        data: Array<Record<string, unknown>>;
+        has_more?: boolean;
+    }>;
+    createProvisioningProviderConnectionRequest(params: {
+        provider: string;
+        configuration?: Record<string, string>;
+        project?: string;
+    }): Promise<Record<string, unknown>>;
+    listProvisioningProjects(params?: {
+        limit?: number;
+        page?: string;
+    }): Promise<{
+        ok: true;
+        apiVersion: string;
+        object: "list";
+        data: Array<Record<string, unknown>>;
+        has_more?: boolean;
+    }>;
+    createProvisioningProject(params: {
+        name: string;
+        catalog?: "dev" | "prod" | "testing";
+        project_profile?: string;
+    }): Promise<Record<string, unknown>>;
+    listProvisioningResources(params?: {
+        project?: string;
+        provider?: string;
+        limit?: number;
+        page?: string;
+    }): Promise<{
+        ok: true;
+        apiVersion: string;
+        object: "list";
+        data: Array<Record<string, unknown>>;
+        has_more?: boolean;
+    }>;
+    createProvisioningResource(params: {
+        provider: string;
+        service_ref: string;
+        configuration?: Record<string, unknown>;
+        name?: string;
+        project?: string;
+        environment?: "dev" | "prod";
+        catalog?: "dev" | "prod" | "testing";
+        livemode?: boolean;
+    }): Promise<Record<string, unknown>>;
+    revealResourceAccessConfiguration(resourceId: string): Promise<{
+        ok: true;
+        apiVersion: string;
+        object: string;
+        resource: string;
+        configuration: Record<string, string>;
+        created: string;
+        expires_at?: string | null;
+        livemode: boolean;
+        source: string;
+    }>;
+    getResourceSecrets(resourceId: string): Promise<{
+        ok: true;
+        resourceId: string;
+        resourceName: string;
+        workspaceId: string;
+        envVarKeys: string[];
+        secrets: Record<string, string>;
+    }>;
+    listWorkspaces(): Promise<{
+        ok: true;
+        currentWorkspaceId: string;
+        workspaces: WorkspaceSummary[];
+    }>;
+    createWorkspace(params: {
+        name: string;
+        teamName?: string;
+        environment?: "live" | "test";
+    }): Promise<{
+        ok: true;
+        workspace: Workspace;
+        apiKey: string;
+        workspaces: WorkspaceSummary[];
+    }>;
+    switchWorkspace(workspaceId: string): Promise<{
+        ok: true;
+        workspace: Workspace;
+        workspaces: WorkspaceSummary[];
+    }>;
+    joinWorkspaceWithApiKey(apiKey: string): Promise<{
+        ok: true;
+        mode: "api_key_join";
+        workspace: Workspace;
+        apiKey: string;
+        sessionToken: string | null;
+        keyRecord: {
+            id: string;
+            name: string;
+            keyPrefix: string;
+            teamName: string | null;
+            role: WorkspaceRole;
+            environment: "live" | "test";
+        };
+        workspaces: WorkspaceSummary[];
+        message: string;
+    }>;
+    onboardTeam(params: {
+        teamName: string;
+        role?: WorkspaceRole;
+        mode?: "shared_workspace" | "dedicated_workspace";
+        environment?: "live" | "test";
+        scopes?: string[];
+    }): Promise<{
+        ok: true;
+        kit: TeamOnboardingKit;
+        workspace: Workspace;
+        apiKey: string;
+        workspaces: WorkspaceSummary[];
+    }>;
+    updateProvisioningSpendLimit(params: {
+        max_amount: string | number;
+        currency?: string;
+        recurring_interval?: string;
+        provider?: string;
+    }): Promise<Record<string, unknown>>;
+    createProvisioningEventDestination(params: {
+        name?: string;
+        url: string;
+        events?: string[];
+    }): Promise<Record<string, unknown>>;
+    recordBillingMeterEvent(params: {
+        event_name?: string;
+        value: number;
+        lane?: string;
+        tool_slug?: string;
+        identifier?: string;
+    }): Promise<Record<string, unknown>>;
+    listBillingMeterEvents(limit?: number): Promise<Record<string, unknown>>;
+    listToolkits(params?: {
+        category?: string;
+        search?: string;
+    }): Promise<Record<string, unknown>>;
+    createCustomAuthConfig(params: {
+        toolkitSlug: string;
+        authScheme: "OAUTH2" | "API_KEY";
+        scopeMode?: "read_only" | "full_access";
+        customScopes?: string[];
+        credentials?: Record<string, string>;
+    }): Promise<Record<string, unknown>>;
+    listTriggers(provider?: string): Promise<Record<string, unknown>>;
+    enableTrigger(params: {
+        triggerSlug: string;
+        providerSlug: string;
+        webhookUrl?: string;
+        config?: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+    ingestTriggerWebhook(params: {
+        triggerSlug: string;
+        providerSlug?: string;
+        payload: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+    executeBatchPlans(params: {
+        items: Array<{
+            toolSlug: string;
+            input: Record<string, unknown>;
+            reason: string;
+        }>;
+        autoApprove?: boolean;
+    }): Promise<Record<string, unknown>>;
+    searchMemoryHybrid(query: string, limit?: number): Promise<Record<string, unknown>>;
+    startDurableWorkflow(params: {
+        provider?: string;
+        serviceRef?: string;
+        region?: string;
+    }): Promise<Record<string, unknown>>;
+    advanceDurableWorkflow(workflowId: string, eventPayload?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    exportGovernanceArchive(): Promise<Record<string, unknown>>;
 }