@redocly/redoc 0.138.0-next.14 → 0.138.0-next.16

package/dist/server/plugins/mcp/docs-mcp/tools/core/whoami.js

@@ -0,0 +1 @@
+const s=async(i,e)=>e.user?.isAuthenticated?{content:[{type:"text",text:JSON.stringify({authenticated:!0,email:e.user.email,name:e.user.claims?.name,subject:e.user.claims?.sub,clientId:e.user.claims?.client_id,scope:e.user.claims?.scope,issuedAt:e.user.claims?.iat?new Date(Number(e.user.claims.iat)*1e3).toISOString():void 0,expiresAt:e.user.claims?.exp?new Date(Number(e.user.claims.exp)*1e3).toISOString():void 0})}]}:{content:[{type:"text",text:JSON.stringify({authenticated:!1})}]};var a={whoami:s};export{a as default};

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const GRAPHQL_TYPE_KINDS: readonly ['queries', 'mutations', 'subscriptions', 'objects', 'interfaces', 'unions', 'enums', 'inputs', 'scalars', 'directives'];
+export declare const GRAPHQL_LIST_SCOPES: readonly ['members', 'fields'];
+export declare const FIELD_SCOPE_KINDS: readonly ['objects', 'interfaces', 'inputs'];
+//# sourceMappingURL=constants.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/constants.js

@@ -0,0 +1 @@
+const s=["queries","mutations","subscriptions","objects","interfaces","unions","enums","inputs","scalars","directives"],e=["members","fields"],t=["objects","interfaces","inputs"];export{t as FIELD_SCOPE_KINDS,e as GRAPHQL_LIST_SCOPES,s as GRAPHQL_TYPE_KINDS};

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/get-graphql-schema.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolHandler } from '../../../types.js';
+import type { GetGraphqlSchemaArgs } from './types.js';
+declare const _default: {
+    'get-graphql-schema': McpToolHandler<GetGraphqlSchemaArgs>;
+};
+export default _default;
+//# sourceMappingURL=get-graphql-schema.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/get-graphql-schema.js

@@ -0,0 +1,3 @@
+import{printSchema as h}from"graphql";import{respondWithGraphqlSchema as t}from"./tool-helpers.js";const p=(e,a)=>t(e.name,a,({name:m,schema:r})=>`# Schema: ${m}
+
+${h(r)}`);var n={"get-graphql-schema":p};export{n as default};

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/get-graphql-type-list.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolHandler } from '../../../types.js';
+import type { GetGraphqlTypeListArgs } from './types.js';
+declare const _default: {
+    'get-graphql-type-list': McpToolHandler<GetGraphqlTypeListArgs>;
+};
+export default _default;
+//# sourceMappingURL=get-graphql-type-list.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/get-graphql-type-list.js

@@ -0,0 +1 @@
+import{FIELD_SCOPE_KINDS as n,GRAPHQL_TYPE_KINDS as u}from"./constants.js";import{respondWithGraphqlSchema as g,paginate as d}from"./tool-helpers.js";import{groupSchemaTypes as h,fieldMembers as y,filterMembersReferencingType as S,matchesFilter as b}from"./utils.js";function T(r,p,t){if(p==="fields"){if(t&&!n.some(e=>e===t))throw new Error(`scope "fields" lists the fields of object, interface, and input types; kind must be ${n.map(e=>`"${e}"`).join(", ")}, or omitted.`);return y(r,t)}const o=h(r);return(t?[t]:u).flatMap(e=>o[e].map(s=>({kind:e,...s})))}const E=(r,p)=>g(r.name,p,({name:t,schema:o})=>{const{kind:e,scope:s="members",filter:f,referencesType:l,page:m=1,limit:a=300}=r;let i=T(o,s,e);return l&&(i=S(o,i,l)),f&&(i=i.filter(c=>b(c,f))),JSON.stringify({name:t,...d(i,m,a)},null,2)});var D={"get-graphql-type-list":E};export{D as default};

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/get-graphql-type.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolHandler } from '../../../types.js';
+import type { GetGraphqlTypeArgs } from './types.js';
+declare const _default: {
+    'get-graphql-type': McpToolHandler<GetGraphqlTypeArgs>;
+};
+export default _default;
+//# sourceMappingURL=get-graphql-type.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/get-graphql-type.js

@@ -0,0 +1,10 @@
+import{respondWithGraphqlSchema as s}from"./tool-helpers.js";import{printTypeOrField as d,printTypeOrFieldWithReferences as a,referencedTypeManifest as m}from"./utils.js";const h=(n,i)=>s(n.name,i,({name:p,schema:t})=>{const{includeReferencedTypes:c}=n,e=n.type??n.typeName;if(!e)throw new Error("Pass `type`: the name of the type, operation, or directive.");if(c){const{sdl:r,referencedCount:l}=a(t,e);return`# Schema: ${p}
+# Type: ${e} (+ ${l} referenced types)
+
+${r}`}const o=`# Schema: ${p}
+# Type: ${e}
+
+${d(t,e)}`,f=m(t,e);if(f.length===0)return o;const y=["# Referenced types (one level, names only; fetch a type or set includeReferencedTypes for full SDL):",...f.map(r=>`# ${r}`)].join(`
+`);return`${o}
+
+${y}`});var T={"get-graphql-type":h};export{T as default};

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/list-graphql-apis.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolHandler } from '../../../types.js';
+import type { ListGraphqlApisArgs } from './types.js';
+declare const _default: {
+    'list-graphql-apis': McpToolHandler<ListGraphqlApisArgs>;
+};
+export default _default;
+//# sourceMappingURL=list-graphql-apis.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/list-graphql-apis.js

@@ -0,0 +1 @@
+import{paginate as p,textResult as m}from"./tool-helpers.js";const c=async(r,l)=>{const{filter:i,page:o=1,limit:n=300}=r;let t=l.graphqlDescriptions;if(i){const e=i.toLowerCase();t=t.filter(s=>s.name.toLowerCase().includes(e))}const a=p(t,o,n);return m(JSON.stringify({...a,items:a.items.map(({name:e,description:s})=>({name:e,description:s}))}))};var g={"list-graphql-apis":c};export{g as default};

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/load-graphql-schema.d.ts

@@ -0,0 +1,7 @@
+import type { GraphQLSchema } from 'graphql';
+import type { McpToolContext } from '../../../types.js';
+export declare function loadGraphqlSchema(name: string, context: McpToolContext): Promise<{
+    name: string;
+    schema: GraphQLSchema;
+}>;
+//# sourceMappingURL=load-graphql-schema.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/load-graphql-schema.js

@@ -0,0 +1 @@
+import t from"node:path";import{existsSync as m}from"node:fs";import{readFile as h}from"node:fs/promises";import{buildSchema as e}from"graphql";import{PUBLIC_API_DEFINITIONS_FOLDER as n}from"../../../../../constants/common.js";import{findGraphqlSchemaByName as f}from"./utils.js";async function w(r,a){const o=f(a.graphqlDescriptions,r);if(!o)throw new Error(`No GraphQL schema found matching "${r}".`);const i=t.join(a.outdir||"",n,o.relativePath);if(!m(i))throw new Error(`No GraphQL schema found matching "${r}".`);return{name:o.name,schema:e(await h(i,"utf-8"))}}export{w as loadGraphqlSchema};

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/tool-helpers.d.ts

