@ory/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,87 @@
+# Ory MCP Server
+
+An [MCP](https://modelcontextprotocol.io) server that exposes the [Ory CLI](https://www.ory.com/docs/guides/cli/installation) and the [Ory Network REST API](https://www.ory.com/docs/reference/api) as tools your AI agent can call: manage identities, OAuth2 clients, permission relationships, projects, configuration, and more directly from a chat session.
+
+Every Ory agent plugin in this repo registers it for you, but it's a standalone MCP server; install it on its own and point any MCP-capable harness at it.
+
+## How it works
+
+The server speaks MCP over stdio and registers ~50 tools across two execution paths:
+
+- **CLI-backed tools** shell out to the `ory` binary on your `PATH` (`--format json`). They cover identities, OAuth2 clients, relationships / permissions, projects, configuration, workspaces, organizations, JWKs, and event streams.
+- **`ory_api_request`** calls the Ory Network REST API directly over HTTP. Use it for any endpoint the dedicated tools don't cover (self-service flows, sessions, recovery codes, consent challenges, schemas). The CLI isn't required for this tool; just a base URL and API key.
+
+All logging goes to stderr; stdout is reserved for the MCP protocol.
+
+## Prerequisites
+
+- **Node.js ≥ 24.**
+- **The `ory` CLI on `PATH`** for the CLI-backed tools. Install from [ory.sh/docs/guides/cli/installation](https://www.ory.sh/docs/guides/cli/installation), then authenticate with `ory auth`. (Set `ORY_CLI_PATH` if the binary lives elsewhere.)
+- **`ORY_PROJECT_URL` + `ORY_API_KEY`** for the `ory_api_request` tool.
+
+## Install
+
+```bash
+npm install -g @ory/mcp-server
+```
+
+Then add it to your harness's MCP config. Most harnesses use the generic `mcpServers` shape; for example, Claude Code's `.claude/settings.json`:
+
+```json
+{ "mcpServers": { "ory": { "command": "ory-mcp-server" } } }
+```
+
+To always run the published version on demand instead of installing globally, point the command at `npx`:
+
+```json
+{
+  "mcpServers": {
+    "ory": {
+      "command": "npx",
+      "args": ["--package=@ory/mcp-server", "ory-mcp-server"]
+    }
+  }
+}
+```
+
+> Config shapes vary by harness. OpenCode, for example, uses a `mcp` (singular) key with a `{ "type": "local", "command": [...] }` connector. Check your harness's MCP documentation for the exact schema; the `ory-mcp-server` binary (or the `npx` invocation above) is what every shape ultimately runs.
+
+## Tools
+
+- **Identities**: `list`, `get`, `delete`, `import`, `validate`.
+- **OAuth2 / OIDC**: `list`, `get`, `create`, `update`, `import`, `delete` clients; `introspect`, `revoke`, `perform_client_credentials`; `delete_access_tokens`.
+- **Relationships & Permissions**: `list`, `create`, `create_from_file`, `parse`, `delete`, `check_permission`.
+- **Projects**: `list`, `get`, `create`, `update`, `patch`, `use`.
+- **Configuration**: `get`, `update`, `patch` for identity / oauth2 / permission configs; `update_opl`, `patch_opl`.
+- **Workspaces**: `list`, `get`, `create`.
+- **Organizations (B2B)**: `list`, `create`, `update`, `delete`.
+- **JWKs**: `create`, `get`, `delete`, `import`.
+- **Event streams**: `list`, `create`, `update`, `delete`.
+- **Generic REST**: `ory_api_request` for any Ory Network REST endpoint.
+
+CLI-backed tools accept optional `project` and `workspace` parameters; defaults come from `ORY_PROJECT` / `ORY_WORKSPACE` or from whatever `ory use project` selected. Tools that take a file (imports, OPL, config updates) accept either a `file` path or inline `content`.
+
+## Environment
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `ORY_CLI_PATH` | `ory` | Path to the `ory` CLI binary |
+| `ORY_PROJECT` | _(none)_ | Default project ID/slug for CLI tools |
+| `ORY_WORKSPACE` | _(none)_ | Default workspace ID/name for CLI tools |
+| `ORY_CLI_TIMEOUT` | `30000` | CLI command timeout (ms) |
+| `ORY_PROJECT_URL` | _(none)_ | Base URL for `ory_api_request` |
+| `ORY_SDK_URL` | _(none)_ | Fallback base URL for `ory_api_request` when `ORY_PROJECT_URL` is unset |
+| `ORY_API_KEY` | _(none)_ | Bearer token for `ory_api_request` |
+| `ORY_ACCESS_TOKEN` | _(none)_ | Fallback bearer for `ory_api_request` when `ORY_API_KEY` is unset |
+| `ORY_HTTP_TIMEOUT` | `30000` | REST request timeout (ms) |
+| `ORY_MCP_DEBUG` | `false` | Set to `true` for structured debug logging on stderr |
+
+Per-call parameters on `ory_api_request` (`base_url`, `api_key`) override the corresponding env vars.
+
+## Links
+
+- [ory.com](https://ory.com)
+
+## License
+
+Apache-2.0

package/dist/executor.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Ory CLI execution wrapper.
+ *
+ * Runs `ory` subcommands via child_process.execFile and returns structured results.
+ * Always appends `--format json` for parseable output.
+ */
+export interface ExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare class OryCliNotFoundError extends Error {
+    constructor();
+}
+/**
+ * Run an ory CLI command and return the result.
+ *
+ * Non-zero exit codes are not thrown — the caller inspects stdout/stderr.
+ * Only truly fatal errors (binary missing, timeout) are thrown.
+ */
+export declare function runOryCommand(args: string[]): Promise<ExecResult>;
+/**
+ * Build the common args appended to every ory command.
+ * Adds --format json and optional --project / --workspace flags.
+ */
+export declare function buildCommonArgs(params: {
+    project?: string;
+    workspace?: string;
+    format?: boolean;
+}): string[];
+/**
+ * Helper to format an ory command result as an MCP tool response.
+ */
+export declare function formatToolResult(result: ExecResult): {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+};
+/**
+ * Run an ory command and return a formatted MCP tool response.
+ * Catches OryCliNotFoundError and returns a user-friendly message.
+ */
+export declare function execOryTool(args: string[]): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+/**
+ * For CLI commands that accept either a file path or inline content,
+ * write the content to a tempfile and clean up afterwards.
+ *
+ * Returns an MCP error response if neither is provided. Pass `extension`
+ * to control the temp file suffix (e.g. ".json", ".ts").
+ */
+export declare function withFileOrContent(params: {
+    file?: string;
+    content?: string;
+}, extension: string, fn: (filePath: string) => Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}>): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}>;

package/dist/executor.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * Ory CLI execution wrapper.
+ *
+ * Runs `ory` subcommands via child_process.execFile and returns structured results.
+ * Always appends `--format json` for parseable output.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OryCliNotFoundError = void 0;
+exports.runOryCommand = runOryCommand;
+exports.buildCommonArgs = buildCommonArgs;
+exports.formatToolResult = formatToolResult;
+exports.execOryTool = execOryTool;
+exports.withFileOrContent = withFileOrContent;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+const logger_js_1 = require("./logger.js");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const ORY_BINARY = process.env.ORY_CLI_PATH ?? "ory";
+const TIMEOUT = Number(process.env.ORY_CLI_TIMEOUT) || 30_000;
+const MAX_BUFFER = 10 * 1024 * 1024; // 10 MB
+class OryCliNotFoundError extends Error {
+    constructor() {
+        super("The 'ory' CLI binary was not found on PATH. " +
+            "Install it from https://ory.com/docs/guides/cli/installation " +
+            "or set the ORY_CLI_PATH environment variable to the binary location.");
+        this.name = "OryCliNotFoundError";
+    }
+}
+exports.OryCliNotFoundError = OryCliNotFoundError;
+/**
+ * Run an ory CLI command and return the result.
+ *
+ * Non-zero exit codes are not thrown — the caller inspects stdout/stderr.
+ * Only truly fatal errors (binary missing, timeout) are thrown.
+ */
+async function runOryCommand(args) {
+    (0, logger_js_1.log)("debug", "executing ory command", { args });
+    try {
+        const result = await execFileAsync(ORY_BINARY, args, {
+            maxBuffer: MAX_BUFFER,
+            timeout: TIMEOUT,
+        });
+        return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
+    }
+    catch (err) {
+        const execErr = err;
+        if (execErr.code === "ENOENT") {
+            throw new OryCliNotFoundError();
+        }
+        // Timeout
+        if (execErr.killed || execErr.signal === "SIGTERM") {
+            return {
+                stdout: "",
+                stderr: `Command timed out after ${TIMEOUT}ms. Increase ORY_CLI_TIMEOUT if needed.`,
+                exitCode: 124,
+            };
+        }
+        // Non-zero exit but command ran — return output for the caller to handle
+        if (execErr.stdout !== undefined || execErr.stderr !== undefined) {
+            return {
+                stdout: execErr.stdout ?? "",
+                stderr: execErr.stderr ?? "",
+                exitCode: 1,
+            };
+        }
+        throw err;
+    }
+}
+/**
+ * Build the common args appended to every ory command.
+ * Adds --format json and optional --project / --workspace flags.
+ */
+function buildCommonArgs(params) {
+    const args = [];
+    if (params.format !== false) {
+        args.push("--format", "json");
+    }
+    const project = params.project ?? process.env.ORY_PROJECT;
+    const workspace = params.workspace ?? process.env.ORY_WORKSPACE;
+    if (project)
+        args.push("--project", project);
+    if (workspace)
+        args.push("--workspace", workspace);
+    return args;
+}
+/**
+ * Helper to format an ory command result as an MCP tool response.
+ */
+function formatToolResult(result) {
+    if (result.exitCode !== 0) {
+        const text = result.stderr || result.stdout || "Command failed with no output.";
+        return { content: [{ type: "text", text }], isError: true };
+    }
+    return { content: [{ type: "text", text: result.stdout }] };
+}
+/**
+ * Run an ory command and return a formatted MCP tool response.
+ * Catches OryCliNotFoundError and returns a user-friendly message.
+ */
+async function execOryTool(args) {
+    try {
+        const result = await runOryCommand(args);
+        return formatToolResult(result);
+    }
+    catch (err) {
+        if (err instanceof OryCliNotFoundError) {
+            return { content: [{ type: "text", text: err.message }], isError: true };
+        }
+        const message = err instanceof Error ? err.message : "Unknown error executing ory CLI.";
+        return { content: [{ type: "text", text: message }], isError: true };
+    }
+}
+/**
+ * For CLI commands that accept either a file path or inline content,
+ * write the content to a tempfile and clean up afterwards.
+ *
+ * Returns an MCP error response if neither is provided. Pass `extension`
+ * to control the temp file suffix (e.g. ".json", ".ts").
+ */
+async function withFileOrContent(params, extension, fn) {
+    if (!params.file && !params.content) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Either 'content' or 'file' must be provided.",
+                },
+            ],
+            isError: true,
+        };
+    }
+    if (params.file) {
+        return fn(params.file);
+    }
+    const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "ory-mcp-"));
+    const tempFile = path.join(tmpDir, `payload${extension}`);
+    await fs.promises.writeFile(tempFile, params.content, "utf-8");
+    try {
+        return await fn(tempFile);
+    }
+    finally {
+        await fs.promises.rm(tmpDir, { recursive: true, force: true });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Ory MCP Server — wraps the Ory CLI as an MCP tool provider.
+ *
+ * Communicates via stdio (stdin/stdout) using the Model Context Protocol.
+ * All logging goes to stderr.
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Ory MCP Server — wraps the Ory CLI as an MCP tool provider.
+ *
+ * Communicates via stdio (stdin/stdout) using the Model Context Protocol.
+ * All logging goes to stderr.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const server_js_1 = require("./server.js");
+const logger_js_1 = require("./logger.js");
+async function main() {
+    (0, logger_js_1.log)("info", "starting ory mcp server");
+    const server = (0, server_js_1.createOryMcpServer)();
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    (0, logger_js_1.log)("info", "ory mcp server connected via stdio");
+}
+main().catch((err) => {
+    (0, logger_js_1.log)("error", "fatal error", {
+        error: err instanceof Error ? err.message : String(err),
+    });
+    process.exit(1);
+});

package/dist/logger.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Minimal stderr logger for the MCP server.
+ *
+ * All output goes to stderr — stdout is reserved for the MCP protocol.
+ */
+export declare function log(level: "info" | "warn" | "error" | "debug", message: string, data?: Record<string, unknown>): void;

package/dist/logger.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Minimal stderr logger for the MCP server.
+ *
+ * All output goes to stderr — stdout is reserved for the MCP protocol.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = log;
+const DEBUG = process.env.ORY_MCP_DEBUG === "true";
+function log(level, message, data) {
+    if (level === "debug" && !DEBUG)
+        return;
+    const entry = JSON.stringify({
+        timestamp: new Date().toISOString(),
+        level,
+        component: "ory-mcp-server",
+        message,
+        ...data,
+    });
+    process.stderr.write(entry + "\n");
+}

package/dist/server.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MCP server creation and tool registration.
+ *
+ * Wraps the Ory CLI and Ory Network REST API and registers tool groups for
+ * identities, OAuth2, relationships, projects, configuration, workspaces,
+ * organizations, JWKs, event streams, and a generic REST API request.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createOryMcpServer(): McpServer;

package/dist/server.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * MCP server creation and tool registration.
+ *
+ * Wraps the Ory CLI and Ory Network REST API and registers tool groups for
+ * identities, OAuth2, relationships, projects, configuration, workspaces,
+ * organizations, JWKs, event streams, and a generic REST API request.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOryMcpServer = createOryMcpServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const identities_js_1 = require("./tools/identities.js");
+const oauth2_js_1 = require("./tools/oauth2.js");
+const relationships_js_1 = require("./tools/relationships.js");
+const projects_js_1 = require("./tools/projects.js");
+const config_js_1 = require("./tools/config.js");
+const workspaces_js_1 = require("./tools/workspaces.js");
+const organizations_js_1 = require("./tools/organizations.js");
+const jwk_js_1 = require("./tools/jwk.js");
+const event_streams_js_1 = require("./tools/event_streams.js");
+const api_js_1 = require("./tools/api.js");
+// Read version from package.json at build time via a constant.
+// This avoids dynamic require() issues in CJS/ESM interop.
+const VERSION = "0.1.0";
+function createOryMcpServer() {
+    const server = new mcp_js_1.McpServer({
+        name: "ory",
+        version: VERSION,
+    });
+    (0, identities_js_1.registerIdentityTools)(server);
+    (0, oauth2_js_1.registerOAuth2Tools)(server);
+    (0, relationships_js_1.registerRelationshipTools)(server);
+    (0, projects_js_1.registerProjectTools)(server);
+    (0, config_js_1.registerConfigTools)(server);
+    (0, workspaces_js_1.registerWorkspaceTools)(server);
+    (0, organizations_js_1.registerOrganizationTools)(server);
+    (0, jwk_js_1.registerJwkTools)(server);
+    (0, event_streams_js_1.registerEventStreamTools)(server);
+    (0, api_js_1.registerApiTools)(server);
+    return server;
+}

package/dist/tools/api.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerApiTools(server: McpServer): void;

package/dist/tools/api.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerApiTools = registerApiTools;
+const zod_1 = require("zod");
+const logger_js_1 = require("../logger.js");
+const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+const TIMEOUT = Number(process.env.ORY_HTTP_TIMEOUT) || 30_000;
+const MAX_RESPONSE_SIZE = 5 * 1024 * 1024; // 5 MB
+function resolveBaseUrl(explicit) {
+    return explicit ?? process.env.ORY_PROJECT_URL ?? process.env.ORY_SDK_URL ?? null;
+}
+function resolveApiKey(explicit) {
+    return explicit ?? process.env.ORY_API_KEY ?? process.env.ORY_ACCESS_TOKEN;
+}
+function buildUrl(baseUrl, path, query) {
+    const trimmedBase = baseUrl.replace(/\/+$/, "");
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const url = new URL(`${trimmedBase}${normalizedPath}`);
+    for (const [key, value] of Object.entries(query ?? {})) {
+        url.searchParams.append(key, value);
+    }
+    return url.toString();
+}
+async function executeApiCall(params) {
+    const baseUrl = resolveBaseUrl(params.base_url);
+    if (!baseUrl) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No base URL is configured. Set the ORY_PROJECT_URL environment variable or pass 'base_url'.",
+                },
+            ],
+            isError: true,
+        };
+    }
+    const apiKey = resolveApiKey(params.api_key);
+    const url = buildUrl(baseUrl, params.path, params.query);
+    const headers = {
+        accept: "application/json",
+        ...(params.headers ?? {}),
+    };
+    if (apiKey && !headers.authorization && !headers.Authorization) {
+        headers.authorization = `Bearer ${apiKey}`;
+    }
+    if (params.body && !headers["content-type"] && !headers["Content-Type"]) {
+        headers["content-type"] = "application/json";
+    }
+    (0, logger_js_1.log)("debug", "ory api request", {
+        method: params.method,
+        url,
+        has_body: Boolean(params.body),
+    });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), TIMEOUT);
+    try {
+        const response = await fetch(url, {
+            method: params.method,
+            headers,
+            body: params.body,
+            signal: controller.signal,
+        });
+        let text;
+        const reader = response.body?.getReader();
+        if (reader) {
+            const chunks = [];
+            let total = 0;
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                if (!value)
+                    continue;
+                total += value.byteLength;
+                if (total > MAX_RESPONSE_SIZE) {
+                    await reader.cancel();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Response exceeded ${MAX_RESPONSE_SIZE} bytes. Refine the request or filter the result.`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                chunks.push(value);
+            }
+            text = Buffer.concat(chunks).toString("utf-8");
+        }
+        else {
+            text = await response.text();
+        }
+        const summary = {
+            status: response.status,
+            statusText: response.statusText,
+            body: text,
+        };
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(summary, null, 2) },
+            ],
+            isError: !response.ok,
+        };
+    }
+    catch (err) {
+        if (err.name === "AbortError") {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Request timed out after ${TIMEOUT}ms. Increase ORY_HTTP_TIMEOUT if needed.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: "text", text: `Request failed: ${message}` }],
+            isError: true,
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function registerApiTools(server) {
+    server.registerTool("ory_api_request", {
+        title: "Ory REST API Request",
+        description: "Make an authenticated request against the Ory Network REST API. Use this for endpoints not exposed by the dedicated tools (e.g. self-service flows, identity sessions, recovery codes, consent challenges, trusted JWT issuers, schemas). The base URL defaults to ORY_PROJECT_URL and authentication uses ORY_API_KEY as a Bearer token unless overridden. The full API reference is at https://ory.com/docs/reference/api.",
+        inputSchema: {
+            method: zod_1.z
+                .enum(HTTP_METHODS)
+                .describe("HTTP method"),
+            path: zod_1.z
+                .string()
+                .describe("Path component of the URL (e.g. '/admin/identities', '/admin/sessions')"),
+            base_url: zod_1.z
+                .string()
+                .optional()
+                .describe("Override the base URL. Defaults to ORY_PROJECT_URL or ORY_SDK_URL env var."),
+            query: zod_1.z
+                .record(zod_1.z.string(), zod_1.z.string())
+                .optional()
+                .describe("Query string parameters as a key/value map"),
+            headers: zod_1.z
+                .record(zod_1.z.string(), zod_1.z.string())
+                .optional()
+                .describe("Additional HTTP headers. 'authorization' is set automatically from ORY_API_KEY unless provided."),
+            body: zod_1.z
+                .string()
+                .optional()
+                .describe("Request body as a string. JSON content-type is added automatically when a body is provided."),
+            api_key: zod_1.z
+                .string()
+                .optional()
+                .describe("Override the bearer token. Defaults to ORY_API_KEY env var."),
+        },
+    }, async (params) => executeApiCall(params));
+}

package/dist/tools/config.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerConfigTools(server: McpServer): void;