toolcraft 0.0.38 → 0.0.40

package/dist/mcp.js

@@ -128,14 +128,24 @@ function formatAvailableList(values) {
     return `Available: ${[...values].sort().join(", ")}.`;
 }
 function applySchemaCasing(schema, casing) {
+    const oneOf = schema.oneOf?.map((child) => applySchemaCasing(child, casing));
+    const additionalProperties = typeof schema.additionalProperties === "object" && schema.additionalProperties !== null
+        ? applySchemaCasing(schema.additionalProperties, casing)
+        : schema.additionalProperties;
     if (schema.type !== "object" || schema.properties === undefined) {
         if (schema.type === "array" && schema.items !== undefined) {
             return {
                 ...schema,
-                items: applySchemaCasing(schema.items, casing)
+                ...(additionalProperties === undefined ? {} : { additionalProperties }),
+                items: applySchemaCasing(schema.items, casing),
+                ...(oneOf === undefined ? {} : { oneOf })
             };
         }
-        return schema;
+        return {
+            ...schema,
+            ...(additionalProperties === undefined ? {} : { additionalProperties }),
+            ...(oneOf === undefined ? {} : { oneOf })
+        };
     }
     const properties = Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [
         formatSegment(key, casing),
@@ -144,8 +154,10 @@ function applySchemaCasing(schema, casing) {
     const required = schema.required?.map((key) => formatSegment(key, casing));
     return {
         ...schema,
+        ...(additionalProperties === undefined ? {} : { additionalProperties }),
         properties,
-        ...(required === undefined ? {} : { required })
+        ...(required === undefined ? {} : { required }),
+        ...(oneOf === undefined ? {} : { oneOf })
     };
 }
 function collectParamSummaries(schema, casing, path = [], inheritedOptional = false) {
@@ -162,16 +174,32 @@ function collectParamSummaries(schema, casing, path = [], inheritedOptional = fa
     }
     return summaries;
 }
-function buildToolDescription(description, params, casing) {
+function buildToolDescription(description, params, examples, commandName, casing) {
     const summary = collectParamSummaries(params, casing);
     const parameterSummary = summary.length === 0 ? "" : `Parameters: ${summary.join(", ")}.`;
+    const exampleSummary = examples.length === 0
+        ? ""
+        : `\n\nExamples:\n${examples
+            .map((example) => `- ${example.title}: ${commandName} ${formatMcpExampleParams(example.params)}`)
+            .join("\n")}`;
     if (description === undefined) {
-        return parameterSummary;
+        return `${parameterSummary}${exampleSummary}`;
     }
     if (parameterSummary.length === 0) {
-        return description;
+        return `${description}${exampleSummary}`;
     }
-    return `${description} ${parameterSummary}`;
+    return `${description} ${parameterSummary}${exampleSummary}`;
+}
+function formatMcpExampleParams(params) {
+    return Object.entries(params)
+        .map(([key, value]) => `${key}=${formatMcpExampleValue(value)}`)
+        .join(" ");
+}
+function formatMcpExampleValue(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    return JSON.stringify(value);
 }
 function matchesAllowlist(toolName, allowlist) {
     if (allowlist === undefined) {
@@ -216,6 +244,9 @@ function enumerateTools(root, casing, allowlist, omitRootToolNamePrefix) {
                 throw new ToolcraftBugError(`command "${name}" must define an object params schema for MCP.`);
             }
             validateUniqueMCPParameterFields(params, casing);
+            if (node.result !== undefined) {
+                validateUniqueMCPParameterFields(node.result, casing);
+            }
             const resolvedCommandPath = [...commandPath, node.name].join(".");
             const existingPath = commandPathsByToolName.get(name);
             if (existingPath !== undefined) {
@@ -226,8 +257,14 @@ function enumerateTools(root, casing, allowlist, omitRootToolNamePrefix) {
                 command: node,
                 commandPath: resolvedCommandPath,
                 name,
-                description: buildToolDescription(node.description, params, casing),
-                inputSchema: applySchemaCasing(toJsonSchema(params), casing)
+                description: buildToolDescription(node.description, params, node.examples, node.name, casing),
+                inputSchema: applySchemaCasing(toJsonSchema(params), casing),
+                ...(node.result === undefined
+                    ? {}
+                    : {
+                        outputSchema: applySchemaCasing(toJsonSchema(node.result), casing),
+                        resultSchema: node.result
+                    })
             });
             return;
         }
@@ -466,6 +503,166 @@ function validateToolArguments(schema, argumentsValue, casing) {
     throwValidationErrors(errors);
     return result;
 }
+function serializeResultValue(schema, value, casing, label, errors) {
+    const unwrappedSchema = unwrapOptional(schema);
+    if (value === null && unwrappedSchema.nullable === true) {
+        return null;
+    }
+    switch (unwrappedSchema.kind) {
+        case "object":
+            return serializeResultObject(unwrappedSchema, value, casing, label, errors);
+        case "array":
+            if (!Array.isArray(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an array, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            return value.map((item, index) => serializeResultValue(unwrappedSchema.item, item, casing, `${label}[${index}]`, errors));
+        case "record":
+            if (!isPlainObject(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+                key,
+                serializeResultValue(unwrappedSchema.value, item, casing, `${label}.${key}`, errors)
+            ]));
+        case "oneOf": {
+            if (!isPlainObject(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            const discriminator = value[unwrappedSchema.discriminator];
+            const branch = typeof discriminator === "string" ? unwrappedSchema.branches[discriminator] : undefined;
+            if (branch === undefined) {
+                const branchNames = Object.keys(unwrappedSchema.branches);
+                errors.push({
+                    path: label.length === 0 ? unwrappedSchema.discriminator : `${label}.${unwrappedSchema.discriminator}`,
+                    message: `Invalid value for "${label.length === 0 ? unwrappedSchema.discriminator : `${label}.${unwrappedSchema.discriminator}`}". Expected one of: ${branchNames.join(", ")}, got ${describeReceived(discriminator)}.`
+                });
+                return value;
+            }
+            const { [unwrappedSchema.discriminator]: ignoredDiscriminator, ...branchValue } = value;
+            void ignoredDiscriminator;
+            return {
+                [formatSegment(unwrappedSchema.discriminator, casing)]: discriminator,
+                ...serializeResultObject(branch, branchValue, casing, label, errors)
+            };
+        }
+        case "union": {
+            if (!isPlainObject(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            const branch = unwrappedSchema.branches.find((candidate) => Object.keys(candidate.shape).every((key) => candidate.shape[key]?.kind === "optional" ||
+                Object.prototype.hasOwnProperty.call(value, key)));
+            if (branch === undefined) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected one union branch, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            return serializeResultObject(branch, value, casing, label, errors);
+        }
+        default:
+            return validateSchemaValue(schema, value, casing, label, errors);
+    }
+}
+function serializeResultObject(schema, value, casing, label, errors) {
+    if (!isPlainObject(value)) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+        });
+        return {};
+    }
+    const result = {};
+    const expectedKeys = new Set(Object.keys(schema.shape));
+    for (const key of Object.keys(value)) {
+        if (!expectedKeys.has(key) && schema.additionalProperties !== true) {
+            const fieldLabel = label.length === 0 ? key : `${label}.${key}`;
+            errors.push({
+                path: fieldLabel,
+                message: `Unexpected result field "${fieldLabel}". ${formatAvailableList([...expectedKeys].map((expectedKey) => label.length === 0 ? expectedKey : `${label}.${expectedKey}`))}`
+            });
+        }
+    }
+    for (const [sourceKey, rawChildSchema] of Object.entries(schema.shape)) {
+        const childSchema = unwrapOptional(rawChildSchema);
+        const hasValue = Object.prototype.hasOwnProperty.call(value, sourceKey);
+        const wireKey = formatSegment(sourceKey, casing);
+        const fieldLabel = label.length === 0 ? sourceKey : `${label}.${sourceKey}`;
+        if (!hasValue) {
+            if (childSchema.default !== undefined) {
+                Object.defineProperty(result, wireKey, {
+                    value: childSchema.default,
+                    enumerable: true,
+                    configurable: true,
+                    writable: true
+                });
+                continue;
+            }
+            if (isOptional(rawChildSchema)) {
+                continue;
+            }
+            errors.push({ path: fieldLabel, message: `Missing required result field "${fieldLabel}".` });
+            continue;
+        }
+        Object.defineProperty(result, wireKey, {
+            value: serializeResultValue(rawChildSchema, value[sourceKey], casing, fieldLabel, errors),
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    }
+    if (schema.additionalProperties === true) {
+        for (const key of Object.keys(value)) {
+            if (!expectedKeys.has(key)) {
+                Object.defineProperty(result, key, {
+                    value: value[key],
+                    enumerable: true,
+                    configurable: true,
+                    writable: true
+                });
+            }
+        }
+    }
+    return result;
+}
+function validateCommandResult(schema, value, casing) {
+    const errors = [];
+    const result = serializeResultObject(schema, value, casing, "", errors);
+    throwResultValidationErrors(errors);
+    return result;
+}
+function throwResultValidationErrors(errors) {
+    if (errors.length === 0) {
+        return;
+    }
+    if (errors.length === 1) {
+        throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, errors[0]?.message ?? "Invalid command result.");
+    }
+    const rendered = errors
+        .slice(0, 10)
+        .map((error) => `  - ${error.path}: ${error.message}`);
+    const remaining = errors.length - rendered.length;
+    if (remaining > 0) {
+        rendered.push(`  ... and ${remaining} more`);
+    }
+    throw new ToolError(JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `${errors.length} result errors:\n${rendered.join("\n")}`);
+}
 function isContentBlock(value) {
     if (!isPlainObject(value) || typeof value.type !== "string") {
         return false;
@@ -491,7 +688,9 @@ function toToolContent(result) {
     if (isContentBlock(result)) {
         return [result];
     }
-    return [{ type: "text", text: JSON.stringify(result) }];
+    const fallbackValue = result;
+    const fallbackText = JSON.stringify(fallbackValue);
+    return [{ type: "text", text: fallbackText }];
 }
 function toToolError(error) {
     if (error instanceof ToolError) {
@@ -524,7 +723,7 @@ function createResolvedMCPServer(root, options) {
         validateToolArguments: false
     });
     for (const tool of tools) {
-        server.tool(tool.name, tool.description, tool.inputSchema, async (argumentsValue) => {
+        const handler = async (argumentsValue) => {
             let params;
             let secrets;
             try {
@@ -548,6 +747,13 @@ function createResolvedMCPServer(root, options) {
                 if (isHumanInLoopPending(result)) {
                     return renderPendingApproval(result);
                 }
+                if (tool.resultSchema !== undefined) {
+                    const structuredContent = validateCommandResult(tool.resultSchema, result, casing);
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+                        structuredContent
+                    };
+                }
                 return toToolContent(result);
             }
             catch (error) {
@@ -566,7 +772,13 @@ function createResolvedMCPServer(root, options) {
                 });
                 throw toToolError(error);
             }
-        });
+        };
+        if (tool.outputSchema === undefined) {
+            server.tool(tool.name, tool.description, tool.inputSchema, handler);
+        }
+        else {
+            server.tool(tool.name, tool.description, tool.inputSchema, handler, tool.outputSchema);
+        }
     }
     return {
         ...server,

package/node_modules/@poe-code/frontmatter/README.md

@@ -0,0 +1,35 @@
+# @poe-code/frontmatter
+
+Shared YAML frontmatter parsing for poe-code packages.
+
+## API
+
+```ts
+import {
+  FrontmatterParseError,
+  parseFrontmatter,
+  parseFrontmatterDocument,
+  stringifyFrontmatter
+} from "@poe-code/frontmatter";
+```
+
+- `parseFrontmatter(source)` returns `{ frontmatter, body }`.
+- `parseFrontmatterDocument(source)` returns `{ frontmatter, body, errors, lineCounter }` for callers that need YAML diagnostics.
+- `stringifyFrontmatter(frontmatter, body)` writes `---` fences, YAML, and the body.
+- `FrontmatterParseError` is thrown for malformed frontmatter, invalid YAML, non-object frontmatter, and stringify failures.
+
+When no leading frontmatter block exists, parsing returns `{ frontmatter: {}, body: source }`.
+The returned `body` is sliced from the original input and is otherwise byte-for-byte unchanged.
+YAML mappings that contain `__proto__` keep it as an own property without changing the object's prototype.
+
+Duplicate mapping keys use YAML's last-wins behavior by default, matching the
+legacy frontmatter readers. Callers that need strict YAML mappings can pass
+`{ uniqueKeys: true }` to `parseFrontmatter` or `parseFrontmatterDocument`.
+
+## Environment
+
+This package reads no environment variables.
+
+## Config
+
+This package has no configuration options.

package/node_modules/@poe-code/frontmatter/dist/fences.d.ts

@@ -0,0 +1,8 @@
+export type FrontmatterBlock = {
+    raw: string;
+    body: string;
+};
+export type SplitFrontmatterResult = FrontmatterBlock | {
+    body: string;
+};
+export declare function splitFrontmatterBlock(source: string): SplitFrontmatterResult;

package/node_modules/@poe-code/frontmatter/dist/fences.js

@@ -0,0 +1,72 @@
+export function splitFrontmatterBlock(source) {
+    const content = source.startsWith("\uFEFF") ? source.slice(1) : source;
+    const opening = readOpeningFence(content);
+    if (opening === undefined) {
+        return { body: source };
+    }
+    const closing = findClosingFence(content, opening.next);
+    if (closing === undefined) {
+        throw new Error("Missing YAML frontmatter end delimiter (---).");
+    }
+    return {
+        raw: content.slice(opening.next, closing.index),
+        body: content.slice(closing.end + closing.lineBreakLength)
+    };
+}
+function readOpeningFence(source) {
+    if (!source.startsWith("---")) {
+        return undefined;
+    }
+    const lineEnd = findLineEnd(source, 0);
+    if (lineEnd.lineBreakLength === 0 || source.slice(0, lineEnd.index) !== "---") {
+        return undefined;
+    }
+    return { next: lineEnd.index + lineEnd.lineBreakLength };
+}
+function findClosingFence(source, start) {
+    let lineStart = start;
+    while (lineStart <= source.length) {
+        const lineEnd = findLineEnd(source, lineStart);
+        if (isClosingFenceLine(source.slice(lineStart, lineEnd.index))) {
+            return {
+                index: lineStart,
+                end: lineEnd.index,
+                lineBreakLength: lineEnd.lineBreakLength
+            };
+        }
+        if (lineEnd.lineBreakLength === 0) {
+            break;
+        }
+        lineStart = lineEnd.index + lineEnd.lineBreakLength;
+    }
+    return undefined;
+}
+function isClosingFenceLine(line) {
+    if (!line.startsWith("---")) {
+        return false;
+    }
+    for (let index = 3; index < line.length; index += 1) {
+        const character = line[index];
+        if (character !== " " && character !== "\t") {
+            return false;
+        }
+    }
+    return true;
+}
+function findLineEnd(source, start) {
+    let index = start;
+    while (index < source.length) {
+        const character = source[index];
+        if (character === "\n") {
+            return { index, lineBreakLength: 1 };
+        }
+        if (character === "\r") {
+            return {
+                index,
+                lineBreakLength: source[index + 1] === "\n" ? 2 : 1
+            };
+        }
+        index += 1;
+    }
+    return { index: source.length, lineBreakLength: 0 };
+}

package/node_modules/@poe-code/frontmatter/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { splitFrontmatterBlock, type FrontmatterBlock, type SplitFrontmatterResult } from "./fences.js";
+export { FrontmatterParseError, parseFrontmatter, parseFrontmatterDocument, type ParsedFrontmatter, type ParsedFrontmatterDocument, type ParseFrontmatterOptions } from "./parse.js";
+export { stringifyFrontmatter } from "./stringify.js";

package/node_modules/@poe-code/frontmatter/dist/index.js

@@ -0,0 +1,3 @@
+export { splitFrontmatterBlock } from "./fences.js";
+export { FrontmatterParseError, parseFrontmatter, parseFrontmatterDocument } from "./parse.js";
+export { stringifyFrontmatter } from "./stringify.js";

package/node_modules/@poe-code/frontmatter/dist/parse.d.ts

@@ -0,0 +1,20 @@
+import { LineCounter } from "yaml";
+export interface ParsedFrontmatter {
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+export interface ParsedFrontmatterDocument extends ParsedFrontmatter {
+    errors: readonly {
+        message: string;
+        pos?: [number, number];
+    }[];
+    lineCounter: LineCounter;
+}
+export interface ParseFrontmatterOptions {
+    uniqueKeys?: boolean;
+}
+export declare class FrontmatterParseError extends Error {
+    constructor(message: string);
+}
+export declare function parseFrontmatter(source: string, options?: ParseFrontmatterOptions): ParsedFrontmatter;
+export declare function parseFrontmatterDocument(source: string, options?: ParseFrontmatterOptions): ParsedFrontmatterDocument;

package/node_modules/@poe-code/frontmatter/dist/parse.js

@@ -0,0 +1,137 @@
+import { LineCounter, parse, parseDocument } from "yaml";
+import { splitFrontmatterBlock } from "./fences.js";
+export class FrontmatterParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "FrontmatterParseError";
+    }
+}
+export function parseFrontmatter(source, options = {}) {
+    const split = splitFrontmatter(source);
+    if (split.raw === undefined) {
+        return {
+            frontmatter: {},
+            body: split.body
+        };
+    }
+    return {
+        frontmatter: parseYamlFrontmatter(split.raw, options),
+        body: split.body
+    };
+}
+export function parseFrontmatterDocument(source, options = {}) {
+    const split = splitFrontmatter(source);
+    const lineCounter = new LineCounter();
+    if (split.raw === undefined) {
+        return {
+            frontmatter: {},
+            body: split.body,
+            errors: [],
+            lineCounter
+        };
+    }
+    const document = parseDocument(normalizeYamlLineEndings(split.raw), {
+        lineCounter,
+        prettyErrors: false,
+        uniqueKeys: options.uniqueKeys ?? false
+    });
+    const errors = document.errors.map((error) => ({
+        message: error.message,
+        ...(error.pos === undefined ? {} : { pos: error.pos })
+    }));
+    if (errors.length > 0) {
+        return {
+            frontmatter: {},
+            body: split.body,
+            errors,
+            lineCounter
+        };
+    }
+    return {
+        frontmatter: normalizeYamlFrontmatter(document.toJSON()),
+        body: split.body,
+        errors,
+        lineCounter
+    };
+}
+function splitFrontmatter(source) {
+    try {
+        return splitFrontmatterBlock(source);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new FrontmatterParseError(error.message);
+        }
+        throw error;
+    }
+}
+function parseYamlFrontmatter(yamlBlock, options) {
+    let parsed;
+    try {
+        parsed = parse(normalizeYamlLineEndings(yamlBlock), {
+            uniqueKeys: options.uniqueKeys ?? false
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown YAML parse error";
+        throw new FrontmatterParseError(`Invalid YAML frontmatter: ${message}`);
+    }
+    return normalizeYamlFrontmatter(parsed);
+}
+function normalizeYamlLineEndings(value) {
+    if (!value.includes("\r")) {
+        return value;
+    }
+    let normalized = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (character !== "\r") {
+            normalized += character;
+            continue;
+        }
+        if (value[index + 1] === "\n") {
+            normalized += "\r\n";
+            index += 1;
+            continue;
+        }
+        normalized += "\n";
+    }
+    return normalized;
+}
+function normalizeYamlFrontmatter(value) {
+    if (value === null || value === undefined) {
+        return {};
+    }
+    if (!isRecord(value)) {
+        throw new FrontmatterParseError("YAML frontmatter must parse to an object.");
+    }
+    return normalizeYamlValue(value);
+}
+function normalizeYamlValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeYamlValue(item));
+    }
+    if (!isPlainRecord(value)) {
+        return value;
+    }
+    const normalized = {};
+    for (const [key, entryValue] of Object.entries(value)) {
+        Object.defineProperty(normalized, key, {
+            configurable: true,
+            enumerable: true,
+            value: normalizeYamlValue(entryValue),
+            writable: true
+        });
+    }
+    return normalized;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPlainRecord(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/node_modules/@poe-code/frontmatter/dist/stringify.d.ts

@@ -0,0 +1 @@
+export declare function stringifyFrontmatter(frontmatter: Record<string, unknown>, body: string): string;

package/node_modules/@poe-code/frontmatter/dist/stringify.js

@@ -0,0 +1,35 @@
+import { stringify } from "yaml";
+import { FrontmatterParseError } from "./parse.js";
+export function stringifyFrontmatter(frontmatter, body) {
+    try {
+        assertAcyclic(frontmatter);
+        return `---\n${stringify(frontmatter, { aliasDuplicateObjects: false }).trimEnd()}\n---\n${body}`;
+    }
+    catch (error) {
+        if (error instanceof FrontmatterParseError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : "Unknown YAML stringify error";
+        throw new FrontmatterParseError(`Invalid YAML frontmatter: ${message}`);
+    }
+}
+function assertAcyclic(value, seen = new WeakSet()) {
+    if (typeof value !== "object" || value === null) {
+        return;
+    }
+    if (seen.has(value)) {
+        throw new FrontmatterParseError("Cannot stringify cyclic frontmatter.");
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            assertAcyclic(item, seen);
+        }
+    }
+    else {
+        for (const item of Object.values(value)) {
+            assertAcyclic(item, seen);
+        }
+    }
+    seen.delete(value);
+}

package/node_modules/@poe-code/frontmatter/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@poe-code/frontmatter",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc",
+    "test": "cd ../.. && vitest run packages/frontmatter/src",
+    "test:unit": "cd ../.. && vitest run packages/frontmatter/src"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "yaml": "^2.8.2"
+  }
+}

package/node_modules/mcp-oauth/dist/server/jwks-token-verifier.d.ts

@@ -3,6 +3,7 @@ export interface JwksTokenVerifierOptions {
     jwksUrl: string | URL;
     clockSkewSeconds?: number;
     allowedAlgorithms?: readonly string[];
+    jwksCacheTtlMs?: number;
     fetch?: FetchLike;
 }
 export interface JwksVerifiedAccessToken {