@@ -0,0 +1,14 @@
+import type { McpToolContext, McpToolWorkerResponse } from '../../../types.js';
+import { loadGraphqlSchema } from './load-graphql-schema.js';
+type LoadedGraphqlSchema = Awaited<ReturnType<typeof loadGraphqlSchema>>;
+export declare function textResult(text: string, isError?: boolean): McpToolWorkerResponse;
+export declare function respondWithGraphqlSchema(name: string, context: McpToolContext, render: (loaded: LoadedGraphqlSchema) => string): Promise<McpToolWorkerResponse>;
+export declare function paginate<T>(items: T[], page: number, limit: number): {
+    items: T[];
+    limit: number;
+    total: number;
+    page: number;
+    totalPages: number;
+};
+export {};
+//# sourceMappingURL=tool-helpers.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/tool-helpers.js

@@ -0,0 +1 @@
+import{loadGraphqlSchema as c}from"./load-graphql-schema.js";function o(t,e=!1){return{content:[{type:"text",text:t}],isError:e?!0:void 0}}async function u(t,e,r){try{return o(r(await c(t,e)))}catch(n){return o(n.message,!0)}}function h(t,e,r){const n=t.length,a=(e-1)*r;return{items:t.slice(a,a+r),limit:r,total:n,page:e,totalPages:Math.ceil(n/r)}}export{h as paginate,u as respondWithGraphqlSchema,o as textResult};

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/types.d.ts

