brains-mcp 1.61.2

package/dist/api/openapi.js

@@ -0,0 +1,942 @@
+import { getVisibleTools } from "../server.js";
+function makeToolSummary(name) {
+    return name
+        .split("_")
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function resolveServerUrl() {
+    const value = process.env.BRAINS_BASE_URL?.trim() ||
+        process.env.BRAINS_PUBLIC_BASE_URL?.trim() ||
+        process.env.API_BASE_URL?.trim() ||
+        "";
+    if (!value)
+        return "/";
+    return value.replace(/\/$/, "");
+}
+function resolveAbsoluteUrl(pathname) {
+    const base = resolveServerUrl();
+    if (base === "/")
+        return pathname;
+    return `${base}${pathname}`;
+}
+export function buildOpenApiSpec() {
+    const visibleTools = getVisibleTools();
+    const toolSchemas = Object.fromEntries(visibleTools.map((tool) => [
+        `${tool.name}Input`,
+        tool.inputSchema,
+    ]));
+    return {
+        openapi: "3.1.0",
+        info: {
+            title: "brains Wiki API",
+            version: "1.0.0",
+            description: "API-first interface for the brains second-brain wiki. OAuth 2.0 authorization-code flow is designed for ChatGPT Actions and Claude integrations.",
+        },
+        servers: [{ url: resolveServerUrl() }],
+        security: [{ ApiKeyAuth: [] }, { OAuth2: ["wiki.read", "wiki.write"] }],
+        tags: [
+            { name: "Auth" },
+            { name: "Wiki" },
+            { name: "Session" },
+            { name: "Tools" },
+            { name: "Health" },
+            { name: "Discovery" },
+        ],
+        paths: {
+            "/": {
+                get: {
+                    tags: ["Discovery"],
+                    summary: "Service metadata",
+                    security: [],
+                    responses: {
+                        "200": {
+                            description: "Service information",
+                        },
+                    },
+                },
+            },
+            "/openapi.json": {
+                get: {
+                    tags: ["Discovery"],
+                    summary: "OpenAPI document",
+                    security: [],
+                    responses: {
+                        "200": {
+                            description: "OpenAPI JSON",
+                        },
+                    },
+                },
+            },
+            "/api/v1": {
+                get: {
+                    tags: ["Discovery"],
+                    summary: "API index (OpenAPI)",
+                    description: "Returns the full OpenAPI spec. Equivalent to GET /openapi.json. Useful for agent discoverability — lists all routes including /import-zip/upload, /purge, and /tools/{name}.",
+                    security: [],
+                    responses: {
+                        "200": {
+                            description: "OpenAPI JSON",
+                        },
+                    },
+                },
+            },
+            "/.well-known/oauth-authorization-server": {
+                get: {
+                    tags: ["Discovery"],
+                    summary: "OAuth authorization server metadata",
+                    security: [],
+                    responses: {
+                        "200": {
+                            description: "OAuth server discovery metadata",
+                        },
+                    },
+                },
+            },
+            "/oauth/authorize": {
+                get: {
+                    tags: ["Auth"],
+                    summary: "OAuth authorization endpoint",
+                    security: [],
+                    parameters: [
+                        { name: "response_type", in: "query", required: true, schema: { type: "string", enum: ["code"] } },
+                        { name: "client_id", in: "query", required: true, schema: { type: "string" } },
+                        { name: "redirect_uri", in: "query", required: true, schema: { type: "string", format: "uri" } },
+                        { name: "scope", in: "query", required: false, schema: { type: "string" } },
+                        { name: "state", in: "query", required: false, schema: { type: "string" } },
+                        { name: "code_challenge", in: "query", required: false, schema: { type: "string" } },
+                        {
+                            name: "code_challenge_method",
+                            in: "query",
+                            required: false,
+                            schema: { type: "string", enum: ["S256", "plain"] },
+                        },
+                    ],
+                    responses: {
+                        "200": { description: "Consent/login UI" },
+                        "302": { description: "Redirect with authorization code" },
+                    },
+                },
+                post: {
+                    tags: ["Auth"],
+                    summary: "OAuth authorization form submit",
+                    security: [],
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/x-www-form-urlencoded": {
+                                schema: {
+                                    type: "object",
+                                    required: ["username", "password", "client_id", "redirect_uri", "scope"],
+                                    properties: {
+                                        username: { type: "string" },
+                                        password: { type: "string" },
+                                        client_id: { type: "string" },
+                                        redirect_uri: { type: "string", format: "uri" },
+                                        scope: { type: "string" },
+                                        state: { type: "string" },
+                                        code_challenge: { type: "string" },
+                                        code_challenge_method: { type: "string", enum: ["S256", "plain"] },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    responses: {
+                        "302": { description: "Redirect with authorization code" },
+                        "400": { description: "Invalid request" },
+                        "401": { description: "Invalid user credentials" },
+                    },
+                },
+            },
+            "/oauth/token": {
+                post: {
+                    tags: ["Auth"],
+                    summary: "OAuth token endpoint",
+                    security: [],
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/x-www-form-urlencoded": {
+                                schema: {
+                                    type: "object",
+                                    required: ["grant_type"],
+                                    properties: {
+                                        grant_type: { type: "string", enum: ["authorization_code", "refresh_token"] },
+                                        code: { type: "string" },
+                                        redirect_uri: { type: "string", format: "uri" },
+                                        client_id: { type: "string" },
+                                        client_secret: {
+                                            type: "string",
+                                            description: "Required for confidential clients; omit for public PKCE clients.",
+                                        },
+                                        code_verifier: { type: "string" },
+                                        refresh_token: { type: "string" },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Access token response" },
+                        "400": { description: "OAuth error" },
+                    },
+                },
+            },
+            "/api/v1/health": {
+                get: {
+                    tags: ["Health"],
+                    summary: "Health check",
+                    responses: {
+                        "200": { description: "Health status" },
+                    },
+                },
+            },
+            "/api/v1/launch/status": {
+                get: {
+                    tags: ["Health"],
+                    summary: "Launch spot counter",
+                    description: "Returns remaining first-500 launch spots for the marketing pricing page. Result is cached for 60 seconds.",
+                    responses: {
+                        "200": {
+                            description: "Launch status",
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object",
+                                        properties: {
+                                            spotsRemaining: { type: "number", description: "Launch spots left, floored at 0" },
+                                            offerOpen: { type: "boolean", description: "False once all 500 spots are claimed" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            "/api/v1/metrics": {
+                get: {
+                    tags: ["Health"],
+                    summary: "Request telemetry metrics",
+                    description: "Aggregates request_events telemetry over a configurable time window. Requires wiki.read scope.",
+                    parameters: [
+                        {
+                            name: "window",
+                            in: "query",
+                            schema: { type: "string", enum: ["1h", "6h", "24h", "7d"], default: "1h" },
+                            description: "Aggregation window. Defaults to 1h.",
+                        },
+                    ],
+                    responses: {
+                        "200": {
+                            description: "Metrics aggregation",
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object",
+                                        properties: {
+                                            window: { type: "string" },
+                                            search: {
+                                                type: "object",
+                                                properties: {
+                                                    p50: { type: "number" },
+                                                    p95: { type: "number" },
+                                                    p99: { type: "number" },
+                                                    totalRequests: { type: "integer" },
+                                                    errorRate: { type: "number" },
+                                                    zeroResultRate: { type: "number" },
+                                                    backendBreakdown: { type: "object", additionalProperties: { type: "number" } },
+                                                    topQueries: { type: "array", items: { type: "string" } },
+                                                },
+                                            },
+                                            writes: {
+                                                type: "object",
+                                                properties: {
+                                                    p50: { type: "number" },
+                                                    p95: { type: "number" },
+                                                    totalRequests: { type: "integer" },
+                                                },
+                                            },
+                                            overall: {
+                                                type: "object",
+                                                properties: {
+                                                    p95: { type: "number" },
+                                                    errorRate: { type: "number" },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        "400": { description: "Invalid window parameter" },
+                        "401": { description: "Missing or invalid authentication" },
+                    },
+                },
+            },
+            "/api/v1/pages": {
+                get: {
+                    tags: ["Wiki"],
+                    summary: "List pages",
+                    parameters: [
+                        { name: "tag", in: "query", schema: { type: "string" } },
+                        { name: "status", in: "query", schema: { type: "string", enum: ["active", "archived", "draft"] } },
+                    ],
+                    responses: {
+                        "200": { description: "Pages list" },
+                    },
+                },
+                post: {
+                    tags: ["Wiki"],
+                    summary: "Create page",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/create_pageInput" },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Create result" },
+                    },
+                },
+            },
+            "/api/v1/pages/batch": {
+                post: {
+                    tags: ["Wiki"],
+                    summary: "Create pages batch",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/create_pagesInput" },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Batch result" },
+                    },
+                },
+            },
+            "/api/v1/pages/{name}/backlinks": {
+                get: {
+                    tags: ["Wiki"],
+                    summary: "List backlinks for a page",
+                    parameters: [
+                        { name: "name", in: "path", required: true, schema: { type: "string" } },
+                        { name: "userId", in: "query", required: false, schema: { type: "string" }, description: "Admin (api-key) only: query a specific user's link graph." },
+                    ],
+                    responses: {
+                        "200": { description: "Backlink source pages" },
+                        "403": { description: "userId override requires api-key authentication" },
+                    },
+                },
+            },
+            "/api/v1/pages/{name}/related": {
+                get: {
+                    tags: ["Wiki"],
+                    summary: "List related pages (shared outbound targets)",
+                    parameters: [
+                        { name: "name", in: "path", required: true, schema: { type: "string" } },
+                        { name: "userId", in: "query", required: false, schema: { type: "string" }, description: "Admin (api-key) only: query a specific user's link graph." },
+                    ],
+                    responses: {
+                        "200": { description: "Related pages" },
+                        "403": { description: "userId override requires api-key authentication" },
+                    },
+                },
+            },
+            "/api/v1/page": {
+                get: {
+                    tags: ["Wiki"],
+                    summary: "Read page",
+                    parameters: [{ name: "name", in: "query", required: true, schema: { type: "string" } }],
+                    responses: {
+                        "200": { description: "Page" },
+                    },
+                },
+                put: {
+                    tags: ["Wiki"],
+                    summary: "Update page (full rewrite)",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/update_pageInput" },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Update result" },
+                    },
+                },
+                patch: {
+                    tags: ["Wiki"],
+                    summary: "Patch page",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/patch_pageInput" },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Patch result" },
+                    },
+                },
+            },
+            "/api/v1/page/move": {
+                post: {
+                    tags: ["Wiki"],
+                    summary: "Archive or rename page",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/move_pageInput" },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Move result" },
+                    },
+                },
+            },
+            "/api/v1/search": {
+                get: {
+                    tags: ["Wiki"],
+                    summary: "Search pages",
+                    parameters: [
+                        { name: "query", in: "query", required: true, schema: { type: "string" } },
+                        { name: "tag", in: "query", schema: { type: "string" } },
+                        { name: "maxCandidates", in: "query", schema: { type: "integer" } },
+                        { name: "maxResults", in: "query", schema: { type: "integer" } },
+                        { name: "maxConcurrency", in: "query", schema: { type: "integer" } },
+                    ],
+                    responses: {
+                        "200": { description: "Search result" },
+                    },
+                },
+            },
+            "/api/v1/logs": {
+                post: {
+                    tags: ["Wiki"],
+                    summary: "Append log entry",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/append_logInput" },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Log write result" },
+                    },
+                },
+            },
+            "/api/v1/links/extract": {
+                post: {
+                    tags: ["Wiki"],
+                    summary: "Extract and index wiki links for stale pages",
+                    description: "Processes only pages matching tags/folder filters where link metadata is missing or stale. Admin (api-key) callers may pass userId to backfill another user's pages.",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        tags: { type: "array", items: { type: "string" } },
+                                        folder: { type: "string" },
+                                        userId: { type: "string", description: "Admin (api-key) only: target a specific user's pages." },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Extraction summary" },
+                        "400": { description: "Missing required filter parameter" },
+                        "403": { description: "userId override requires api-key authentication" },
+                    },
+                },
+            },
+            "/api/v1/links/suggest": {
+                post: {
+                    tags: ["Wiki"],
+                    summary: "Suggest cross-reference links for pages missing a Related pages section",
+                    description: "Finds pages that lack a '## Related pages' section and returns ready-to-apply markdown patches suggesting cross-references. Uses the link graph when available; falls back to tag-overlap heuristics. Never writes — all patches require explicit review and confirmation.",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        tags: { type: "array", items: { type: "string" } },
+                                        folder: { type: "string" },
+                                        maxPages: { type: "number", description: "Maximum candidate pages to analyze (default 20, max 50)." },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Link suggestion result with patches" },
+                        "400": { description: "Missing required filter parameter" },
+                    },
+                },
+            },
+            "/api/v1/import": {
+                post: {
+                    tags: ["Wiki"],
+                    summary: "Import source brain documents",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/import_brain_sourceInput" },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Import result" },
+                    },
+                },
+            },
+            "/api/v1/export": {
+                post: {
+                    tags: ["Wiki"],
+                    summary: "Export wiki to ZIP archive",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/export_wikiInput" },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Export result" },
+                    },
+                },
+            },
+            "/api/v1/export/download": {
+                get: {
+                    tags: ["Wiki"],
+                    summary: "Download wiki export ZIP (async)",
+                    description: "Enqueues a background export job and returns immediately. Poll GET /api/v1/jobs/{jobId} until status is 'done', then fetch the ZIP from GET /api/v1/jobs/{jobId}/download.",
+                    parameters: [
+                        {
+                            name: "folder",
+                            in: "query",
+                            required: false,
+                            schema: { type: "string" },
+                            description: "Optional path prefix filter (e.g. projects/brainsapp).",
+                        },
+                        {
+                            name: "tags",
+                            in: "query",
+                            required: false,
+                            schema: { type: "string" },
+                            description: "Optional comma-separated tags filter.",
+                        },
+                        {
+                            name: "includeSystem",
+                            in: "query",
+                            required: false,
+                            schema: { type: "boolean", default: false },
+                            description: "Include system files (index.md, log.md). Defaults to false.",
+                        },
+                        {
+                            name: "since",
+                            in: "query",
+                            required: false,
+                            schema: { type: "string", format: "date-time" },
+                            description: "ISO 8601 datetime — only include pages modified after this time (delta export).",
+                        },
+                    ],
+                    responses: {
+                        "202": {
+                            description: "Export job queued. Poll GET /api/v1/jobs/{jobId} for status, then GET /api/v1/jobs/{jobId}/download for the ZIP.",
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object",
+                                        properties: {
+                                            ok: { type: "boolean" },
+                                            jobId: { type: "string" },
+                                            status: { type: "string" },
+                                            pollUrl: { type: "string" },
+                                            downloadUrl: { type: "string" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        "400": { description: "Invalid query parameter" },
+                        "401": { description: "Missing or invalid authentication" },
+                    },
+                },
+            },
+            "/api/v1/import-zip": {
+                post: {
+                    tags: ["Wiki"],
+                    summary: "Import wiki from ZIP archive",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/import_wikiInput" },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Import result" },
+                    },
+                },
+            },
+            "/api/v1/import-zip/upload": {
+                post: {
+                    tags: ["Wiki"],
+                    summary: "Import wiki from uploaded ZIP bytes",
+                    parameters: [
+                        {
+                            name: "execute",
+                            in: "query",
+                            required: false,
+                            schema: { type: "boolean", default: true },
+                            description: "If false, returns preview diff only. Defaults to true.",
+                        },
+                        {
+                            name: "conflictStrategy",
+                            in: "query",
+                            required: false,
+                            schema: { type: "string", enum: ["skip", "overwrite", "merge"], default: "merge" },
+                            description: "Conflict handling strategy. Defaults to merge.",
+                        },
+                        {
+                            name: "includeSystem",
+                            in: "query",
+                            required: false,
+                            schema: { type: "boolean", default: false },
+                            description: "Include system files (index.md, log.md). Defaults to false.",
+                        },
+                        {
+                            name: "mode",
+                            in: "query",
+                            required: false,
+                            schema: { type: "string", enum: ["additive", "replace"], default: "additive" },
+                            description: "Import mode. replace mirrors ZIP and deletes pages missing from ZIP.",
+                        },
+                        {
+                            name: "logTiming",
+                            in: "query",
+                            required: false,
+                            schema: { type: "boolean", default: false },
+                            description: "If true, appends a log entry to log.md after a successful execute run. Defaults to false.",
+                        },
+                    ],
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/zip": {
+                                schema: { type: "string", format: "binary" },
+                            },
+                        },
+                    },
+                    responses: {
+                        "202": {
+                            description: "Job queued (both preview and execute). Poll GET /api/v1/jobs/{jobId} for result.",
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object",
+                                        properties: {
+                                            ok: { type: "boolean" },
+                                            jobId: { type: "string" },
+                                            status: { type: "string" },
+                                            pollUrl: { type: "string" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        "400": { description: "Invalid query parameter" },
+                        "401": { description: "Missing or invalid authentication" },
+                        "413": { description: "Payload too large" },
+                        "415": { description: "Unsupported media type" },
+                    },
+                },
+            },
+            "/api/v1/purge": {
+                post: {
+                    tags: ["Wiki"],
+                    summary: "Purge all wiki pages",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: { $ref: "#/components/schemas/purge_wikiInput" },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Dry-run result (confirm=false)" },
+                        "202": {
+                            description: "Purge job queued (confirm=true). Poll GET /api/v1/jobs/{jobId} for result.",
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object",
+                                        properties: {
+                                            ok: { type: "boolean" },
+                                            jobId: { type: "string" },
+                                            status: { type: "string" },
+                                            pollUrl: { type: "string" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            "/api/v1/jobs/{jobId}": {
+                get: {
+                    tags: ["Wiki"],
+                    summary: "Get async job status and result",
+                    parameters: [
+                        {
+                            name: "jobId",
+                            in: "path",
+                            required: true,
+                            schema: { type: "string" },
+                            description: "Job ID returned by an async import or purge endpoint.",
+                        },
+                    ],
+                    responses: {
+                        "200": {
+                            description: "Job status",
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object",
+                                        properties: {
+                                            ok: { type: "boolean" },
+                                            job: {
+                                                type: "object",
+                                                properties: {
+                                                    id: { type: "string" },
+                                                    kind: { type: "string", enum: ["import", "import-preview", "export", "purge"] },
+                                                    status: { type: "string", enum: ["queued", "running", "done", "failed"] },
+                                                    progress: {
+                                                        type: "object",
+                                                        properties: {
+                                                            processed: { type: "integer" },
+                                                            total: { type: "integer" },
+                                                            phase: { type: "string" },
+                                                        },
+                                                    },
+                                                    result: { type: "object" },
+                                                    error: { type: "string" },
+                                                    startedAt: { type: "string" },
+                                                    completedAt: { type: "string" },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        "401": { description: "Missing or invalid authentication" },
+                        "404": { description: "Job not found or expired (jobs expire after 1 hour)" },
+                    },
+                },
+            },
+            "/api/v1/jobs/{jobId}/download": {
+                get: {
+                    tags: ["Wiki"],
+                    summary: "Download the binary result of a completed async job",
+                    parameters: [
+                        {
+                            name: "jobId",
+                            in: "path",
+                            required: true,
+                            schema: { type: "string" },
+                            description: "Job ID returned by an async export endpoint.",
+                        },
+                    ],
+                    responses: {
+                        "200": {
+                            description: "Binary file (e.g. ZIP archive for export jobs)",
+                            content: {
+                                "application/zip": {
+                                    schema: { type: "string", format: "binary" },
+                                },
+                            },
+                        },
+                        "401": { description: "Missing or invalid authentication" },
+                        "404": { description: "Job not found, expired, or has no binary result" },
+                        "409": { description: "Job is not yet done — poll /api/v1/jobs/{jobId} first" },
+                    },
+                },
+            },
+            "/api/v1/session/bundle": {
+                get: {
+                    tags: ["Session"],
+                    summary: "Pull a filtered slice as a plain-text bundle",
+                    description: "Returns pages matching the given tag or folder filter as a single plain-text bundle. At least one of 'tags' or 'folder' must be provided. Requires wiki.read scope.",
+                    parameters: [
+                        {
+                            name: "tags",
+                            in: "query",
+                            required: false,
+                            schema: { type: "string" },
+                            description: "Comma-separated tag filter (e.g. 'brainsapp,open-loop'). Pages with any matching tag are included.",
+                        },
+                        {
+                            name: "folder",
+                            in: "query",
+                            required: false,
+                            schema: { type: "string" },
+                            description: "Path prefix filter (e.g. 'projects/brainsapp'). Pages whose path starts with this prefix are included.",
+                        },
+                    ],
+                    responses: {
+                        "200": {
+                            description: "Bundle of matching pages as plain text",
+                            headers: {
+                                "X-Page-Count": {
+                                    schema: { type: "integer" },
+                                    description: "Number of pages included in the bundle",
+                                },
+                                "X-Session-Token": {
+                                    schema: { type: "string" },
+                                    description: "UUID identifying this session pull",
+                                },
+                            },
+                            content: {
+                                "text/plain": {
+                                    schema: { type: "string" },
+                                },
+                            },
+                        },
+                        "400": { description: "Missing required filter parameter" },
+                        "401": { description: "Missing or invalid authentication" },
+                    },
+                },
+                post: {
+                    tags: ["Session"],
+                    summary: "Push edited pages back from a bundle",
+                    description: "Accepts a plain-text bundle (same format as GET response) and upserts each page into the wiki. Requires wiki.write scope.",
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "text/plain": {
+                                schema: { type: "string" },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": {
+                            description: "Upsert result",
+                            content: {
+                                "application/json": {
+                                    schema: {
+                                        type: "object",
+                                        properties: {
+                                            ok: { type: "boolean" },
+                                            updated: { type: "integer" },
+                                            created: { type: "integer" },
+                                            failed: {
+                                                type: "array",
+                                                items: {
+                                                    type: "object",
+                                                    properties: {
+                                                        name: { type: "string" },
+                                                        error: { type: "string" },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        "400": { description: "Invalid bundle format" },
+                        "401": { description: "Missing or invalid authentication" },
+                    },
+                },
+            },
+            "/api/v1/tools": {
+                get: {
+                    tags: ["Tools"],
+                    summary: "List tool contracts",
+                    responses: {
+                        "200": { description: "Tool catalog" },
+                    },
+                },
+            },
+            "/api/v1/tools/{name}": {
+                post: {
+                    tags: ["Tools"],
+                    summary: "Invoke any tool by name",
+                    parameters: [{ name: "name", in: "path", required: true, schema: { type: "string" } }],
+                    requestBody: {
+                        required: true,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        arguments: { type: "object", additionalProperties: true },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    responses: {
+                        "200": { description: "Tool execution result" },
+                    },
+                },
+            },
+        },
+        components: {
+            securitySchemes: {
+                OAuth2: {
+                    type: "oauth2",
+                    flows: {
+                        authorizationCode: {
+                            authorizationUrl: resolveAbsoluteUrl("/oauth/authorize"),
+                            tokenUrl: resolveAbsoluteUrl("/oauth/token"),
+                            scopes: {
+                                "wiki.read": "Read wiki content and metadata",
+                                "wiki.write": "Create, update, patch, and move wiki content",
+                            },
+                        },
+                    },
+                },
+                ApiKeyAuth: {
+                    type: "apiKey",
+                    in: "header",
+                    name: "x-api-key",
+                },
+            },
+            schemas: {
+                ...toolSchemas,
+            },
+        },
+        "x-tools": visibleTools.map((tool) => ({
+            name: tool.name,
+            summary: makeToolSummary(tool.name),
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        })),
+    };
+}
+//# sourceMappingURL=openapi.js.map