@muxoai/platform 0.0.0-stage → 1.2.1

package/dist/engine.d.ts

@@ -0,0 +1,128 @@
+import type { MuxoConfig } from "./config.js";
+import { ComposioInstantAdapter } from "./providers/composio-instant.js";
+import { ComposioSdkAdapter } from "./providers/composio-sdk.js";
+import { MicrosoftGovernanceAdapter } from "./providers/microsoft-governance.js";
+import { StripeBillingAdapter } from "./providers/stripe-billing.js";
+import { StripeProjectsAdapter } from "./providers/stripe-projects.js";
+import { SupermemoryAdapter } from "./providers/supermemory.js";
+import type { MuxoStore } from "./store.js";
+import type { ActionPlan, ConnectionRecord, ExecutionReceipt, ExecutionRun, GovernanceDecisionRecord, MemoryContextSummary, MuxoTool, ProviderLane, RiskLevel, User, Workspace, WorkspaceMemoryRecord } from "./types.js";
+export interface ExecutionContext {
+    user: User;
+    workspace: Workspace;
+    actorId: string;
+    authType: "session" | "api_key";
+}
+export declare class MuxoEngine {
+    readonly config: MuxoConfig;
+    readonly store: MuxoStore;
+    readonly composioSdk: ComposioSdkAdapter;
+    readonly composioInstant: ComposioInstantAdapter;
+    readonly stripeProjects: StripeProjectsAdapter;
+    readonly stripeBilling: StripeBillingAdapter;
+    readonly governance: MicrosoftGovernanceAdapter;
+    readonly supermemory: SupermemoryAdapter;
+    constructor(config: MuxoConfig, store: MuxoStore);
+    getProfile(ctx: ExecutionContext): Record<string, unknown>;
+    getOrganization(ctx: ExecutionContext): Record<string, unknown>;
+    searchTools(params: {
+        query?: string;
+        lane?: ProviderLane | "all";
+        riskLevel?: RiskLevel;
+        limit?: number;
+    }): Promise<{
+        tools: MuxoTool[];
+        total: number;
+    }>;
+    inspectTool(slug: string): Promise<MuxoTool>;
+    connectionStatus(ctx: ExecutionContext, params?: {
+        provider?: string;
+        syncLive?: boolean;
+    }): Promise<Record<string, unknown>>;
+    startConnection(ctx: ExecutionContext, params: {
+        provider: string;
+        lane?: ProviderLane;
+        callbackUrl?: string;
+    }): Promise<ConnectionRecord & {
+        message: string;
+        callbackUrl?: string;
+    }>;
+    waitForConnection(ctx: ExecutionContext, params: {
+        provider: string;
+        timeoutSeconds?: number;
+        pollIntervalMs?: number;
+    }): Promise<{
+        connected: boolean;
+        provider: string;
+        status: ConnectionRecord["status"];
+        connection: ConnectionRecord;
+        redirectUrl: string | null;
+        message: string;
+    }>;
+    handleOAuthCallback(params: {
+        workspaceId: string;
+        provider: string;
+        connectedAccountId?: string;
+        status?: string;
+    }): Promise<{
+        ok: boolean;
+        workspaceId: string;
+        providerSlug: string;
+        providerName: string;
+        status: ConnectionRecord["status"];
+        externalAccountId: string | null;
+    }>;
+    planAction(ctx: ExecutionContext, params: {
+        toolSlug: string;
+        input?: Record<string, unknown>;
+        reason?: string;
+    }): Promise<{
+        plan: ActionPlan;
+        tool: MuxoTool;
+        decisionRecord: GovernanceDecisionRecord;
+        memoryContext: MemoryContextSummary;
+        authHandoff?: {
+            required: boolean;
+            provider: string;
+            status: ConnectionRecord["status"];
+            redirectUrl: string | null;
+            externalAccountId: string | null;
+            instructions: string;
+        };
+        nextStep: string;
+    }>;
+    getPlan(ctx: ExecutionContext, planId: string): ActionPlan;
+    approvePlan(ctx: ExecutionContext, planId: string, decision?: "approved" | "rejected"): ActionPlan;
+    getRunContext(ctx: ExecutionContext, query?: string): Promise<Record<string, unknown>>;
+    getMemoryOverview(ctx: ExecutionContext, query?: string): Promise<{
+        enabled: boolean;
+        namespace: string;
+        context: MemoryContextSummary;
+        recentMemories: WorkspaceMemoryRecord[];
+        memories: WorkspaceMemoryRecord[];
+    }>;
+    addWorkspaceMemory(ctx: ExecutionContext, params: {
+        title: string;
+        content: string;
+        kind?: WorkspaceMemoryRecord["kind"];
+        metadata?: Record<string, unknown>;
+    }): Promise<WorkspaceMemoryRecord>;
+    deleteWorkspaceMemory(ctx: ExecutionContext, idOrDocId: string): Promise<{
+        deleted: boolean;
+        record: WorkspaceMemoryRecord | null;
+    }>;
+    executePlanForRisk(ctx: ExecutionContext, planId: string, expectedRisk: RiskLevel): Promise<{
+        run: ExecutionRun;
+        receipt: ExecutionReceipt;
+    }>;
+    getRun(ctx: ExecutionContext, runId: string): ExecutionRun;
+    cancelRun(ctx: ExecutionContext, runId: string): {
+        run: ExecutionRun;
+        receipt: ExecutionReceipt | null;
+    };
+    getReceipt(ctx: ExecutionContext, receiptOrRunId: string): {
+        receipt: ExecutionReceipt;
+        signatureValid: boolean;
+        governanceSignatureValid: boolean;
+    };
+}