@@ -0,0 +1,38 @@
+import type { GRAPHQL_LIST_SCOPES, GRAPHQL_TYPE_KINDS } from './constants.js';
+export type GraphqlTypeKind = (typeof GRAPHQL_TYPE_KINDS)[number];
+export type GraphqlListScope = (typeof GRAPHQL_LIST_SCOPES)[number];
+export type SchemaMember = {
+    name: string;
+    description?: string;
+    type?: string;
+    args?: string;
+    directives?: string;
+};
+export type SchemaMemberWithKind = SchemaMember & {
+    kind: GraphqlTypeKind;
+};
+export type GroupedSchemaTypes = Record<GraphqlTypeKind, SchemaMember[]>;
+export type ListGraphqlApisArgs = {
+    filter?: string;
+    page?: number;
+    limit?: number;
+};
+export type GetGraphqlTypeListArgs = {
+    name: string;
+    kind?: GraphqlTypeKind;
+    scope?: GraphqlListScope;
+    filter?: string;
+    referencesType?: string;
+    page?: number;
+    limit?: number;
+};
+export type GetGraphqlTypeArgs = {
+    name: string;
+    type?: string;
+    typeName?: string;
+    includeReferencedTypes?: boolean;
+};
+export type GetGraphqlSchemaArgs = {
+    name: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/utils.d.ts

@@ -0,0 +1,20 @@
+import type { GraphQLSchema } from 'graphql';
+import type { GraphqlDescriptionInfo } from '../../../types.js';
+import type { GraphqlTypeKind, GroupedSchemaTypes, SchemaMember, SchemaMemberWithKind } from './types.js';
+export declare function findGraphqlSchemaByName(graphqlDescriptions: GraphqlDescriptionInfo[], name: string): GraphqlDescriptionInfo | undefined;
+export declare function groupSchemaTypes(schema: GraphQLSchema): GroupedSchemaTypes;
+export declare function fieldMembers(schema: GraphQLSchema, kind?: GraphqlTypeKind): SchemaMemberWithKind[];
+/** Case-insensitive substring match against the member's name or description. */
+export declare function matchesFilter(member: SchemaMember, filter: string): boolean;
+export declare function filterMembersReferencingType<T extends {
+    kind: GraphqlTypeKind;
+    name: string;
+}>(schema: GraphQLSchema, members: T[], targetName: string): T[];
+export declare function referencedTypeClosure(schema: GraphQLSchema, name: string): string[];
+export declare function printTypeOrField(schema: GraphQLSchema, name: string): string;
+export declare function referencedTypeManifest(schema: GraphQLSchema, name: string): string[];
+export declare function printTypeOrFieldWithReferences(schema: GraphQLSchema, name: string): {
+    sdl: string;
+    referencedCount: number;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/graphql/utils.js

@@ -0,0 +1,5 @@
+import{getNamedType as u,isEnumType as j,isInputObjectType as d,isInterfaceType as p,isIntrospectionType as l,isObjectType as g,isScalarType as y,isSpecifiedScalarType as v,isUnionType as T,print as a,printType as L,specifiedDirectives as I}from"graphql";const D=new Set(["queries","mutations","subscriptions"]);function w(e){return e.toLowerCase().split(/[^a-z0-9_]+/).filter(Boolean)}function V(e,n){const t=n.toLowerCase(),r=e.find(s=>s.name.toLowerCase().includes(t));if(r)return r;const i=new Set(w(t));let o,f=0;for(const s of e){const c=w(s.name);c.length>f&&c.every(k=>i.has(k))&&(o=s,f=c.length)}return o}function m(e,n){return e.getQueryType()?.getFields()[n]??e.getMutationType()?.getFields()[n]??e.getSubscriptionType()?.getFields()[n]}function N(e){return[u(e.type).name,...(e.args??[]).map(n=>u(n.type).name)]}function S(e){const n=new Set;if(g(e)||p(e)){for(const t of Object.values(e.getFields())){n.add(u(t.type).name);for(const r of t.args)n.add(u(r.type).name)}for(const t of e.getInterfaces())n.add(t.name)}else if(T(e))for(const t of e.getTypes())n.add(t.name);else if(d(e))for(const t of Object.values(e.getFields()))n.add(u(t.type).name);return n}function O(e){return new Set([e.getQueryType(),e.getMutationType(),e.getSubscriptionType()].filter(n=>!!n).map(n=>n.name))}function A(e){const n=O(e),t={queries:b(e.getQueryType()),mutations:b(e.getMutationType()),subscriptions:b(e.getSubscriptionType()),objects:[],interfaces:[],unions:[],enums:[],inputs:[],scalars:[],directives:[]};for(const i of Object.values(e.getTypeMap())){if(l(i)||n.has(i.name))continue;const o=$(i);o&&t[o].push({name:i.name,description:i.description??void 0})}const r=new Set(I.map(i=>i.name));return t.directives=e.getDirectives().filter(i=>!r.has(i.name)).map(i=>({name:i.name,description:i.description??void 0})),t}function $(e){if(y(e))return v(e)?void 0:"scalars";if(g(e))return"objects";if(p(e))return"interfaces";if(T(e))return"unions";if(j(e))return"enums";if(d(e))return"inputs"}function F(e){return g(e)||p(e)||d(e)?e:void 0}function x(e){const n=e.astNode?.directives;return n?.length?n.map(t=>a(t)).join(" "):void 0}function b(e){return e?Object.values(e.getFields()).map(n=>({name:n.name,description:n.description??void 0,type:n.type.toString(),args:n.args.length?`(${n.args.map(t=>{const r=t.astNode?.defaultValue?` = ${a(t.astNode.defaultValue)}`:"";return`${t.name}: ${t.type}${r}`}).join(", ")})`:void 0,directives:x(n)})):[]}function G(e,n){const t=O(e),r=[];for(const i of Object.values(e.getTypeMap())){if(l(i)||t.has(i.name))continue;const o=F(i);if(!o)continue;const f=$(o);if(!(!f||n&&n!==f))for(const s of Object.values(o.getFields()))r.push({kind:f,name:`${o.name}.${s.name}`,description:s.description??void 0,type:s.type.toString(),directives:x(s)})}return r}function K(e,n){const t=n.toLowerCase();return e.name.toLowerCase().includes(t)||(e.description?.toLowerCase().includes(t)??!1)}function R(e,n){const t=n.indexOf(".");return t===-1?void 0:F(e.getType(n.slice(0,t)))?.getFields()[n.slice(t+1)]}function _(e,n,t){const r=B(e,t);if(!r)return[];const i=new Set([r,...q(e,r)]);return n.filter(o=>{if(o.name.includes(".")){const s=R(e,o.name);return s?N(s).some(c=>i.has(c)):!1}if(!D.has(o.kind))return i.has(o.name);const f=m(e,o.name);return f?N(f).some(s=>i.has(s)):!1})}function z(e,n){const t=new Set,r=[...M(e,n)];for(let i=0;i<r.length;i+=1){const o=r[i];if(t.has(o))continue;t.add(o);const f=e.getType(o);if(f)for(const s of S(f))t.has(s)||r.push(s)}return[...t].filter(i=>i!==n&&h(e,i))}function M(e,n){const t=e.getType(n);if(t)return S(t);const r=m(e,n);if(r)return new Set(N(r));const i=e.getDirective(n);return i?new Set(i.args.map(o=>u(o.type).name)):new Set}function q(e,n){const t=new Map;for(const o of Object.values(e.getTypeMap()))if(!l(o))for(const f of S(o)){let s=t.get(f);s||(s=new Set,t.set(f,s)),s.add(o.name)}const r=new Set,i=[n];for(let o=0;o<i.length;o+=1)for(const f of t.get(i[o])??[])r.has(f)||(r.add(f),i.push(f));return r}function B(e,n){const t=n.toLowerCase();return Object.keys(e.getTypeMap()).find(r=>r.toLowerCase()===t)}function h(e,n){const t=e.getType(n);return!t||l(t)?!1:!(y(t)&&v(t))}function C(e){return e.astNode?[e.astNode,...e.extensionASTNodes??[]].map(n=>a(n)).join(`
+
+`):L(e)}function Q(e,n){const t=e.getType(n);if(t)return C(t);const r=m(e,n);if(r?.astNode)return a(r.astNode);const i=e.getDirective(n);if(i?.astNode)return a(i.astNode);throw new Error(`No GraphQL type, operation, or directive named "${n}" found.`)}function P(e,n){const t=[];for(const r of M(e,n)){if(r===n||!h(e,r))continue;const i=e.getType(r);g(i)?t.push(`type ${r} { ${Object.keys(i.getFields()).join(", ")} }`):p(i)?t.push(`interface ${r} { ${Object.keys(i.getFields()).join(", ")} }`):d(i)?t.push(`input ${r} { ${Object.keys(i.getFields()).join(", ")} }`):j(i)?t.push(`enum ${r} { ${i.getValues().map(o=>o.name).join(", ")} }`):T(i)?t.push(`union ${r} = ${i.getTypes().map(o=>o.name).join(" | ")}`):y(i)&&t.push(`scalar ${r}`)}return t}function U(e,n){const t=Q(e,n),r=z(e,n).map(i=>e.getType(i)).filter(i=>!!i).map(i=>C(i));return{sdl:[t,...r].join(`
+
+`),referencedCount:r.length}}export{G as fieldMembers,_ as filterMembersReferencingType,V as findGraphqlSchemaByName,A as groupSchemaTypes,K as matchesFilter,Q as printTypeOrField,U as printTypeOrFieldWithReferences,z as referencedTypeClosure,P as referencedTypeManifest};

package/dist/server/plugins/mcp/docs-mcp/tools/index.d.ts

@@ -0,0 +1,20 @@
+declare const _default: {
+    createAnonymousSession: {
+        execute: import("../../types.js").McpToolHandler<import("./core/create-anonymous-session.js").CreateAnonymousSessionArgs>;
+        isAvailable: typeof import("./core/create-anonymous-session.js").isAnonymousSessionToolAvailable;
+    };
+    'list-apis': import("../../types.js").McpToolHandler<import("./openapi/types.js").ListApisArgs>;
+    'get-endpoints': import("../../types.js").McpToolHandler<import("./openapi/types.js").ApiNameVersionArgs>;
+    'get-endpoint-info': import("../../types.js").McpToolHandler<import("./openapi/types.js").GetEndpointInfoArgs>;
+    'get-security-schemes': import("../../types.js").McpToolHandler<import("./openapi/types.js").ApiNameVersionArgs>;
+    'get-full-api-description': import("../../types.js").McpToolHandler<import("./openapi/types.js").ApiNameVersionArgs>;
+    search: import("../../types.js").McpToolHandler<import("./core/types.js").SearchArgs>;
+    whoami: import("../../types.js").McpToolHandler<import("./core/types.js").WhoamiArgs>;
+    "submit-feedback": import("../../types.js").McpToolHandler<import("./core/types.js").SubmitFeedbackArgs>;
+    'list-graphql-apis': import("../../types.js").McpToolHandler<import("./graphql/types.js").ListGraphqlApisArgs>;
+    'get-graphql-type-list': import("../../types.js").McpToolHandler<import("./graphql/types.js").GetGraphqlTypeListArgs>;
+    'get-graphql-type': import("../../types.js").McpToolHandler<import("./graphql/types.js").GetGraphqlTypeArgs>;
+    'get-graphql-schema': import("../../types.js").McpToolHandler<import("./graphql/types.js").GetGraphqlSchemaArgs>;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/index.js

@@ -0,0 +1 @@
+import o from"./openapi/list-apis.js";import r from"./openapi/get-endpoints.js";import m from"./openapi/get-endpoint-info.js";import t from"./openapi/get-security-schemes.js";import i from"./openapi/get-full-api-description.js";import p from"./core/search.js";import e from"./core/whoami.js";import f from"./core/create-anonymous-session.js";import s from"./core/submit-feedback.js";import a from"./graphql/list-graphql-apis.js";import l from"./graphql/get-graphql-type-list.js";import n from"./graphql/get-graphql-type.js";import h from"./graphql/get-graphql-schema.js";var k={...o,...r,...m,...t,...i,...p,...e,...f,...s,...a,...l,...n,...h};export{k as default};

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const OPERATION_METHODS: readonly ['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace', 'query', 'x-query'];
+export declare const HTTP_METHODS: Set<string>;
+export declare const MAX_ENDPOINT_INFO_BYTES: number;
+export declare const MAX_INLINED_ENDPOINT_BYTES: number;
+//# sourceMappingURL=constants.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/constants.js

@@ -0,0 +1 @@
+const t=["get","put","post","delete","options","head","patch","trace","query","x-query"],e=new Set(t),o=8*1024*1024,T=1024*1024;export{e as HTTP_METHODS,o as MAX_ENDPOINT_INFO_BYTES,T as MAX_INLINED_ENDPOINT_BYTES,t as OPERATION_METHODS};

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/endpoint-suggestions.d.ts

@@ -0,0 +1,17 @@
+import type { OpenAPIDefinition } from '@redocly/api-docs';
+import type { McpMode } from '../../../types.js';
+/** Methods documented and visible at `path`, uppercased. */
+export declare function visibleMethodsAt(definition: OpenAPIDefinition, path: string): string[];
+/** Paths with at least one visible operation. */
+export declare function visiblePaths(definition: OpenAPIDefinition): string[];
+/** The tools that recover a lookup miss. The sandbox calls the same tools by their JS names. */
+export declare function recoveryToolNames(mcpMode?: McpMode): {
+    endpoints: string;
+    search: string;
+    listApis: string;
+};
+/** Message for a path the definition does not document, or documents only behind `x-mcp`. */
+export declare function describePathMiss(definition: OpenAPIDefinition, apiTitle: string, path: string, mcpMode?: McpMode): string;
+/** Message for a visible path that does not document the requested method, or hides it. */
+export declare function describeMethodMiss(definition: OpenAPIDefinition, apiTitle: string, path: string, method: string): string;
+//# sourceMappingURL=endpoint-suggestions.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/endpoint-suggestions.js

@@ -0,0 +1 @@
+import{formatCandidates as r}from"../../utils/api-name-matching.js";import{visibleOperations as l}from"./utils.js";function i(t,e){return l(t.paths?.[e]).map(([o])=>o.toUpperCase()).sort()}function h(t){return Object.keys(t.paths??{}).filter(e=>i(t,e).length>0).sort()}function c(t){return t==="code"?{endpoints:"tools.getEndpoints",search:"tools.search",listApis:"tools.listApis"}:{endpoints:"get-endpoints",search:"search",listApis:"list-apis"}}function f(t,e,o,n){const s=h(t);if(s.length===0)return"Endpoint not found";const{endpoints:p,search:a}=c(n);return`No path "${o}" in "${e}". Documented paths: ${r(s)}. Call ${p} for the full list, or ${a} with a keyword from the request.`}function m(t,e,o,n){const s=i(t,o);return s.length===0?"Endpoint not found":`"${o}" in "${e}" documents no ${n.toUpperCase()}. Available methods: ${r(s)}.`}export{m as describeMethodMiss,f as describePathMiss,c as recoveryToolNames,i as visibleMethodsAt,h as visiblePaths};

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/get-endpoint-info.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolHandler } from '../../../types.js';
+import type { GetEndpointInfoArgs } from './types.js';
+declare const _default: {
+    'get-endpoint-info': McpToolHandler<GetEndpointInfoArgs>;
+};
+export default _default;
+//# sourceMappingURL=get-endpoint-info.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/get-endpoint-info.js

@@ -0,0 +1 @@
+import{inlineOperation as N,resolveOperation as O}from"../../utils/resolve-refs.js";import{matchDocumentedPath as b,visibleOperations as I}from"./utils.js";import{MAX_ENDPOINT_INFO_BYTES as x,MAX_INLINED_ENDPOINT_BYTES as T}from"./constants.js";import{describeMethodMiss as _,describePathMiss as S}from"./endpoint-suggestions.js";import{loadApiDescription as $}from"./load-api-description.js";const D=async(c,n)=>{const{path:h,method:e}=c;if(!h||!e)return{content:[{type:"text",text:'Both "path" and "method" are required (e.g. path: "/tickets", method: "GET").'}],isError:!0};let m;try{m=await $(c,n)}catch(r){return{content:[{type:"text",text:r.message}],isError:!0}}const{description:t,filePath:E,otherMatches:i}=m,d=i?` Other definitions share this title: ${i.map(r=>`"${r.filePath}"`).join(", ")}. Pass "filePath" to check them.`:"",o=b(t,h),{title:s=""}=t.info||{},a=t.paths?.[o],l=I(a);if(!a||l.length===0)return{content:[{type:"text",text:S(t,s,o,n.mcpMode)+d}],isError:!0};const f=l.find(([r])=>r.toLowerCase()===e.toLowerCase())?.[1];if(!f)return{content:[{type:"text",text:_(t,s,o,e)+d}],isError:!0};const{"x-mcp":C,...P}=f,v=a?.parameters||[],u={operation:P,pathParams:v,definition:t},M=n.mcpMode==="code"?N(u,T):void 0,{operation:g,components:y}=M??O(u),p=JSON.stringify({api:s,version:t.info?.version||"",filePath:E,otherMatches:i,servers:t.servers||[],endpoint:{path:o,method:e.toUpperCase(),...g},globalSecurity:t.security||[],securitySchemes:t.components?.securitySchemes||{},...y?{components:y}:{}},null,2);return p.length>x?{content:[{type:"text",text:`${e.toUpperCase()} ${o} is ${p.length} bytes, over the ${x} byte limit.`}],isError:!0}:{content:[{type:"text",text:p}]}};var U={"get-endpoint-info":D};export{U as default};

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/get-endpoints.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolHandler } from '../../../types.js';
+import type { ApiNameVersionArgs } from './types.js';
+declare const _default: {
+    'get-endpoints': McpToolHandler<ApiNameVersionArgs>;
+};
+export default _default;
+//# sourceMappingURL=get-endpoints.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/get-endpoints.js

@@ -0,0 +1 @@
+import{loadApiDescription as a}from"./load-api-description.js";import{getEndpointsFromPaths as c}from"./utils.js";const d=async(r,n)=>{let e;try{e=await a(r,n)}catch(p){return{content:[{type:"text",text:p.message}],isError:!0}}const{description:t,filePath:o,otherMatches:i}=e,s=c(t);return{content:[{type:"text",text:JSON.stringify({api:t.info?.title||"",version:t.info?.version||"",filePath:o,otherMatches:i,servers:t.servers||[],endpoints:s},null,2)}]}};var m={"get-endpoints":d};export{m as default};

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/get-full-api-description.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolHandler } from '../../../types.js';
+import type { ApiNameVersionArgs } from './types.js';
+declare const _default: {
+    'get-full-api-description': McpToolHandler<ApiNameVersionArgs>;
+};
+export default _default;
+//# sourceMappingURL=get-full-api-description.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/get-full-api-description.js

