@dokebi/mcp 0.0.0-stage → 0.1.0

package/dist/registry.d.ts

@@ -0,0 +1,70 @@
+import { InputSchema } from './schema.js';
+import { type McpPrompt, type McpPromptArgument, type McpResource, type McpTool } from './tool.js';
+export interface CompiledTool {
+    readonly tool: McpTool;
+    readonly name: string;
+    /** The first of `scopes` (the one a refused client is asked for). */
+    readonly scope: string;
+    /** The scopes of which any one lets a grant use it. */
+    readonly scopes: readonly string[];
+    readonly bucket: string;
+    readonly readOnly: boolean;
+    readonly input: InputSchema;
+    /** The `tools/list` entry (frozen). */
+    readonly listing: Readonly<Record<string, unknown>>;
+    /** The contributing plugin. */
+    readonly plugin: string;
+}
+export interface CompiledPrompt {
+    readonly prompt: McpPrompt;
+    readonly name: string;
+    /** The first of `scopes` (the one a refused client is asked for). */
+    readonly scope: string;
+    /** The scopes of which any one lets a grant use it. */
+    readonly scopes: readonly string[];
+    readonly arguments: readonly McpPromptArgument[];
+    readonly listing: Readonly<Record<string, unknown>>;
+    readonly plugin: string;
+}
+export interface CompiledResource {
+    readonly resource: McpResource;
+    readonly name: string;
+    /** The first of `scopes` (the one a refused client is asked for). */
+    readonly scope: string;
+    /** The scopes of which any one lets a grant use it. */
+    readonly scopes: readonly string[];
+    readonly uri: string | undefined;
+    readonly template: string | undefined;
+    readonly mimeType: string | undefined;
+    /**
+     * For a template: the literal text around its variables (one more than the variables) and
+     * their names. Matched by `matchTemplate` in linear time, never by a backtracking regex.
+     */
+    readonly literals: readonly string[] | undefined;
+    readonly variables: readonly string[];
+    readonly listing: Readonly<Record<string, unknown>>;
+    readonly plugin: string;
+}
+/** Each contribution with its plugin, as `context.collect` gives them. */
+export interface Contributed<T> {
+    readonly plugin: string;
+    readonly value: T;
+}
+/** The tools, checked. `scopes`: the resource's declared scopes (undefined: not checked). */
+export declare function compileTools(contributed: readonly Contributed<unknown>[], scopes: ReadonlySet<string> | undefined): CompiledTool[];
+export declare function compilePrompts(contributed: readonly Contributed<unknown>[], scopes: ReadonlySet<string> | undefined): CompiledPrompt[];
+/**
+ * The raw values of a template's variables in `uri`, or undefined: `literals[0] {v1} literals[1]
+ * … {vk} literals[k]`, each variable one or more characters other than `/`, `?` and `#`. The
+ * values are the ones a greedy regex would capture (each variable as long as the rest still
+ * matches), found in time linear in the URI: a regex with two variables between a literal backtracks
+ * quadratically (`ticket://{project}-{number}` and 32 KB of `a-`: 0.3 s; three variables: cubic),
+ * and the URI is client input of up to `bodyLimitBytes`.
+ */
+export declare function matchTemplate(literals: readonly string[], uri: string): string[] | undefined;
+export declare function compileResources(contributed: readonly Contributed<unknown>[], scopes: ReadonlySet<string> | undefined): CompiledResource[];
+/** The resource that serves `uri` and its template values (percent-decoded), or undefined. */
+export declare function matchResource(resources: readonly CompiledResource[], uri: string): {
+    resource: CompiledResource;
+    params: Readonly<Record<string, string>>;
+} | undefined;

package/dist/registry.js

