@muxoai/platform 1.4.0 → 1.4.1

package/dist/mcp-schema.d.ts

@@ -0,0 +1,125 @@
+export interface McpToolAnnotations {
+    readOnlyHint: boolean;
+    destructiveHint: boolean;
+    openWorldHint: boolean;
+}
+export interface McpToolSecurityScheme {
+    type: "noauth" | "oauth2";
+    scopes?: string[];
+}
+export interface McpToolDefinition {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    securitySchemes?: McpToolSecurityScheme[];
+    annotations: McpToolAnnotations;
+    _meta?: Record<string, unknown>;
+}
+export declare const MCP_TOOLS_OAUTH_SCOPE = "mcp:tools";
+/** Workspace-bound tools require an OAuth bearer token (or workspace API key). */
+export declare const DEFAULT_TOOL_SECURITY_SCHEMES: McpToolSecurityScheme[];
+/** Catalog discovery tools work anonymously and also accept OAuth. */
+export declare const PUBLIC_TOOL_SECURITY_SCHEMES: McpToolSecurityScheme[];
+export declare const PUBLIC_MCP_TOOL_NAMES: ReadonlySet<string>;
+/** Stable per-workspace agent identity returned at agent signup on both runtimes. */
+export declare function workspaceAgentDid(workspaceId: string): string;
+/** JSON-RPC methods that anonymous MCP clients may call for discovery. */
+export declare const PUBLIC_MCP_METHODS: ReadonlySet<string>;
+/** True when a single JSON-RPC MCP request only needs public discovery access. */
+export declare function isPublicMcpRequest(rpc: unknown): boolean;
+export declare function securitySchemesForTool(name: string): McpToolSecurityScheme[];
+/** Maximum in-turn polling window for wait_for_connection and get_plan(wait_for_approval). */
+export declare const MAX_MCP_WAIT_SECONDS = 120;
+export declare const DEFAULT_MCP_WAIT_SECONDS = 15;
+export declare function clampWaitSeconds(raw: unknown, fallback?: number, max?: number): number;
+/** Matches explicit catalog slugs (e.g. 'app.github.create_issue') as opposed to natural-language requests. */
+export declare function looksLikeToolSlug(raw: string): boolean;
+/**
+ * Picks the live Composio search hit for a requested `app.<toolkit>.<action>` slug: an exact
+ * slug/upstream match, else a same-toolkit tool whose slug contains every action word. Returns
+ * null rather than an unrelated top search result.
+ */
+export declare function matchAppToolSlug<T extends {
+    slug: string;
+    upstreamSlug: string;
+    providerSlug: string;
+}>(requestedSlug: string, candidates: T[]): T | null;
+export declare const DEFAULT_MCP_SKILL_NAME = "muxo";
+/**
+ * SEP-2640 `skills/get` lookup. A `uri` takes precedence over `name`, and a miss returns
+ * `skill: undefined` so callers answer with JSON-RPC -32602 rather than a default skill.
+ */
+export declare function findMcpSkill<T extends {
+    uri: string;
+    name: string;
+}>(skills: readonly T[], params: {
+    uri?: unknown;
+    name?: unknown;
+}): {
+    skill: T | undefined;
+    requested: string;
+};
+export declare const APPROVED_PLAN_STATUSES: ReadonlySet<string>;
+export declare const GET_RUN_CONTEXT_ACTIONS: readonly ["inspect", "remember", "recall", "forget", "memory_graph", "set_guardrail", "governance_status", "scan_context", "list_workspaces", "switch_workspace", "onboard_team"];
+/** Error carrying a structured MCP/REST payload (merged into structuredContent / JSON body). */
+export declare class MuxoToolError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    readonly payload: Record<string, unknown>;
+    constructor(message: string, options: {
+        code: string;
+        statusCode?: number;
+        payload?: Record<string, unknown>;
+    });
+}
+export declare function unknownToolError(slug: string): MuxoToolError;
+export interface ApprovalGatePlan {
+    id: string;
+    toolSlug: string;
+    riskLevel: string;
+    approvalStatus: string;
+}
+export declare function buildApprovalUrl(baseUrl: string, planId: string): string;
+/** Structured response returned when execute_<risk> is called on a plan still awaiting approval. */
+export declare function buildApprovalRequiredPayload(baseUrl: string, plan: ApprovalGatePlan): Record<string, unknown>;
+export declare function approvalRequiredError(baseUrl: string, plan: ApprovalGatePlan): MuxoToolError;
+export declare function errorPayloadFrom(err: unknown, fallback?: string): Record<string, unknown>;
+export interface OnboardTeamGuideInput {
+    baseUrl: string;
+    workspaceId: string;
+    workspaceName: string;
+    teamName?: string;
+    workspaces?: unknown[];
+}
+/**
+ * MCP onboard_team never mints credentials in-band; it returns the human handoff
+ * (Console / CLI / REST) that issues a Team API key so secrets stay out of agent transcripts.
+ */
+export declare function buildOnboardTeamGuide(input: OnboardTeamGuideInput): Record<string, unknown>;
+/**
+ * Concise server instructions (<512 chars) per OpenAI Plugin MCP Server specification:
+ * https://developers.openai.com/plugins/build/mcp-server
+ */
+export declare const MUXO_MCP_SERVER_INSTRUCTIONS = "Muxo governs SaaS actions (app.*), Instant tools (instant.*), Cloud Infrastructure (resource.*), Memory, and Guardrails. Workflow: 1) search_tools & inspect_tool. 2) plan_action to get a plan_*. 3) If authHandoff.required, show humanHandoff.url and call wait_for_connection. 4) If approvalStatus is pending_approval, send humanHandoff.url or call get_plan(wait_for_approval:true). 5) Execute via execute_<risk>. 6) Manage memory/guardrails via get_run_context.";
+export declare const MUXO_MCP_TOOLS: McpToolDefinition[];
+/**
+ * OpenAI Company Knowledge standard `search` and `fetch` tool definitions
+ * per https://developers.openai.com/plugins/build/mcp-server#company-knowledge-compatibility
+ */
+export declare const OPENAI_COMPANY_KNOWLEDGE_TOOLS: McpToolDefinition[];
+export interface McpNextToolCallHint {
+    tool: string;
+    input: Record<string, unknown>;
+    when: string;
+}
+export interface McpHarnessGuidance {
+    summary: string;
+    nextToolCalls: McpNextToolCallHint[];
+}
+/**
+ * Enriches any MCP tool output object with structured `llmGuidance` so agent harnesses
+ * (Claude Code, Cursor, Codex, OpenAI MCP, Windsurf) always know the exact next tool call.
+ */
+export declare function attachMcpHarnessGuidance<T>(toolName: string, toolArgs: Record<string, unknown>, output: T): T;