@@ -0,0 +1 @@
+import{loadApiDescription as a}from"./load-api-description.js";const c=async(i,r)=>{let e;try{e=await a(i,r)}catch(s){return{content:[{type:"text",text:s.message}],isError:!0}}const{description:t,filePath:n,otherMatches:o}=e;return{content:[{type:"text",text:JSON.stringify({api:t.info?.title||"",version:t.info?.version||"",filePath:n,otherMatches:o,definition:t},null,2)}]}};var p={"get-full-api-description":c};export{p as default};

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/get-security-schemes.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolHandler } from '../../../types.js';
+import type { ApiNameVersionArgs } from './types.js';
+declare const _default: {
+    'get-security-schemes': McpToolHandler<ApiNameVersionArgs>;
+};
+export default _default;
+//# sourceMappingURL=get-security-schemes.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/get-security-schemes.js

@@ -0,0 +1 @@
+import{loadApiDescription as n}from"./load-api-description.js";const a=async(r,i)=>{let t;try{t=await n(r,i)}catch(o){return{content:[{type:"text",text:o.message}],isError:!0}}const{description:e,filePath:s,otherMatches:c}=t;return{content:[{type:"text",text:JSON.stringify({api:e.info?.title||"",version:e.info?.version||"",filePath:s,otherMatches:c,securitySchemes:e.components?.securitySchemes||{},security:e.security||[]},null,2)}]}};var y={"get-security-schemes":a};export{y as default};

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/list-apis.d.ts

@@ -0,0 +1,7 @@
+import type { McpToolHandler } from '../../../types.js';
+import type { ListApisArgs } from './types.js';
+declare const _default: {
+    'list-apis': McpToolHandler<ListApisArgs>;
+};
+export default _default;
+//# sourceMappingURL=list-apis.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/list-apis.js

