@muxoai/sdk 1.2.3 → 1.4.2

package/dist/sdk.d.ts

@@ -0,0 +1,951 @@
+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?;
+    private readonly fetchImpl;
+    private readonly timeoutMs;
+    constructor(options?: MuxoClientOptions);
+    private request;
+    static signup(params?: {
+        workspaceName?: string;
+        ownerEmail?: string;
+        agentName?: string;
+        harness?: string;
+    }, baseUrl?: string): Promise<{
+        ok: true;
+        agentId: string;
+        workspace: Pick<Workspace, "id" | "name" | "slug" | "tier" | "creditsBalance">;
+        apiKey: string;
+        mcpEndpoint: string;
+        skillUrl: string;
+        claimEndpoint: string;
+        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;
+    }): Promise<{
+        ok: true;
+        agentId: string;
+        workspace: Pick<Workspace, "id" | "name" | "slug" | "tier" | "creditsBalance">;
+        apiKey: string;
+        mcpEndpoint: string;
+        skillUrl: string;
+        claimEndpoint: string;
+        governanceDid: string;
+        supermemoryNamespace: string;
+    }>;
+    whoami(): Promise<{
+        ok: true;
+        workspace: Workspace;
+        organization?: Workspace;
+        user?: Record<string, unknown>;
+        settlementSummary?: SupplierSettlementSummary;
+    }>;
+    mcpCall<T = Record<string, unknown>>(name: string, args?: Record<string, unknown>): Promise<T>;
+    searchTools(params?: {
+        query?: string;
+        lane?: ProviderLane | "all";
+        riskLevel?: RiskLevel;
+        limit?: number;
+    }): Promise<{
+        ok: true;
+        count: number;
+        tools: MuxoTool[];
+    }>;
+    inspectTool(slug: string): Promise<MuxoTool>;
+    planAction(params: {
+        toolSlug: string;
+        input: Record<string, unknown>;
+        reason?: string;
+        fundingMode?: "muxo_funded" | "byok";
+    }): Promise<{
+        ok: true;
+        plan: ActionPlan;
+        nextStep: string;
+        authHandoff?: {
+            required: boolean;
+            providerSlug: string;
+            providerName: string;
+            status: string;
+            redirectUrl: string | null;
+            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;
+    }>;
+    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;
+    }>;
+    executePlan(planId: string): Promise<{
+        ok: true;
+        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;
+        run: ExecutionRun;
+        receipt: ExecutionReceipt;
+        settlement?: Record<string, unknown> | null;
+    }>;
+    verifyReceipt(receiptId: string): Promise<{
+        ok: true;
+        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;
+        callbackUrl?: string;
+    }): Promise<{
+        ok: true;
+        connection: ConnectionRecord;
+    }>;
+    waitForConnection(paramsOrProvider: string | {
+        provider: string;
+        timeoutSeconds?: number;
+        simulateCallback?: boolean;
+    }, options?: {
+        timeoutSeconds?: number;
+        simulateCallback?: boolean;
+    }): Promise<{
+        ok: true;
+        connection: ConnectionRecord;
+        status: ConnectionRecord["status"];
+        ready: boolean;
+        polledAttempts: number;
+        elapsedMs: number;
+        message: string;
+    }>;
+    listResources(): Promise<{
+        ok: true;
+        resources: ProvisionedResource[];
+    }>;
+    pullEnv(): Promise<{
+        ok: true;
+        workspaceId: string;
+        variables: Record<string, string>;
+        dotenv: string;
+        includes: (substr: string) => boolean;
+    }>;
+    topupCredits(paramsOrCredits: number | {
+        credits: number;
+        description?: string;
+    }, description?: string): Promise<{
+        ok: true;
+        creditsAdded: number;
+        creditBalance: number;
+        usdPaid: number;
+        workspace: Workspace;
+        settlementSummary: SupplierSettlementSummary;
+    }>;
+    getBillingStatus(): Promise<{
+        ok: true;
+        workspace?: Workspace;
+        creditsBalance?: number;
+        creditBalance?: number;
+        tier?: string;
+        byokKeys?: ByokKeyRecord[];
+        settlementSummary: SupplierSettlementSummary & {
+            totalCustomerChargedCredits?: number;
+        };
+    }>;
+    settlements(): Promise<{
+        ok: true;
+        settlementSummary: SupplierSettlementSummary & {
+            totalCustomerChargedCredits?: number;
+        };
+        summary?: SupplierSettlementSummary;
+    }>;
+    getSettlements(): Promise<{
+        ok: true;
+        settlementSummary: SupplierSettlementSummary & {
+            totalCustomerChargedCredits?: number;
+        };
+    }>;
+    recallMemory(query?: string): Promise<{
+        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;
+        status: string;
+        intent: {
+            toolSlug: string | null;
+            input: Record<string, unknown>;
+            extractedInput: Record<string, unknown>;
+            reason: string;
+            confidence: number;
+        };
+        resolution: Record<string, unknown>;
+        plan?: ActionPlan;
+        run?: ExecutionRun;
+        receipt?: ExecutionReceipt;
+        humanMessage: string;
+    }>;
+    ask(prompt: string, options?: {
+        input?: Record<string, unknown>;
+        autoApprove?: boolean;
+        dryRun?: boolean;
+        planOnly?: boolean;
+        fundingMode?: "muxo_funded" | "byok";
+    }): Promise<{
+        ok: boolean;
+        executed: boolean;
+        status: string;
+        intent: {
+            toolSlug: string | null;
+            input: Record<string, unknown>;
+            extractedInput: Record<string, unknown>;
+            reason: string;
+            confidence: number;
+        };
+        resolution: Record<string, unknown>;
+        plan?: ActionPlan;
+        run?: ExecutionRun;
+        receipt?: ExecutionReceipt;
+        humanMessage: string;
+    }>;
+    listByokKeys(): Promise<{
+        ok: true;
+        workspaceId: string;
+        keys: ByokKeyRecord[];
+    }>;
+    setByokKey(provider: string, secretKey: string): Promise<{
+        ok: true;
+        key: ByokKeyRecord;
+        keys: ByokKeyRecord[];
+    }>;
+    deleteByokKey(provider: string): Promise<{
+        ok: true;
+        deleted: boolean;
+        provider: string;
+        keys: ByokKeyRecord[];
+    }>;
+    /** Lists plans, prices, and credit packs. No auth required. */
+    getPlans(): Promise<{
+        ok: true;
+    } & 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?: "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;
+        fulfilled: boolean;
+        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>>;
+}