@muxoai/sdk 1.3.0 → 1.4.3

package/dist/sdk.d.ts

@@ -1,10 +1,87 @@
-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, 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;
+    reliability?: number;
+    consistency?: number;
+}
 export interface MuxoClientOptions {
     baseUrl?: string;
     apiKey?: string | (() => string | Promise<string>);
     fetch?: typeof fetch;
     timeoutMs?: number;
 }
+/** Error thrown for any non-OK Muxo API response. Carries the machine-readable code and payload. */
+export declare class MuxoApiError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    readonly url?: string;
+    readonly checkoutUrl?: string;
+    readonly data: Record<string, unknown>;
+    constructor(status: number, payload: Record<string, unknown>);
+}
+export interface BillingPlanInfo {
+    tier: "free" | "starter" | "pro";
+    name: string;
+    tagline: string;
+    monthlyActions: number;
+    monthlyCredits: number;
+    prices: {
+        month: {
+            cents: number;
+            label: string;
+        };
+        year: {
+            cents: number;
+            label: string;
+            perMonthLabel: string;
+        };
+    };
+    features: string[];
+}
+export interface PlanCatalog {
+    plans: BillingPlanInfo[];
+    yearlyDiscount: string;
+    creditPriceCents: number;
+    creditPacks: Array<{
+        credits: number;
+        cents: number;
+        label: string;
+    }>;
+    minCheckoutCredits: number;
+}
+export type UpgradePlanResult = {
+    ok: true;
+    unchanged: true;
+    tier: string;
+    message: string;
+    workspace?: Workspace;
+} | {
+    ok: true;
+    mode: "portal";
+    action: "billing_portal";
+    tier: string;
+    interval: string;
+    portalUrl: string;
+    url: string;
+    nextStep: string;
+} | {
+    ok: false;
+    code: "payment_required";
+    paymentRequired: true;
+    checkoutUrl: string;
+    sessionId: string;
+    kind: string;
+    tier: string;
+    interval: string;
+    credits: number;
+    error: string;
+} | {
+    ok: false;
+    code: "human_required";
+    url: string;
+    error: string;
+};
 export declare class MuxoClient {
     readonly baseUrl: string;
     private readonly apiKeyResolver?;
@@ -28,6 +105,54 @@ 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;
+        sessionToken: string;
+        token: string;
+    }>;
+    static login(params: {
+        email: string;
+        password: string;
+    }, baseUrl?: string): Promise<{
+        ok: true;
+        user: Record<string, unknown>;
+        workspace: Workspace;
+        apiKey: string;
+        sessionToken: string;
+        token: string;
+    }>;
+    register(params: {
+        email: string;
+        password: string;
+        name?: string;
+        workspaceName?: string;
+    }): Promise<{
+        ok: true;
+        user: Record<string, unknown>;
+        workspace: Workspace;
+        apiKey: string;
+        sessionToken: string;
+        token: string;
+    }>;
+    login(params: {
+        email: string;
+        password: string;
+    }): Promise<{
+        ok: true;
+        user: Record<string, unknown>;
+        workspace: Workspace;
+        apiKey: string;
+        sessionToken: string;
+        token: string;
+    }>;
     signupAgent(params: {
         agentName?: string;
         harness?: string;
@@ -65,6 +190,7 @@ export declare class MuxoClient {
         toolSlug: string;
         input: Record<string, unknown>;
         reason?: string;
+        fundingMode?: "muxo_funded" | "byok";
     }): Promise<{
         ok: true;
         plan: ActionPlan;
@@ -78,8 +204,31 @@ export declare class MuxoClient {
             waitTool: string;
             instructions: string;
         };
+        humanHandoff?: HumanHandoff;
+        llmGuidance?: LlmGuidance;
+    }>;
+    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;
     }>;
@@ -88,9 +237,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;
@@ -103,7 +262,33 @@ 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(queryOrOptions?: string | {
+        query?: string;
+        asOf?: string;
+        focalEntity?: string;
+        maxHops?: number;
+    }): Promise<{
+        ok: true;
+    } & MemoryKnowledgeGraph>;
     startConnection(paramsOrProvider: string | {
         provider: string;
         lane?: ProviderLane;
@@ -152,6 +337,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 +363,202 @@ 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;
+        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;
+        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;
+    }>;
+    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;
         dryRun?: boolean;
+        planOnly?: boolean;
+        fundingMode?: "muxo_funded" | "byok";
     }): Promise<{
         ok: boolean;
         executed: boolean;
@@ -199,6 +580,8 @@ export declare class MuxoClient {
         input?: Record<string, unknown>;
         autoApprove?: boolean;
         dryRun?: boolean;
+        planOnly?: boolean;
+        fundingMode?: "muxo_funded" | "byok";
     }): Promise<{
         ok: boolean;
         executed: boolean;
@@ -232,17 +615,41 @@ export declare class MuxoClient {
         provider: string;
         keys: ByokKeyRecord[];
     }>;
-    upgradePlan(): Promise<{
+    /** Lists plans, prices, and credit packs. No auth required. */
+    getPlans(): Promise<{
         ok: true;
-        tier: string;
-        workspace: Workspace;
-        settlementSummary: SupplierSettlementSummary;
+    } & PlanCatalog>;
+    /**
+     * Moves the workspace to a plan. A first subscription returns a Stripe checkout URL
+     * (`payment_required`); changing an existing subscription returns a billing-portal URL.
+     * Plan changes are confirmed by a signed-in person; API keys get `human_required`.
+     */
+    upgradePlan(options?: {
+        tier?: "starter" | "pro";
+        interval?: "month" | "year";
+    }): Promise<UpgradePlanResult>;
+    /**
+     * Opens the Stripe billing portal to manage payment details, switch plans, or cancel.
+     * Signed-in people only; API keys get a `human_required` MuxoApiError.
+     */
+    openBillingPortal(): Promise<{
+        ok: true;
+        url: string;
+        portalUrl: string;
     }>;
-    createCheckoutSession(kind?: "starter_subscription" | "credit_topup"): Promise<{
+    createCheckoutSession(kind?: "subscription" | "starter_subscription" | "credit_topup", optionsOrCredits?: number | {
+        credits?: number;
+        tier?: "starter" | "pro";
+        interval?: "month" | "year";
+    }): Promise<{
         ok: true;
         sessionId: string;
         url: string;
         mode?: string;
+        kind?: string;
+        credits?: number;
+        tier?: string;
+        interval?: string;
     }>;
     verifyCheckoutSession(sessionId: string): Promise<{
         ok: true;
@@ -250,4 +657,318 @@ 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>>;
+    getWorkflowHistory(workflowId: string): Promise<Record<string, unknown>>;
+    signalDurableWorkflow(workflowId: string, signalName: string, payload?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    rollbackDurableWorkflow(workflowId: string, params?: {
+        reason?: string;
+        failedStep?: string;
+    }): Promise<Record<string, unknown>>;
+    getCedarPolicy(): Promise<Record<string, unknown>>;
+    evaluateCedarPolicy(params: {
+        toolSlug: string;
+        input?: Record<string, unknown>;
+        riskLevel?: RiskLevel;
+        creditCost?: number;
+        lane?: string;
+    }): Promise<Record<string, unknown>>;
+    getOtelTraces(limit?: number): Promise<Record<string, unknown>>;
+    listPlaybooks(): Promise<Record<string, unknown>>;
+    runPlaybook(slug: string, input?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getRoiAnalytics(): Promise<Record<string, unknown>>;
 }