@@ -0,0 +1 @@
+import{getCallableApis as b}from"../../../gateway-mcp/callable-apis.js";import{filterApiDescriptionsByName as d}from"../../utils/api-name-matching.js";import{apiTitleKey as y,countApiTitles as A,orderSharedTitles as T}from"../../utils/api-titles.js";const x=async(r,l)=>{const{filter:s,page:a=1,limit:e=300}=r,n=new Set(b(l).map(i=>i.relativePath)),m=n.size>0,o=T(Object.values(l.apiDescriptionsMap)),f=A(o);let t=o;s&&(t=d(t,s));const c=(a-1)*e,u=c+e,g=Math.ceil(t.length/e),h=t.length;return t=t.slice(c,u),{content:[{type:"text",text:JSON.stringify({items:t.map(({relativePath:i,fetchEligible:D,...p})=>({filePath:i,...p,...(f.get(y(p.name))??0)>1?{ambiguousTitle:!0}:{},...m?{callable:n.has(i)}:{}})),limit:e,total:h,page:a,totalPages:g})}]}};var I={"list-apis":x};export{I as default};

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/load-api-description.d.ts

@@ -0,0 +1,24 @@
+import type { OpenAPIDefinition } from '@redocly/api-docs';
+import type { McpToolContext } from '../../../types.js';
+type ApiDescriptionRef = {
+    version?: string;
+    filePath: string;
+};
+type LoadedApiDescription = {
+    description: OpenAPIDefinition;
+    filePath: string;
+    otherMatches?: ApiDescriptionRef[];
+};
+type ApiLookup = {
+    name?: string;
+    version?: string;
+    filePath?: string;
+    path?: string;
+    method?: string;
+};
+export declare function loadApiDescription(args: ApiLookup & {
+    apiName?: string;
+    api?: string;
+}, context: McpToolContext): Promise<LoadedApiDescription>;
+export {};
+//# sourceMappingURL=load-api-description.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/load-api-description.js

@@ -0,0 +1 @@
+import{describeAvailableApis as l,findApiDescriptionByNameAndVersion as b,formatCandidates as d}from"../../utils/api-name-matching.js";import{apiTitleKey as A,compareApiDescriptions as P}from"../../utils/api-titles.js";import{recoveryToolNames as f,visibleMethodsAt as g}from"./endpoint-suggestions.js";import{absolutePath as u,getApiDescriptionFromFs as I,matchDocumentedPath as M}from"./utils.js";function m(i){return`Pass \`name\` (the API title, or a unique part of it) or \`filePath\` from ${f(i).listApis}.`}const D=10;function N({name:i,version:e,filePath:n},t){const o=Object.values(t);if(n)return o.filter(a=>a.relativePath===n);const r=o.find(a=>a.relativePath===i);if(r)return[r];const s=b(t,i??"",e);return s?[s.description,...s.otherMatches??[]]:[]}function w({version:i,relativePath:e}){return{...i?{version:i}:{},filePath:e}}function h({relativePath:i},e){return I({relativePath:i,outdir:e.outdir||"",user:e.user,rbac:e?.config?.access?.rbac||{},requiresLogin:!!e?.config?.access?.requiresLogin})}async function S(i,e){const{version:n,filePath:t}=i,o=i.name??i.apiName??i.api;if(!t&&!o)return y(i,e);const r=N({name:o,version:n,filePath:t},e.apiDescriptionsMap);return F(r,{name:o,filePath:t},e)}async function y({path:i,method:e,version:n},t){const o=Object.values(t.apiDescriptionsMap);if(o.length===0)throw new Error("This project documents no OpenAPI description.");if(o.length===1){const[p]=o;if(n&&p.version!==n)throw new Error(`"${p.name}" has no version "${n}". Available versions: ${p.version||"(no version)"}.`);const $=await h(p,t);if(!$)throw new Error(`Could not read the API definition "${p.relativePath}". ${m(t.mcpMode)}`);return{description:$,filePath:p.relativePath}}if(!i||!e||o.length>D)throw new Error(`${m(t.mcpMode)} Available APIs: ${l(t.apiDescriptionsMap,"")}.`);const r=await k(o,i,e,t),{documenting:s,otherMethods:a}=r;if(s.length===0)throw C(t,a,i,e);if(!n)return v(s,r.best,i,e,t);const c=s.filter(p=>p.version===n);if(c.length===0)throw j(s,i,n);return v(c,r.best,i,e,t)}async function v(i,e,n,t,o){const r=new Set(i.map(({name:p})=>A(p)));if(r.size>1)throw E(i,r,n,t,o.mcpMode);const[s,...a]=i,c=s===e?.api?e.description:await h(s,o);if(!c)throw new Error(`Could not read the API definition "${s.relativePath}". ${m(o.mcpMode)}`);return{description:c,filePath:s.relativePath,otherMatches:a.length>0?a.map(w):void 0}}function E(i,e,n,t,o){const r=[...e].map(s=>{const[a]=i.filter(c=>A(c.name)===s);return`"${a.name}" (${a.relativePath})`});return new Error(`${t.toUpperCase()} ${u(n)} is documented by ${e.size} APIs: ${d(r)}. Pass \`name\` or \`filePath\` from ${f(o).listApis} to pick one.`)}function C(i,e,n,t){if(e.length>0){const s=e.map(({api:a,methods:c})=>`"${a.name}" (${a.relativePath}) documents ${d(c)}.`).join(" ");return new Error(`No API documents ${t.toUpperCase()} ${u(n)}. ${s}`)}const{endpoints:o,search:r}=f(i.mcpMode);return new Error(`No API in this project documents ${u(n)}. Available APIs: ${l(i.apiDescriptionsMap,"")}. Call ${o} with one of them, or ${r} with a keyword from the request.`)}function j(i,e,n){const t=[...new Set(i.map(({version:o})=>o||"(no version)"))];return new Error(`No API documenting "${u(e)}" has version "${n}". Available versions: ${d(t)}.`)}async function k(i,e,n,t){const o=[],r=[];let s;for(const a of i){const c=await h(a,t);if(!c)continue;const p=g(c,M(c,e));p.includes(n.toUpperCase())?(o.push(a),(!s||P(a,s.api)<0)&&(s={api:a,description:c})):p.length>0&&r.push({api:a,methods:p})}return{documenting:o.sort(P),best:s,otherMethods:r}}async function F(i,{name:e,filePath:n},t){if(i.length===0){if(n)throw new Error(`No API found with filePath "${n}". File paths are returned by the ${f(t.mcpMode).listApis} tool.`);const r=l(t.apiDescriptionsMap,e??"");throw new Error(r?`No API found matching "${e}". Available APIs: ${r}.`:`No API found matching "${e}".`)}for(const r of i){const s=await h(r,t);if(!s)continue;const a=i.filter(c=>c!==r);return{description:s,filePath:r.relativePath,otherMatches:a.length>0?a.map(w):void 0}}const o=i.map(({relativePath:r})=>`"${r}"`).join(", ");throw new Error(i.length>1?`No API found matching "${n||e}". None of the matching definitions could be loaded: ${o}.`:`No API found matching "${n||e}".`)}export{S as loadApiDescription};

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/types.d.ts