@@ -0,0 +1,413 @@
+import { McpError } from './errors.js';
+import { BUCKET } from './options.js';
+import { TOOL_NAME } from './protocol.js';
+import { frozenJson, InputSchema } from './schema.js';
+import { kindOf, } from './tool.js';
+const ANNOTATION_KEYS = new Set([
+    'title',
+    'readOnlyHint',
+    'destructiveHint',
+    'idempotentHint',
+    'openWorldHint',
+]);
+const ARGUMENT = /^[A-Za-z_][A-Za-z0-9_-]{0,63}$/;
+const VARIABLE = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+const ABSOLUTE_URI = /^[A-Za-z][A-Za-z0-9+.-]*:\S+$/;
+const MAX_DESCRIPTION = 8_192;
+/** Reads a member of a contributed object; a getter that throws is the object's problem. */
+function member(target, key, problems, where) {
+    try {
+        return target[key];
+    }
+    catch (error) {
+        problems.push(`${where}.${key} threw when read (${error.message})`);
+        return undefined;
+    }
+}
+function describe(value, where, problems) {
+    if (typeof value !== 'string' || value.trim() === '' || value.length > MAX_DESCRIPTION) {
+        problems.push(`${where}.description must be a non-empty string of at most ${MAX_DESCRIPTION} characters`);
+        return undefined;
+    }
+    return value;
+}
+function title(value, where, problems) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || value === '' || value.length > 200) {
+        problems.push(`${where}.title must be a non-empty string of at most 200 characters`);
+        return undefined;
+    }
+    return value;
+}
+function scopeOf(value, where, scopes, problems) {
+    const list = typeof value === 'string' ? [value] : Array.isArray(value) ? value : undefined;
+    if (list === undefined ||
+        list.length === 0 ||
+        list.length > 32 ||
+        list.some((item) => typeof item !== 'string' || item === '')) {
+        problems.push(`${where}.scope is required: one scope of the resource, or a list of 1-32 of which any one is enough`);
+        return undefined;
+    }
+    const unique = [...new Set(list)];
+    const unknown = scopes ? unique.filter((item) => !scopes.has(item)) : [];
+    if (unknown.length) {
+        problems.push(`${where}.scope ${unknown.join(', ')} is not declared by the oauth resource (${[...(scopes ?? [])].join(', ') || 'no scopes'})`);
+        return undefined;
+    }
+    return Object.freeze(unique);
+}
+function fail(code, noun, problems) {
+    return new McpError(code, `${problems.length} problem(s) in the contributed ${noun}s: ${problems[0]}`, {
+        fix: `Correct the ${noun} classes contributed to dokebi-mcp:${noun}s (details.problems lists every problem).`,
+        details: { problems },
+    });
+}
+/** The tools, checked. `scopes`: the resource's declared scopes (undefined: not checked). */
+export function compileTools(contributed, scopes) {
+    const problems = [];
+    const result = [];
+    const names = new Map();
+    for (const { plugin, value } of contributed) {
+        const before = problems.length;
+        const label = `tool of ${plugin}`;
+        if (kindOf(value) !== 'tool') {
+            problems.push(`${label} is not an instance of a McpTool subclass`);
+            continue;
+        }
+        const tool = value;
+        const name = member(tool, 'name', problems, label);
+        const where = typeof name === 'string' ? `tool ${name}` : label;
+        if (typeof name !== 'string' || !TOOL_NAME.test(name))
+            problems.push(`${where}: name must be 1-128 letters, digits, _, - or .`);
+        else if (names.has(name))
+            problems.push(`${where} of ${plugin}: the name is used by another tool (of ${names.get(name)}); tool names are unique across every plugin and module`);
+        else
+            names.set(name, plugin);
+        const description = describe(member(tool, 'description', problems, where), where, problems);
+        const shown = title(member(tool, 'title', problems, where), where, problems);
+        const scope = scopeOf(member(tool, 'scope', problems, where), where, scopes, problems);
+        const annotations = member(tool, 'annotations', problems, where);
+        let readOnly = false;
+        if (annotations !== undefined) {
+            if (annotations === null || typeof annotations !== 'object' || Array.isArray(annotations))
+                problems.push(`${where}.annotations must be an object`);
+            else
+                for (const [key, hint] of Object.entries(annotations)) {
+                    if (!ANNOTATION_KEYS.has(key))
+                        problems.push(`${where}.annotations.${key} is not an MCP tool annotation`);
+                    else if (key === 'title' ? typeof hint !== 'string' : typeof hint !== 'boolean')
+                        problems.push(`${where}.annotations.${key} has the wrong type`);
+                }
+            readOnly = annotations?.readOnlyHint === true;
+        }
+        const bucket = member(tool, 'bucket', problems, where) ?? (readOnly ? 'read' : 'write');
+        if (typeof bucket !== 'string' || !BUCKET.test(bucket))
+            problems.push(`${where}.bucket must be 1-32 lower-case letters, digits or - (a limit bucket)`);
+        if (typeof member(tool, 'handle', problems, where) !== 'function')
+            problems.push(`${where}.handle must be a method`);
+        const input = InputSchema.check(member(tool, 'inputSchema', problems, where), 'input');
+        for (const problem of input.problems)
+            problems.push(`${where}: ${problem}`);
+        const outputValue = member(tool, 'outputSchema', problems, where);
+        const output = outputValue === undefined ? undefined : InputSchema.check(outputValue, 'output');
+        for (const problem of output?.problems ?? [])
+            problems.push(`${where}: ${problem}`);
+        if (problems.length > before || !input.schema)
+            continue;
+        result.push(Object.freeze({
+            tool,
+            name: name,
+            scope: scope[0],
+            scopes: scope,
+            bucket: bucket,
+            readOnly,
+            input: input.schema,
+            plugin,
+            listing: Object.freeze({
+                name,
+                ...(shown === undefined ? {} : { title: shown }),
+                description,
+                inputSchema: input.schema.schema,
+                ...(output?.schema ? { outputSchema: output.schema.schema } : {}),
+                ...(annotations === undefined ? {} : { annotations: frozenJson(annotations) }),
+            }),
+        }));
+    }
+    if (problems.length)
+        throw fail('INVALID_TOOL', 'tool', problems);
+    return result;
+}
+export function compilePrompts(contributed, scopes) {
+    const problems = [];
+    const result = [];
+    const names = new Map();
+    for (const { plugin, value } of contributed) {
+        const before = problems.length;
+        const label = `prompt of ${plugin}`;
+        if (kindOf(value) !== 'prompt') {
+            problems.push(`${label} is not an instance of a McpPrompt subclass`);
+            continue;
+        }
+        const prompt = value;
+        const name = member(prompt, 'name', problems, label);
+        const where = typeof name === 'string' ? `prompt ${name}` : label;
+        if (typeof name !== 'string' || !TOOL_NAME.test(name))
+            problems.push(`${where}: name must be 1-128 letters, digits, _, - or .`);
+        else if (names.has(name))
+            problems.push(`${where} of ${plugin}: the name is used by another prompt (of ${names.get(name)}); prompt names are unique across every plugin and module`);
+        else
+            names.set(name, plugin);
+        const description = describe(member(prompt, 'description', problems, where), where, problems);
+        const shown = title(member(prompt, 'title', problems, where), where, problems);
+        const scope = scopeOf(member(prompt, 'scope', problems, where), where, scopes, problems);
+        if (typeof member(prompt, 'handle', problems, where) !== 'function')
+            problems.push(`${where}.handle must be a method`);
+        const declared = member(prompt, 'arguments', problems, where) ?? [];
+        const args = [];
+        if (!Array.isArray(declared))
+            problems.push(`${where}.arguments must be a list`);
+        else {
+            const seen = new Set();
+            for (const [index, argument] of declared.entries()) {
+                const at = `${where}.arguments[${index}]`;
+                const one = argument;
+                if (typeof one?.name !== 'string' || !ARGUMENT.test(one.name)) {
+                    problems.push(`${at}.name must be 1-64 letters, digits, _ or - (starting with a letter)`);
+                    continue;
+                }
+                if (seen.has(one.name))
+                    problems.push(`${at}: ${one.name} is listed twice`);
+                seen.add(one.name);
+                if (typeof one.description !== 'string' || one.description.trim() === '')
+                    problems.push(`${at} has no description (the model reads only that about it)`);
+                if (one.required !== undefined && typeof one.required !== 'boolean')
+                    problems.push(`${at}.required must be a boolean`);
+                args.push(Object.freeze({
+                    name: one.name,
+                    description: one.description,
+                    ...(one.required === undefined ? {} : { required: one.required }),
+                }));
+            }
+        }
+        if (problems.length > before)
+            continue;
+        result.push(Object.freeze({
+            prompt,
+            name: name,
+            scope: scope[0],
+            scopes: scope,
+            arguments: Object.freeze(args),
+            plugin,
+            listing: Object.freeze({
+                name,
+                ...(shown === undefined ? {} : { title: shown }),
+                description,
+                arguments: Object.freeze(args),
+            }),
+        }));
+    }
+    if (problems.length)
+        throw fail('INVALID_PROMPT', 'prompt', problems);
+    return result;
+}
+/** Where `literal` occurs in `text` (KMP: linear in both, whatever the literal repeats). */
+function occurrences(text, literal) {
+    const at = new Uint8Array(text.length + 1);
+    if (literal === '')
+        return at.fill(1);
+    const fail = new Int32Array(literal.length);
+    for (let index = 1, known = 0; index < literal.length; index++) {
+        while (known > 0 && literal[index] !== literal[known])
+            known = fail[known - 1];
+        if (literal[index] === literal[known])
+            known++;
+        fail[index] = known;
+    }
+    for (let index = 0, known = 0; index < text.length; index++) {
+        while (known > 0 && text[index] !== literal[known])
+            known = fail[known - 1];
+        if (text[index] === literal[known])
+            known++;
+        if (known === literal.length) {
+            at[index - literal.length + 1] = 1;
+            known = fail[known - 1];
+        }
+    }
+    return at;
+}
+const DELIMITER = new Set(['/', '?', '#']);
+/**
+ * The raw values of a template's variables in `uri`, or undefined: `literals[0] {v1} literals[1]
+ * … {vk} literals[k]`, each variable one or more characters other than `/`, `?` and `#`. The
+ * values are the ones a greedy regex would capture (each variable as long as the rest still
+ * matches), found in time linear in the URI: a regex with two variables between a literal backtracks
+ * quadratically (`ticket://{project}-{number}` and 32 KB of `a-`: 0.3 s; three variables: cubic),
+ * and the URI is client input of up to `bodyLimitBytes`.
+ */
+export function matchTemplate(literals, uri) {
+    const count = literals.length - 1;
+    const first = literals[0];
+    const last = literals[count];
+    const size = uri.length;
+    if (!uri.startsWith(first) || !uri.endsWith(last) || size < first.length + last.length + count)
+        return undefined;
+    // stop[p]: the first delimiter at or after p (a variable that starts at p ends at most there).
+    const stop = new Int32Array(size + 1);
+    stop[size] = size;
+    for (let index = size - 1; index >= 0; index--)
+        stop[index] = DELIMITER.has(uri[index]) ? index : stop[index + 1];
+    // latest[j][x]: the largest q <= x where variable j may end so that the rest matches (-1: none).
+    const latest = new Array(count + 1);
+    const fits = (variable, start) => start < size && latest[variable][stop[start]] > start;
+    for (let variable = count; variable >= 1; variable--) {
+        const after = literals[variable];
+        const at = variable === count ? undefined : occurrences(uri, after);
+        const table = new Int32Array(size + 1);
+        let best = -1;
+        for (let end = 0; end <= size; end++) {
+            const ok = at === undefined
+                ? end === size - after.length
+                : at[end] === 1 && fits(variable + 1, end + after.length);
+            if (ok)
+                best = end;
+            table[end] = best;
+        }
+        latest[variable] = table;
+    }
+    if (!fits(1, first.length))
+        return undefined;
+    const values = [];
+    let start = first.length;
+    for (let variable = 1; variable <= count; variable++) {
+        const end = latest[variable][stop[start]];
+        values.push(uri.slice(start, end));
+        start = end + literals[variable].length;
+    }
+    return values;
+}
+export function compileResources(contributed, scopes) {
+    const problems = [];
+    const result = [];
+    const names = new Map();
+    const uris = new Set();
+    for (const { plugin, value } of contributed) {
+        const before = problems.length;
+        const label = `resource of ${plugin}`;
+        if (kindOf(value) !== 'resource') {
+            problems.push(`${label} is not an instance of a McpResource subclass`);
+            continue;
+        }
+        const resource = value;
+        const name = member(resource, 'name', problems, label);
+        const where = typeof name === 'string' ? `resource ${name}` : label;
+        if (typeof name !== 'string' || !TOOL_NAME.test(name))
+            problems.push(`${where}: name must be 1-128 letters, digits, _, - or .`);
+        else if (names.has(name))
+            problems.push(`${where} of ${plugin}: the name is used by another resource (of ${names.get(name)}); resource names are unique across every plugin and module`);
+        else
+            names.set(name, plugin);
+        const description = describe(member(resource, 'description', problems, where), where, problems);
+        const shown = title(member(resource, 'title', problems, where), where, problems);
+        const scope = scopeOf(member(resource, 'scope', problems, where), where, scopes, problems);
+        if (typeof member(resource, 'read', problems, where) !== 'function')
+            problems.push(`${where}.read must be a method`);
+        const uri = member(resource, 'uri', problems, where);
+        const template = member(resource, 'template', problems, where);
+        const mimeType = member(resource, 'mimeType', problems, where);
+        if ((uri === undefined) === (template === undefined))
+            problems.push(`${where} needs exactly one of uri and template`);
+        let literals;
+        const variables = [];
+        for (const [key, text] of [
+            ['uri', uri],
+            ['template', template],
+        ]) {
+            if (text === undefined)
+                continue;
+            if (typeof text !== 'string' || !ABSOLUTE_URI.test(text) || text.length > 2_048) {
+                problems.push(`${where}.${key} must be an absolute URI (scheme:…) of at most 2048 characters`);
+                continue;
+            }
+            if (uris.has(text))
+                problems.push(`${where}.${key} ${text} is used by another resource`);
+            uris.add(text);
+            if (key === 'uri' && text.includes('{'))
+                problems.push(`${where}.uri has a {variable}: use template`);
+            if (key === 'template') {
+                const around = [];
+                let last = 0;
+                for (const match of text.matchAll(VARIABLE)) {
+                    around.push(text.slice(last, match.index));
+                    variables.push(match[1]);
+                    last = match.index + match[0].length;
+                }
+                around.push(text.slice(last));
+                if (variables.length === 0)
+                    problems.push(`${where}.template has no {variable}: use uri`);
+                if (/[{}]/.test(text.replace(VARIABLE, '')))
+                    problems.push(`${where}.template has a brace that is not a {name} variable`);
+                if (new Set(variables).size !== variables.length)
+                    problems.push(`${where}.template repeats a variable`);
+                literals = around;
+            }
+        }
+        if (mimeType !== undefined &&
+            (typeof mimeType !== 'string' || !/^[\w.+-]+\/[\w.+-]+/.test(mimeType)))
+            problems.push(`${where}.mimeType must be a media type (text/markdown)`);
+        if (problems.length > before)
+            continue;
+        result.push(Object.freeze({
+            resource,
+            name: name,
+            scope: scope[0],
+            scopes: scope,
+            uri: uri,
+            template: template,
+            mimeType: mimeType,
+            literals: literals === undefined ? undefined : Object.freeze(literals),
+            variables: Object.freeze(variables),
+            plugin,
+            listing: Object.freeze({
+                ...(uri === undefined ? { uriTemplate: template } : { uri }),
+                name,
+                ...(shown === undefined ? {} : { title: shown }),
+                description,
+                ...(mimeType === undefined ? {} : { mimeType }),
+            }),
+        }));
+    }
+    if (problems.length)
+        throw fail('INVALID_RESOURCE', 'resource', problems);
+    return result;
+}
+/** The resource that serves `uri` and its template values (percent-decoded), or undefined. */
+export function matchResource(resources, uri) {
+    for (const resource of resources) {
+        if (resource.uri !== undefined) {
+            if (resource.uri === uri)
+                return { resource, params: Object.freeze({}) };
+            continue;
+        }
+        const match = resource.literals && matchTemplate(resource.literals, uri);
+        if (!match)
+            continue;
+        const params = {};
+        let decoded = true;
+        resource.variables.forEach((name, index) => {
+            const raw = match[index];
+            try {
+                params[name] = decodeURIComponent(raw);
+            }
+            catch (error) {
+                // A broken escape is a URI no template serves (the caller answers "not found").
+                if (!(error instanceof URIError))
+                    throw error;
+                decoded = false;
+            }
+        });
+        if (decoded)
+            return { resource, params: Object.freeze(params) };
+    }
+    return undefined;
+}

