@haddowg/json-api-mcp 0.0.0-stage → 1.2.0

package/dist/index.d.mts

@@ -0,0 +1,534 @@
+import { ActionDescriptor, ApiDescriptor, HeadersInit, JsonApiTransport, RelationDescriptor, ResourceDescriptor } from "@haddowg/json-api-client";
+
+//#region src/openapi.d.ts
+/**
+ * The parts of an OpenAPI 3.1 document this package reads, typed loosely: every object keeps its
+ * other members, vendor extensions included, so hooks see the operation as the server wrote it.
+ */
+/** A JSON Schema node as the document writes it. */
+type JsonSchema = {
+  [key: string]: unknown;
+};
+/** One security requirement: scheme name to the scopes it needs. */
+type SecurityRequirement = Readonly<Record<string, readonly string[]>>;
+interface ParameterObject {
+  name: string;
+  in: string;
+  description?: string;
+  required?: boolean;
+  schema?: JsonSchema;
+  [key: string]: unknown;
+}
+interface MediaTypeObject {
+  schema?: JsonSchema;
+  [key: string]: unknown;
+}
+interface RequestBodyObject {
+  description?: string;
+  required?: boolean;
+  content?: Record<string, MediaTypeObject>;
+  [key: string]: unknown;
+}
+interface ResponseObject {
+  description?: string;
+  content?: Record<string, MediaTypeObject>;
+  [key: string]: unknown;
+}
+interface OperationObject {
+  operationId?: string;
+  summary?: string;
+  description?: string;
+  parameters?: (ParameterObject | {
+    $ref: string;
+  })[];
+  requestBody?: RequestBodyObject | {
+    $ref: string;
+  };
+  responses?: Record<string, ResponseObject | {
+    $ref: string;
+  }>;
+  security?: SecurityRequirement[];
+  [key: string]: unknown;
+}
+type HttpMethod = 'get' | 'post' | 'patch' | 'put' | 'delete';
+type PathItemObject = Partial<Record<HttpMethod, OperationObject>> & {
+  parameters?: (ParameterObject | {
+    $ref: string;
+  })[];
+  [key: string]: unknown;
+};
+interface OpenApiDocument {
+  openapi?: string;
+  info?: {
+    'x-generator'?: {
+      contract?: unknown;
+      [key: string]: unknown;
+    };
+    [key: string]: unknown;
+  };
+  servers?: {
+    url: string;
+    [key: string]: unknown;
+  }[];
+  paths?: Record<string, PathItemObject>;
+  components?: {
+    schemas?: Record<string, JsonSchema>;
+    parameters?: Record<string, ParameterObject>;
+    requestBodies?: Record<string, RequestBodyObject>;
+    responses?: Record<string, ResponseObject>;
+    [key: string]: unknown;
+  };
+  security?: SecurityRequirement[];
+  [key: string]: unknown;
+}
+//#endregion
+//#region src/contract.d.ts
+/** The oldest generator contract this package reads: the baseline current servers stamp. */
+declare const MINIMUM_CONTRACT = 13;
+/** The newest generator contract this package reads. */
+declare const MAXIMUM_CONTRACT = 18;
+/**
+ * Throw unless the document's `info.x-generator.contract` is in the range this package reads. A
+ * document outside it would yield tools that miss or misread what the server offers, so there is
+ * no warning mode.
+ */
+declare function assertContract(doc: OpenApiDocument): number;
+//#endregion
+//#region src/types.d.ts
+/** MCP tool annotations: hints a client may show or act on. */
+type McpToolAnnotations = {
+  title?: string;
+  readOnlyHint?: boolean;
+  destructiveHint?: boolean;
+  idempotentHint?: boolean;
+  openWorldHint?: boolean;
+};
+/** An MCP tool definition, as a `tools/list` response carries it. */
+type McpTool = {
+  name: string;
+  title?: string;
+  description?: string;
+  inputSchema: {
+    type: 'object';
+    [key: string]: unknown;
+  };
+  outputSchema?: {
+    type: 'object';
+    [key: string]: unknown;
+  };
+  annotations?: McpToolAnnotations;
+  _meta?: {
+    [key: string]: unknown;
+  };
+};
+/** A content block in a tool result. */
+type McpContent = {
+  type: 'text';
+  text: string;
+} | {
+  type: 'image';
+  data: string;
+  mimeType: string;
+} | {
+  type: 'resource';
+  resource: {
+    uri: string;
+    mimeType?: string;
+    blob: string;
+  };
+};
+/** The result of an MCP `tools/call`. */
+type McpCallToolResult = {
+  content: McpContent[];
+  structuredContent?: {
+    [key: string]: unknown;
+  };
+  isError?: boolean;
+};
+/** What a tool does, from its operation's kind. */
+type McpOperationKind = 'list' | 'get' | 'create' | 'update' | 'delete' | 'related' | 'action';
+/**
+ * One operation the package turned into a tool. Every hook receives it: the descriptor entries,
+ * the raw OpenAPI operation with its vendor extensions, and the security it carries.
+ */
+interface McpOperation {
+  operationId: string;
+  toolName: string;
+  kind: McpOperationKind;
+  /** The JSON:API type, exactly as in the document. */
+  type: string;
+  /** The relation, for a related read. */
+  relation?: string;
+  /** The action's path segment, for a custom action. */
+  action?: string;
+  /** The HTTP method, upper-case. */
+  method: string;
+  /** The path template, such as `/albums/{id}`. */
+  path: string;
+  /** The type's descriptor entry. */
+  resource: ResourceDescriptor;
+  /** The relation's descriptor entry, for a related read. */
+  relationDescriptor?: RelationDescriptor;
+  /** The action's descriptor entry, for a custom action. */
+  actionDescriptor?: ActionDescriptor;
+  /** The operation object as the document writes it, extensions included. */
+  operation: OperationObject;
+  /**
+   * The operation's own `security`, else the document's. Empty means none is required. The
+   * default scope filtering reads the scopes it lists.
+   */
+  security: readonly SecurityRequirement[];
+  /**
+   * The OAuth scopes the operation needs, as the descriptor carries them (generator contract
+   * 16): the ones its `security` lists under an `oauth2` scheme. Absent when it needs none.
+   */
+  scopes?: readonly string[];
+}
+/** What the host's capabilities resource says about one operation for this caller. */
+type McpCapability = 'allowed' | 'denied' | 'depends';
+/** Request settings a host supplies per call. */
+interface McpRequestInit {
+  /** The API's base URL for this call, overriding {@link JsonApiMcpOptions.baseUrl}. */
+  baseUrl?: string;
+  /** Headers for this call, such as `Authorization`. */
+  headers?: HeadersInit;
+}
+/** One error object of a failed call, in the shape the tool result carries. */
+interface McpToolErrorObject {
+  status?: string;
+  code?: string;
+  title?: string;
+  detail?: string;
+  source?: {
+    pointer?: string;
+    parameter?: string;
+    header?: string;
+  };
+  /** The tool argument the error is about, such as `title` or `releaseInfo.label`. */
+  path?: string;
+}
+/** A failed call, before it becomes an `isError` tool result. */
+interface McpToolError {
+  /** The HTTP status of an error response; absent when no response came back. */
+  status?: number;
+  message: string;
+  errors: McpToolErrorObject[];
+  /** What was thrown: a `JsonApiError`, a transport failure, or the package's own refusal. */
+  cause: unknown;
+}
+/** The optional hooks a host plugs into. Each gets the per-request context it supplied. */
+interface JsonApiMcpHooks<Ctx> {
+  /** Called per operation when the tool list is built, after scopes and capabilities. */
+  includeOperation?: (op: McpOperation, ctx: Ctx) => boolean | Promise<boolean>;
+  /** Called per tool after the package built it. Return the tool to list. */
+  decorateTool?: (tool: McpTool, op: McpOperation, ctx: Ctx) => McpTool | Promise<McpTool>;
+  /** Called per call before the request: headers and the base URL. */
+  requestInit?: (op: McpOperation, ctx: Ctx) => McpRequestInit | Promise<McpRequestInit>;
+  /** Called per failed call. Return the error the tool result carries. */
+  mapError?: (error: McpToolError, op: McpOperation, ctx: Ctx) => McpToolError | Promise<McpToolError>;
+  /**
+   * Whether the caller's granted scopes satisfy the scopes one security requirement lists.
+   * Defaults to every required scope appearing in `granted`.
+   */
+  scopeMatcher?: (granted: readonly string[], required: readonly string[]) => boolean;
+  /**
+   * The caller's capabilities, keyed by `operationId`, called once per tool list. A `denied`
+   * operation is left out; `depends` and an operation the result doesn't name stay in.
+   */
+  capabilities?: (ctx: Ctx) => Readonly<Record<string, McpCapability>> | ReadonlyMap<string, McpCapability> | Promise<Readonly<Record<string, McpCapability>> | ReadonlyMap<string, McpCapability>>;
+}
+/** Options for {@link createJsonApiMcp}. */
+interface JsonApiMcpOptions<Ctx> {
+  /**
+   * The model the generator wrote, parsed: `require('./api.mcp.json')`, or `JSON.parse` of the
+   * file. Checked before use.
+   */
+  model: unknown;
+  /** The API's base URL. Defaults to the source document's first server. */
+  baseUrl?: string;
+  /** The transport the client sends through. Defaults to `fetch`. */
+  transport?: JsonApiTransport;
+  /**
+   * The security schemes an MCP caller authenticates with. Scope filtering ignores a security
+   * requirement naming any other scheme, such as a session cookie. Defaults to the model's, the
+   * document's `oauth2` schemes. When neither names one, every requirement counts.
+   */
+  credentialSchemes?: readonly string[];
+  hooks?: JsonApiMcpHooks<Ctx>;
+}
+/** Per-request input to {@link JsonApiMcp.forRequest}. */
+interface McpRequest<Ctx> {
+  /**
+   * The caller's granted scopes. Omit to skip scope filtering, credential schemes included. `null`
+   * grants none, the same as `[]`, unlike core's `GrantedScopesProviderInterface`, where null means
+   * unrestricted.
+   */
+  grantedScopes?: readonly string[] | null;
+  /** The host's own per-request context, handed to every hook. */
+  context: Ctx;
+}
+/** Options for one call. */
+interface McpCallOptions {
+  signal?: AbortSignal;
+}
+/** The tools one caller may use, and the handler for their calls. */
+interface McpToolSession {
+  readonly tools: readonly McpTool[];
+  /** Run a tool from {@link tools}. Any other name is a tool error. */
+  callTool(name: string, args: unknown, options?: McpCallOptions): Promise<McpCallToolResult>;
+}
+/** An operation the package left out of the catalogue, and why. */
+interface SkippedOperation {
+  operationId: string;
+  reason: string;
+}
+/** The tool catalogue built from one document and descriptor. */
+interface JsonApiMcp<Ctx> {
+  /** Every operation that became a tool, before any per-caller filtering. */
+  readonly operations: readonly McpOperation[];
+  /** Every tool, before any per-caller filtering or decoration. */
+  readonly tools: readonly McpTool[];
+  /** Operations that couldn't become a tool, such as an action whose body only takes binary. */
+  readonly skipped: readonly SkippedOperation[];
+  /** The generator contract of the document the model was built from. */
+  readonly contract: number;
+  /** The document the model was built from, and its content hash. */
+  readonly source: {
+    readonly title: string;
+    readonly hash: string;
+  };
+  /** The credential schemes scope filtering counts. `undefined` when it counts every scheme. */
+  readonly credentialSchemes: readonly string[] | undefined;
+  /** Filter and decorate the tools for one caller. */
+  forRequest(request: McpRequest<Ctx>): Promise<McpToolSession>;
+}
+//#endregion
+//#region src/mcp.d.ts
+/** Every required scope appears among the granted ones. */
+declare const exactScopeMatcher: (granted: readonly string[], required: readonly string[]) => boolean;
+/**
+ * Whether granted scopes satisfy an operation's security. No requirement, or an empty one, needs
+ * nothing. Given `credentialSchemes`, the schemes the caller authenticates with, a requirement
+ * counts only when it names nothing else, so an operation whose every requirement needs another
+ * credential fails. A counted requirement passes when its scopes, across its schemes, all match,
+ * or when it lists none. Without `credentialSchemes` every requirement counts.
+ */
+declare function satisfiesSecurity(security: readonly SecurityRequirement[], granted: readonly string[], matcher?: (granted: readonly string[], required: readonly string[]) => boolean, credentialSchemes?: readonly string[]): boolean;
+/**
+ * Serve MCP tools from a model the generator wrote: `createJsonApiMcp({ model })` with the parsed
+ * artefact. Throws when the artefact isn't one this runtime can read.
+ */
+declare function createJsonApiMcp<Ctx = unknown>(options: JsonApiMcpOptions<Ctx>): JsonApiMcp<Ctx>;
+//#endregion
+//#region src/portable.d.ts
+/** The string formats both APIs accept. */
+declare const PORTABLE_FORMATS: ReadonlySet<string>;
+type Decoder = {
+  kind: 'value';
+} | {
+  kind: 'json';
+} | {
+  kind: 'object';
+  props: Readonly<Record<string, PropertyDecoder>>;
+} | {
+  kind: 'array';
+  items: Decoder;
+};
+interface PropertyDecoder {
+  decoder: Decoder;
+  /** The conversion made this property nullable, so `null` means "not given". */
+  nullMeansOmit: boolean;
+}
+//#endregion
+//#region src/inputs.d.ts
+/** How the handler reads a read tool's query arguments. */
+interface QueryPlan {
+  filter?: Decoder;
+  sort: boolean;
+  include: boolean;
+  /**
+   * The include paths the tool accepts, the ones its input lists. A model before format 3
+   * doesn't carry them and its tools accept any path.
+   */
+  includePaths?: readonly string[];
+  fields: readonly string[];
+  /** The wire key `pageSize` maps to, when the endpoint paginates by a size. */
+  sizeKey?: string;
+  maxPageSize?: number;
+  defaultPageSize?: number;
+  /** Whether `pageLink` is offered: the endpoint paginates at all. */
+  paginated: boolean;
+  /**
+   * Whether `withCount` is offered: the endpoint counts its own collection under the Countable
+   * profile, sent as `withCount=_self_` with this profile negotiated.
+   */
+  countProfile?: string;
+}
+/** One top-level write field: an attribute, or a relation sent as ids. */
+interface WriteField {
+  relation?: {
+    cardinality: 'one' | 'many';
+    types: readonly string[];
+    polymorphic?: boolean;
+  };
+  property: PropertyDecoder;
+}
+/** How the handler reads a create, update or flat document action's arguments. */
+interface WritePlan {
+  fields: Readonly<Record<string, WriteField>>;
+  /** The client id argument: whether the body takes one. */
+  clientId: 'none' | 'optional' | 'required';
+  /** Fields `clear` may name, for an update. */
+  clearable: readonly string[];
+}
+/** How the handler reads a custom action's body. */
+type ActionBodyPlan = {
+  kind: 'none';
+} | {
+  kind: 'flat';
+  write: WritePlan;
+} | {
+  kind: 'body';
+  decoder: Decoder;
+  required: boolean; /** The request media type the body goes out as. */
+  mediaType: string;
+  mediaKind: 'document' | 'json' | 'text' | 'form';
+};
+//#endregion
+//#region src/catalogue.d.ts
+/** How the handler shapes a call's result. */
+type ResultShape = 'collection' | 'resource' | 'item' | 'deleted' | 'meta' | 'location' | 'none' | 'raw' | 'loose';
+//#endregion
+//#region src/model.d.ts
+/** The artefact's own format. A runtime refuses a format it doesn't know. */
+declare const MODEL_FORMAT = 3;
+/** The package that writes the artefact. */
+declare const MODEL_GENERATOR = "@haddowg/json-api-mcp";
+/** One operation, as hooks see it, without the descriptor entries the runtime adds back. */
+interface McpModelOperation {
+  operationId: string;
+  toolName: string;
+  kind: McpOperationKind;
+  type: string;
+  relation?: string;
+  action?: string;
+  /** The action's key in the type's descriptor `actions`. */
+  actionKey?: string;
+  method: string;
+  path: string;
+  /**
+   * The operation object, extensions included, without its `parameters`, `requestBody` and
+   * `responses`: the tool already holds what those say, and they can refer to components the
+   * artefact doesn't carry. From format 3 it has no `security` either: the runtime puts back
+   * the `security` below.
+   */
+  operation: OperationObject;
+  /**
+   * The operation's own `security`, else the document's. From format 3 it is absent when the
+   * operation declares none, and the runtime takes the model's `security`.
+   */
+  security?: readonly SecurityRequirement[];
+  /**
+   * Formats 1 and 2: the OAuth scopes the descriptor says the operation needs. From format 3
+   * the runtime reads them from the descriptor.
+   */
+  scopes?: readonly string[];
+}
+/** How the handler turns one tool's arguments into a client call. */
+interface McpModelPlan {
+  query?: QueryPlan;
+  write?: WritePlan;
+  action?: ActionBodyPlan;
+}
+interface McpModelTool {
+  operation: McpModelOperation;
+  tool: McpTool;
+  plan: McpModelPlan;
+  result: ResultShape;
+}
+/** The generated artefact. */
+interface McpModel {
+  format: 1 | 2 | typeof MODEL_FORMAT;
+  generator: typeof MODEL_GENERATOR;
+  /** The generator contract the source document declared. */
+  contract: number;
+  /** Which document it was built from. */
+  source: {
+    title: string;
+    hash: string;
+  };
+  /** The document's first server URL, the default base URL. */
+  baseUrl?: string;
+  /**
+   * The security schemes an MCP caller authenticates with: the document's `oauth2` schemes.
+   * Empty when it has none. A format 1 model doesn't carry it.
+   */
+  credentialSchemes?: string[];
+  /**
+   * Format 3: the document's `security`, which an operation declaring none of its own takes.
+   * Absent when the document declares none.
+   */
+  security?: readonly SecurityRequirement[];
+  /**
+   * How many relationships deep a tool's `include` may reach; null for every path the document
+   * declares. Formats 1 and 2 don't carry it and set no cap.
+   */
+  includeDepth?: number | null;
+  /** The json-api-ts descriptor the client calls through. */
+  descriptor: ApiDescriptor;
+  tools: McpModelTool[];
+  skipped: SkippedOperation[];
+}
+/** Thrown when an artefact can't be read: another format, or a contract out of range. */
+declare class McpModelError extends Error {
+  constructor(message: string);
+}
+/** Check a parsed artefact before the runtime trusts it. */
+declare function assertModel(value: unknown): McpModel;
+//#endregion
+//#region src/names.d.ts
+/** The name pattern OpenAI's and Anthropic's tool names share. */
+declare const TOOL_NAME_PATTERN: RegExp;
+/** What an `operationId` names, for an operation that becomes a tool. */
+interface ParsedOperationId {
+  kind: McpOperationKind;
+  type: string;
+  relation?: string;
+  action?: string;
+  /** The method suffix of a multi-method action's id. */
+  method?: HttpMethod;
+}
+/**
+ * Parse an `operationId` into what a tool needs. `undefined` for an operation that isn't a tool:
+ * relationship endpoints, Atomic Operations, or an id this package doesn't recognise.
+ */
+declare function parseOperationId(operationId: string): ParsedOperationId | undefined;
+/**
+ * The tool name for a parsed `operationId`: noun first, the type as the document spells it with
+ * kebab-case turned into snake_case. A related read ends in `list` or `get` by the relation's
+ * cardinality; an action is named after its path, plus the method for a multi-method action.
+ */
+declare function toolName(parsed: ParsedOperationId, descriptor: ApiDescriptor): string;
+/** Thrown when the tools can't be named: a name too long, with a stray character, or a clash. */
+declare class ToolNameError extends Error {
+  readonly problems: readonly string[];
+  constructor(problems: readonly string[]);
+}
+//#endregion
+//#region src/safety.d.ts
+/** The vendor extension an action's operation declares its safety in. */
+declare const SAFETY_EXTENSION = "x-safety";
+/** What an action declares about itself. A flag it doesn't declare is absent. */
+interface ActionSafety {
+  readOnly?: boolean;
+  destructive?: boolean;
+  idempotent?: boolean;
+}
+/**
+ * Read an action's declared safety from its operation. An operation without the extension, or
+ * with one this package can't read, declares nothing.
+ */
+declare function readActionSafety(operation: OperationObject): ActionSafety;
+//#endregion
+export { type ActionSafety, type JsonApiMcp, type JsonApiMcpHooks, type JsonApiMcpOptions, type JsonSchema, MAXIMUM_CONTRACT, MINIMUM_CONTRACT, MODEL_FORMAT, MODEL_GENERATOR, type McpCallOptions, type McpCallToolResult, type McpCapability, type McpContent, type McpModel, McpModelError, type McpModelOperation, type McpModelPlan, type McpModelTool, type McpOperation, type McpOperationKind, type McpRequest, type McpRequestInit, type McpTool, type McpToolAnnotations, type McpToolError, type McpToolErrorObject, type McpToolSession, type OpenApiDocument, type OperationObject, PORTABLE_FORMATS, type ParsedOperationId, SAFETY_EXTENSION, type SecurityRequirement, type SkippedOperation, TOOL_NAME_PATTERN, ToolNameError, assertContract, assertModel, createJsonApiMcp, exactScopeMatcher, parseOperationId, readActionSafety, satisfiesSecurity, toolName };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/openapi.ts","../src/contract.ts","../src/types.ts","../src/mcp.ts","../src/portable.ts","../src/inputs.ts","../src/catalogue.ts","../src/model.ts","../src/names.ts","../src/safety.ts"],"mappings":"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"}