@@ -0,0 +1,22 @@
+export type ListApisArgs = {
+    filter?: string;
+    page?: number;
+    limit?: number;
+};
+export type ApiNameVersionArgs = {
+    name?: string;
+    apiName?: string;
+    api?: string;
+    version?: string;
+    filePath?: string;
+};
+export type GetEndpointInfoArgs = {
+    name?: string;
+    apiName?: string;
+    api?: string;
+    path: string;
+    method: string;
+    version?: string;
+    filePath?: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/utils.d.ts

@@ -0,0 +1,31 @@
+import type { OpenAPIDefinition, OpenAPIOperation } from '@redocly/api-docs';
+import type { ApiFunctionsUser, RbacConfig } from '@redocly/config';
+import type { McpEndpoint, McpPath } from '../../../types';
+/** The operations of `pathItem` that `x-mcp` does not hide, keyed as the definition keys them. */
+export declare function visibleOperations(pathItem: McpPath | undefined): [string, McpEndpoint][];
+type EndpointInfo = Pick<OpenAPIOperation, 'summary' | 'description' | 'security'> & {
+    method: string;
+    path: string;
+};
+export declare function getEndpointsFromPaths(def: OpenAPIDefinition): EndpointInfo[];
+type ApiDescriptionAccess = {
+    user: ApiFunctionsUser;
+    rbac?: RbacConfig;
+    requiresLogin?: boolean;
+};
+export declare function getApiDescriptionFromFs({ relativePath, outdir, ...access }: ApiDescriptionAccess & {
+    relativePath: string;
+    outdir: string;
+}): Promise<OpenAPIDefinition | undefined>;
+/** The bundled description with no RBAC filtering; never return it to a caller. */
+export declare function readApiDescriptionFromFs(relativePath: string, outdir: string): Promise<OpenAPIDefinition | undefined>;
+/**
+ * A filtered copy of `definition` holding only what the user can read, or undefined when the user
+ * can read none of it; the input is not mutated.
+ */
+export declare function filterApiDescriptionByAccess(definition: OpenAPIDefinition, { user, rbac, requiresLogin }: ApiDescriptionAccess): OpenAPIDefinition | undefined;
+export declare function absolutePath(requestedPath: string): string;
+/** Models copy a path and lose its casing; the definition's own spelling still answers. */
+export declare function matchDocumentedPath(description: OpenAPIDefinition, requestedPath: string): string;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/tools/openapi/utils.js

@@ -0,0 +1 @@
+import a from"node:path";import{existsSync as p}from"node:fs";import{readFile as m}from"node:fs/promises";import{replaceFileExtension as f}from"../../../../../plugins/api-docs/utils/replace-file-extension.js";import{PUBLIC_API_DEFINITIONS_FOLDER as u}from"../../../../../constants/common.js";import{filterDataByAccessDeep as d}from"../../../../../utils/rbac.js";import{isEndpointHidden as c}from"../../../utils/xmcp-utils.js";import{HTTP_METHODS as h}from"./constants.js";function l(t){return!t||c(t,"docs")?[]:Object.entries(t).filter(o=>{const[e,r]=o;return h.has(e.toLowerCase())&&typeof r=="object"&&r!==null&&!c(r,"docs")})}function L(t){const{paths:o={}}=t,e=[];for(const[r,s]of Object.entries(o))for(const[n,i]of l(s))e.push({path:r,method:n.toUpperCase(),summary:i.summary,description:i.description,security:i.security});return e}async function P({relativePath:t,outdir:o,...e}){const r=await y(t,o);return r&&x(r,e)}async function y(t,o){const e=a.join(o||"",u,f(t,".json"));if(p(e))return JSON.parse(await m(e,"utf-8"))}function x(t,{user:o,rbac:e={},requiresLogin:r=!1}){return d(t,{isAuthenticated:o?.isAuthenticated,email:o?.email,teams:o?.teams},e,r)}function D(t){return t.startsWith("/")?t:`/${t}`}function I(t,o){const e=D(o);if(t.paths?.[e])return e;const r=e.toLowerCase();return Object.keys(t.paths??{}).find(n=>n.toLowerCase()===r)??e}export{D as absolutePath,x as filterApiDescriptionByAccess,P as getApiDescriptionFromFs,L as getEndpointsFromPaths,I as matchDocumentedPath,y as readApiDescriptionFromFs,l as visibleOperations};

package/dist/server/plugins/mcp/docs-mcp/utils/api-name-matching.d.ts

@@ -0,0 +1,13 @@
+import type { ApiDescriptionInfo } from '../../types.js';
+export declare const MAX_LISTED_CANDIDATES = 15;
+export type ApiDescriptionMatch = {
+    description: ApiDescriptionInfo;
+    /** The other definitions the lookup matched, absent when it matched exactly one. */
+    otherMatches?: ApiDescriptionInfo[];
+};
+export declare function formatCandidates(items: string[]): string;
+/** Every API name in the catalog, closest to `name` first. Used to make a miss recoverable. */
+export declare function describeAvailableApis(apiDescriptionsMap: Record<string, ApiDescriptionInfo>, name: string): string;
+export declare function findApiDescriptionByNameAndVersion(apiDescriptionsMap: Record<string, ApiDescriptionInfo>, name: string, version?: string): ApiDescriptionMatch | undefined;
+export declare function filterApiDescriptionsByName(apiDescriptions: ApiDescriptionInfo[], filter: string): ApiDescriptionInfo[];
+//# sourceMappingURL=api-name-matching.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/utils/api-name-matching.js

@@ -0,0 +1 @@
+import{apiTitleKey as u,compareApiDescriptions as h}from"./api-titles.js";const T=15,d=new Set(["api","apis","rest","restful","openapi","graphql","spec","specification","service","services"]);function g(r){return r.toLowerCase().split(/[^a-z0-9_]+/).filter(Boolean)}function f(r){return new Set(g(r).filter(n=>!d.has(n)))}function w(r,n){return r.size===n.size&&[...r].every(e=>n.has(e))}function m(r){const n=r.slice(0,T),e=r.length-n.length;return e>0?`${n.join(", ")} (+${e} more)`:n.join(", ")}function x(r,n){const e=f(n);return[...new Set(r.map(t=>t.name))].map(t=>({name:t,score:[...f(t)].filter(s=>e.has(s)).length})).sort((t,s)=>s.score-t.score||t.name.localeCompare(s.name)).map(({name:t})=>t)}function E(r,n){const e=Object.values(r);return e.length===0?"":m(x(e,n).map(t=>`"${t}"`))}function A(r,n){const e=u(n);if(!e)return{matches:[],isExactTitle:!1};const t=r.map(o=>({api:o,title:u(o.name)})),s=o=>o.map(({api:l})=>l),c=t.filter(({title:o})=>o===e);if(c.length>0)return{matches:s(c),isExactTitle:!0};const i=t.filter(({title:o})=>o.includes(e));if(i.length>0)return{matches:s(i),isExactTitle:!1};const a=f(e);if(a.size===0)return{matches:[],isExactTitle:!1};const p=t.filter(({title:o})=>{const l=f(o);return l.size>0&&w(l,a)});return{matches:s(p),isExactTitle:!1}}function k(r){const[n,...e]=[...r].sort(h);return e.length===0?{description:n}:{description:n,otherMatches:e}}function S(r,n,e){if(!n)return;const{matches:t,isExactTitle:s}=A(Object.values(r),n);if(t.length===0)return;if(!s){const i=[...new Set(t.map(({name:a})=>a))];if(i.length>1)throw new Error(`"${n}" matches ${i.length} APIs: ${m(i.map(a=>`"${a}"`))}. Pass one of those names exactly, or the "filePath" parameter from list-apis.`)}const c=e?t.filter(i=>i.version===e):t;if(c.length===0){const i=[...new Set(t.map(({version:a})=>a||"(no version)"))];throw new Error(`"${t[0].name||n}" has no version "${e}". Available versions: ${m(i)}.`)}return k(c)}function $(r,n){const e=n.trim().toLowerCase();if(!e)return r;const t=r.filter(({name:s})=>s.toLowerCase().includes(e));return t.length>0?t:r.filter(({description:s})=>!!s?.toLowerCase().includes(e))}export{T as MAX_LISTED_CANDIDATES,E as describeAvailableApis,$ as filterApiDescriptionsByName,S as findApiDescriptionByNameAndVersion,m as formatCandidates};

package/dist/server/plugins/mcp/docs-mcp/utils/api-titles.d.ts

@@ -0,0 +1,14 @@
+import type { ApiDescriptionInfo } from '../../types.js';
+/** The form the API lookup compares titles in, so a collision here is a collision there. */
+export declare function apiTitleKey(name: string): string;
+/** How many APIs carry each title, keyed by `apiTitleKey`, so a shared title is detectable. */
+export declare function countApiTitles(apis: ApiDescriptionInfo[]): Map<string, number>;
+/** The highest version, then the shortest path, so the same catalog always yields the same pick. */
+export declare function compareApiDescriptions(a: ApiDescriptionInfo, b: ApiDescriptionInfo): number;
+/**
+ * Orders the APIs that share a title the way a name lookup picks, so code that takes the first
+ * matching item gets the same definition. Each title keeps the positions it already occupied,
+ * so no other API moves.
+ */
+export declare function orderSharedTitles(apis: ApiDescriptionInfo[]): ApiDescriptionInfo[];
+//# sourceMappingURL=api-titles.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/utils/api-titles.js

@@ -0,0 +1 @@
+import c from"semver";import{compareVersions as p}from"../../../../../utils/version/compare-versions.js";function a(e){return e.trim().toLowerCase()}function h(e){const t=new Map;for(const{name:n}of e){const o=a(n);t.set(o,(t.get(o)??0)+1)}return t}function l(e,t){return c.valid(e)&&c.valid(t)?c.rcompare(e,t):p(t,e)}function f(e,t){return l(e.version||"",t.version||"")||e.relativePath.length-t.relativePath.length||e.relativePath.localeCompare(t.relativePath)}function v(e){const t=new Map;e.forEach((o,i)=>{const r=a(o.name),s=t.get(r);s?s.push(i):t.set(r,[i])});const n=[...e];for(const o of t.values()){if(o.length===1)continue;const i=o.map(r=>e[r]).sort(f);o.forEach((r,s)=>{n[r]=i[s]})}return n}export{a as apiTitleKey,f as compareApiDescriptions,h as countApiTitles,v as orderSharedTitles};

package/dist/server/plugins/mcp/docs-mcp/utils/resolve-refs.d.ts

@@ -0,0 +1,26 @@
+import type { OpenAPIParameter, Referenced, OpenAPIDefinition } from '@redocly/api-docs';
+import type { McpEndpoint } from '../../types.js';
+import { resolveRef } from '@redocly/api-docs/lib/utils/inline-openapi-refs.js';
+export { resolveRef };
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type ResolvedOperation = {
+    operation: JsonObject;
+    components?: Record<string, JsonObject>;
+};
+type ResolveOperationParams = {
+    operation: McpEndpoint;
+    pathParams: Referenced<OpenAPIParameter>[];
+    definition: OpenAPIDefinition;
+};
+export declare function resolveOperation({ operation, pathParams, definition, }: ResolveOperationParams): ResolvedOperation;
+/**
+ * The operation with every `$ref` it follows inlined, or undefined when the followed targets pass
+ * `maxBytes` or the inliner cannot read the operation.
+ */
+export declare function inlineOperation({ operation, pathParams, definition }: ResolveOperationParams, maxBytes: number): ResolvedOperation | undefined;
+//# sourceMappingURL=resolve-refs.d.ts.map

package/dist/server/plugins/mcp/docs-mcp/utils/resolve-refs.js

@@ -0,0 +1 @@
+import{resolveParameters as y,resolveRef as p,resolveRequestBody as g,resolveResponses as m,unescapeJsonPointerToken as $}from"@redocly/api-docs/lib/utils/inline-openapi-refs.js";const h=/^#\/components\/([^/]+)\/([^/]+)(\/.*)?$/;function d(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}function l(e,o){const n={},s=new Set,t=new Set,r=[e];for(;r.length>0;){const c=r.pop();if(!(c===null||typeof c!="object")){if(d(c)&&typeof c.$ref=="string"&&!s.has(c.$ref)){s.add(c.$ref);const[,f,i]=h.exec(c.$ref)??[],u=i&&$(i);if(f&&u&&!t.has(`${f}/${u}`)){const a=p(`#/components/${f}/${i}`,o);a!==void 0&&(t.add(`${f}/${u}`),(n[f]??={})[u]=a,r.push(a))}}for(const f of Object.values(c))r.push(f)}}return Object.keys(n).length>0?n:void 0}function b(e,o){const n=d(e)&&typeof e.$ref=="string"?p(e.$ref,o)??e:e,{name:s,in:t}=d(n)?n:{};return typeof s=="string"&&typeof t=="string"?`${t}:${s}`:JSON.stringify(e)}function O(e,o,n){const s=new Map;for(const t of[...e,...o])t&&s.set(b(t,n),t);return[...s.values()]}function x({operation:e,pathParams:o,definition:n}){const s={...e,parameters:O(o,e.parameters??[],n)};return{operation:s,components:l(s,n)}}class w extends Error{}function B(e){let o=e;const n=new Map;return(s,t)=>{let r=t===void 0?void 0:n.get(t);if(r===void 0&&(r=JSON.stringify(s).length,t!==void 0&&n.set(t,r)),o-=r,o<0)throw new w}}function R({operation:e,pathParams:o,definition:n},s){const t=B(s);try{const r={...e,parameters:y({pathParams:o,opParams:e.parameters||[],definition:n,charge:t}),requestBody:g(e.requestBody,n,t),responses:e.responses&&m(e.responses,n,t)};return{operation:r,components:l(r,n)}}catch{return}}export{R as inlineOperation,x as resolveOperation,p as resolveRef};

package/dist/server/plugins/mcp/gateway-mcp/allowed-http-methods.d.ts

@@ -0,0 +1,11 @@
+import type { RedoclyConfig } from '@redocly/config';
+export type ApiCallsConfig = NonNullable<NonNullable<RedoclyConfig['mcp']>['apiCalls']>;
+type ApiCallsHttpMethod = NonNullable<ApiCallsConfig['allowedHttpMethods']>[number];
+/** The methods agents may send when `mcp.apiCalls.allowedHttpMethods` is not set. */
+export declare const DEFAULT_ALLOWED_HTTP_METHODS: readonly ApiCallsHttpMethod[];
+/** Upper-case HTTP methods agents may send; read-only unless `redocly.yaml` allows more. */
+export declare function getAllowedHttpMethods(mcp: RedoclyConfig['mcp'] | undefined): string[];
+/** Whether every allowed method is safe by HTTP semantics (`GET`, `HEAD`, `OPTIONS`). */
+export declare function allowsOnlySafeHttpMethods(mcp: RedoclyConfig['mcp'] | undefined): boolean;
+export {};
+//# sourceMappingURL=allowed-http-methods.d.ts.map

package/dist/server/plugins/mcp/gateway-mcp/allowed-http-methods.js

@@ -0,0 +1 @@
+const o=["GET","HEAD","OPTIONS"],r={GET:!0,HEAD:!0,OPTIONS:!0};function T(t){return(t?.apiCalls?.allowedHttpMethods??o).map(e=>e.toUpperCase())}function p(t){return T(t).every(e=>r[e])}export{o as DEFAULT_ALLOWED_HTTP_METHODS,p as allowsOnlySafeHttpMethods,T as getAllowedHttpMethods};

package/dist/server/plugins/mcp/gateway-mcp/api-call-operations.d.ts

@@ -0,0 +1,32 @@
+import type { OpenAPIDefinition, OpenAPIServer } from '@redocly/api-docs';
+export type ApiCallOperation = {
+    pattern: RegExp;
+    /** Upper case. */
+    method: string;
+    /**
+     * False when `x-mcp.apiCalls.hide` or `x-mcp.docs.hide` on the path item or operation, or an
+     * `mcp.apiCalls.excludeOperations` entry, excludes it.
+     */
+    callable: boolean;
+    /**
+     * False when RBAC hides the operation from the caller. The bridge then answers as for an
+     * undocumented path, so the reply does not reveal that the operation exists.
+     */
+    visible: boolean;
+    /** Number of `{variable}` segments in the path; fewer is more specific. */
+    variables: number;
+};
+/** An `mcp.apiCalls.excludeOperations` entry of one API; no `method` excludes every method of `path`. */
+export type ExcludedOperation = {
+    method?: string;
+    path: string;
+};
+/**
+ * Every operation of the unfiltered `description`, with the ones missing from `visibleDescription`,
+ * the caller's RBAC-filtered copy, marked not visible. A hidden or `excluded` operation stays in the
+ * list, so a less specific template cannot claim its requests.
+ */
+export declare function apiCallOperationsOf(description: OpenAPIDefinition, visibleDescription: OpenAPIDefinition, servers: readonly OpenAPIServer[], excluded?: readonly ExcludedOperation[]): ApiCallOperation[];
+/** The documented operations that an upper-case `method` on `pathname` matches. */
+export declare function matchingApiCallOperations(operations: readonly ApiCallOperation[], pathname: string, method: string): ApiCallOperation[];
+//# sourceMappingURL=api-call-operations.d.ts.map

package/dist/server/plugins/mcp/gateway-mcp/api-call-operations.js

@@ -0,0 +1 @@
+import{OPERATION_METHODS as P}from"../docs-mcp/tools/openapi/constants.js";import{isEndpointHidden as u}from"../utils/xmcp-utils.js";import{basePathPrefix as T,operationHttpMethod as d,pathPattern as y,pathTemplateKey as C,pathVariableCount as H}from"./route-pattern.js";const M=new Set(P);function m(t){return u(t,"apiCalls")||u(t,"docs")}function w(t,n,i,a=[]){const b=T(i),c=new Set(a.map(({method:e,path:o})=>p(e&&d(e),o))),f=[];for(const[e,o]of Object.entries(t.paths??{})){if(!o||typeof o!="object")continue;const h=y(b,e);if(!h)continue;const O=m(o)||c.has(p(void 0,e)),x=n.paths?.[e],E=H(e);for(const[r,s]of Object.entries(o)){if(!M.has(r.toLowerCase())||!s||typeof s!="object")continue;const l=d(r);f.push({pattern:h,method:l,callable:!O&&!m(s)&&!c.has(p(l,e)),visible:!!x?.[r],variables:E})}}return f}function p(t,n){return`${t??"*"} ${C(n)}`}function I(t,n,i){return t.filter(a=>a.method===i&&a.pattern.test(n))}export{w as apiCallOperationsOf,I as matchingApiCallOperations};

package/dist/server/plugins/mcp/gateway-mcp/callable-apis.d.ts

@@ -0,0 +1,13 @@
+import type { ApiDescriptionInfo, McpToolContext } from '../types.js';
+import type { ExcludedOperation } from './api-call-operations.js';
+/**
+ * The APIs an agent may call in this request: the build-stamped `fetchEligible` entries of the
+ * already RBAC-filtered map, minus what `mcp.apiCalls` removes. The config is read from the
+ * request context, so a `redocly.yaml` edit applies without restarting the dev server.
+ * No EntitlementsProvider read — this code runs in graphs where the provider is uninitialized.
+ */
+export declare function getCallableApis(context: McpToolContext): ApiDescriptionInfo[];
+/** The `mcp.apiCalls.excludeOperations` entries whose `file` glob matches the API at `relativePath`. */
+export declare function getExcludedOperations(context: McpToolContext, relativePath: string): ExcludedOperation[];
+export declare function isFetchCapable(context: McpToolContext): boolean;
+//# sourceMappingURL=callable-apis.d.ts.map

package/dist/server/plugins/mcp/gateway-mcp/callable-apis.js

@@ -0,0 +1 @@
+import c from"picomatch";function r(e){const i=e.config?.mcp?.apiCalls;if(i?.hide)return[];const t=c(i?.excludeFiles??[]);return Object.values(e.apiDescriptionsMap??{}).filter(l=>l.fetchEligible&&!t(l.relativePath))}function n(e,i){return(e.config?.mcp?.apiCalls?.excludeOperations??[]).filter(({file:t})=>c.isMatch(i,t))}function p(e){return r(e).length>0}export{r as getCallableApis,n as getExcludedOperations,p as isFetchCapable};

package/dist/server/plugins/mcp/gateway-mcp/caller-api-calls.d.ts

@@ -0,0 +1,9 @@
+import type { RedoclyConfig } from '@redocly/config';
+/**
+ * `mcp` with `apiCalls` narrowed by the caller's `metadata.apiCalls` (`hide`, `allowedHttpMethods`),
+ * which the AI Assistant fills from `aiAssistant.mcp.apiCalls`. The caller can only take API calls
+ * or methods away: a value of another shape changes nothing, and a method list that keeps none of
+ * the project's methods turns API calls off.
+ */
+export declare function narrowMcpConfigForCaller(mcp: RedoclyConfig['mcp'], metadata: Record<string, unknown> | undefined): RedoclyConfig['mcp'];
+//# sourceMappingURL=caller-api-calls.d.ts.map

package/dist/server/plugins/mcp/gateway-mcp/caller-api-calls.js

@@ -0,0 +1 @@
+import{DEFAULT_ALLOWED_HTTP_METHODS as d}from"./allowed-http-methods.js";function h(e,a){const o=a?.apiCalls;if(!o||typeof o!="object")return e;const{hide:i,allowedHttpMethods:s}=o,t={...e?.apiCalls};if(i===!0&&(t.hide=!0),Array.isArray(s)){const n=new Set(s.map(r=>String(r).toUpperCase())),l=(e?.apiCalls?.allowedHttpMethods??d).filter(r=>n.has(r));l.length===0?t.hide=!0:t.allowedHttpMethods=l}return{...e,apiCalls:t}}export{h as narrowMcpConfigForCaller};

package/dist/server/plugins/mcp/gateway-mcp/credential-validation.d.ts

@@ -0,0 +1,4 @@
+import type { UpstreamAuthScheme } from './upstream-auth-scheme.js';
+export declare function rejectCredential(auth: UpstreamAuthScheme, value: string): string | undefined;
+export declare function assertHeaderSafe(header: string, value: string): void;
+//# sourceMappingURL=credential-validation.d.ts.map