package/dist/runner.d.ts

@@ -0,0 +1,96 @@
+import { type Awaitable, type DokebiErrorLike, type Logger } from '@dokebi/core';
+import type { WebErrorTranslator } from '@dokebi/web/points';
+import type { FastifyRequest } from 'fastify';
+import { type McpEnvelope } from './envelope.js';
+import type { McpCallEntry, McpCallMethod, McpHookContext, McpHooks } from './extension.js';
+import type { CompiledPrompt, CompiledResource, CompiledTool } from './registry.js';
+import type { McpGrant, McpImageLimits } from './tool.js';
+/** What `consume` of @dokebi/rate-limit answers (by shape; every field since 0.1.0). */
+export interface LimiterDecision {
+    readonly allowed: boolean;
+    readonly limit: number;
+    readonly remaining: number;
+    readonly retryAfterMs: number;
+    readonly resetAfterMs: number;
+}
+/** The part of @dokebi/rate-limit this file uses (by shape). */
+export interface Limiter {
+    consume(key: string): Awaitable<LimiterDecision>;
+}
+export interface RunnerSettings {
+    readonly logger: Logger;
+    readonly timeoutMs: number;
+    readonly resultMaxChars: number;
+    /** The picture limits of a tool result (D-0143). */
+    readonly images: McpImageLimits;
+    /** Limit bucket → limiter (empty: no limit). */
+    readonly limiters: ReadonlyMap<string, Limiter>;
+    readonly hooks: McpHooks | undefined;
+    readonly overridden: ReadonlySet<string>;
+    readonly hookContext: Pick<McpHookContext, 'app' | 'getDependency' | 'logger'>;
+    readonly translators: readonly {
+        readonly plugin: string;
+        readonly value: WebErrorTranslator;
+    }[];
+    /** Aborted when the app stops. */
+    readonly appSignal: AbortSignal | undefined;
+    /** Window of the repeated failure logs (`logRepeatWindowMs`; absent: 10000, D-0114). */
+    readonly logRepeatWindowMs?: number;
+}
+/** Who calls and how: the grant, the HTTP request, the protocol version, the client's signal. */
+export interface CallSettings {
+    readonly grant: McpGrant;
+    readonly request: FastifyRequest | undefined;
+    readonly version: string;
+    /** Aborted when the client closes the request. */
+    readonly signal: AbortSignal | undefined;
+    /**
+     * Takes the entry of each call this request ends (D-0134): set when the extension has
+     * `onCall`; the route hands them to the hook after its response.
+     */
+    readonly record?: (entry: McpCallEntry) => void;
+}
+/** A tool call's wire result (`CallToolResult`) and its result code for the log. */
+export interface ToolOutcome {
+    readonly result: Record<string, unknown>;
+    readonly code: string;
+}
+/** A prompt or resource answer: a result, or a JSON-RPC error. */
+export type RpcOutcome = {
+    readonly kind: 'result';
+    readonly result: Record<string, unknown>;
+    readonly code: 'ok';
+} | {
+    readonly kind: 'error';
+    readonly error: number;
+    readonly message: string;
+    readonly data: Record<string, unknown>;
+    readonly code: string;
+};
+/** The body of a tool error (D-0074 shape plus `next`): code, message, hint, next, data. */
+export declare function errorBody(error: DokebiErrorLike): Record<string, unknown>;
+/** A tool result with `isError`: the error object as structuredContent and as JSON text. */
+export declare function toolError(body: Record<string, unknown>): Record<string, unknown>;
+export declare class McpRunner {
+    #private;
+    constructor(settings: RunnerSettings);
+    /**
+     * D-0154: reloaded limits of the next call (the tool deadline, the result size, the picture
+     * limits); a call in progress keeps the ones it started with.
+     */
+    update(next: Pick<RunnerSettings, 'timeoutMs' | 'resultMaxChars' | 'images'>): void;
+    /** Writes the counted repeats of error logs (at close). */
+    flush(): void;
+    /**
+     * The end of one call: its MCP_CALL info line and, when the request records them, its frozen
+     * `onCall` entry with the same values (D-0134). The route's own refusals (the scope, an unknown
+     * name) come here too, so the log and the hook see the same calls.
+     */
+    report(call: Pick<CallSettings, 'grant' | 'record'>, method: McpCallMethod, name: string, ms: number, bytes: number, code: string, envelope?: McpEnvelope): void;
+    /** One `tools/call`, after the scope check. */
+    callTool(compiled: CompiledTool, args: unknown, call: CallSettings): Promise<ToolOutcome>;
+    /** One `prompts/get` (arguments already checked against the declaration). */
+    getPrompt(compiled: CompiledPrompt, args: Readonly<Record<string, string>>, call: CallSettings): Promise<RpcOutcome>;
+    /** One `resources/read` of a matched resource. */
+    readResource(compiled: CompiledResource, params: Readonly<Record<string, string>>, uri: string, call: CallSettings): Promise<RpcOutcome>;
+}