@sezzlee/sdk-nestjs 0.0.0-stage → 0.2.0

package/dist/meta-tools.js

@@ -0,0 +1,306 @@
+import { catalogGenerationMetaKey, checkPinnedVersion, compose, createLoadedTool, emitGuarded as emitWithin, errorResult, invokeArgumentsDescription, invokeDescription, invokeVersionDescription, isInvokeError, knownFields, loadDescription, missingArgument, narrowingArguments, normalizeInvokeArguments, notInvocable, operationNameDescription, refuseTimedOutInvoke, refuseUnresolvedFile, resolveDeferred as resolveDeferredWith, searchCatalog, searchDescription, searchDetailDescription, searchLimitDescription, searchQueryDescription, searchTagsDescription, SezzleeArgumentError, SezzleeDispatchAborted, textResult, unknownTool, vocabularyOf, wrongArgumentType, defaultSearchLimit, describeRankerEvent, } from "@sezzlee/core";
+import { Logger } from "@nestjs/common";
+import { z } from "zod";
+import { SezzleeFileRefused } from "./files.js";
+import { callerOf } from "./options.js";
+import { currentOuterConnection } from "./outer-connection.js";
+export { catalogGenerationMetaKey };
+const logger = new Logger("Sezzlee");
+/**
+ * Guard: `name` binds as `unknown` and the object publishes its own `required`, so a call that
+ * misspells the argument reaches the handler instead of the framework's validator. The published
+ * schema is byte-identical to a plain `z.string()` one — `.meta` supplies the `type` the runtime
+ * no longer implies. Without this the MCP SDK answers with a bare text error that is not JSON, so
+ * the agent cannot parse it, the leak filter never runs, and the turn dies with nothing to repair
+ * from. Measured: a model called `load_tool` with `operation` instead of `name`. Pinned by
+ * test/meta-tools.spec.ts and by T19.
+ */
+function namedArgument(description) {
+    return z.unknown().optional().meta({ type: "string", description });
+}
+function timeoutFor(deps, target) {
+    const invoke = deps.options.invoke;
+    return invoke.timeoutMsFor?.(target) ?? invoke.timeoutMs;
+}
+function budgetFor(deps, target) {
+    const invoke = deps.options.invoke;
+    const override = target === undefined ? undefined : invoke.maxResponseBytesFor?.(target);
+    return override ?? invoke.maxResponseBytes;
+}
+function rankerFor(deps) {
+    const ranker = deps.catalog.ranker ?? null;
+    if (ranker === null) {
+        return {};
+    }
+    const { rankerTimeoutMs, onRankerFailure } = deps.options.search;
+    return {
+        ranker: {
+            ranker,
+            timeoutMs: rankerTimeoutMs,
+            onFailure: onRankerFailure,
+            report: (event) => {
+                const message = describeRankerEvent(event, onRankerFailure);
+                if (event.kind === "fallback" && event.error !== undefined) {
+                    logger.warn(message, event.error);
+                }
+                else {
+                    logger.warn(message);
+                }
+            },
+        },
+    };
+}
+/**
+ * The MCP call's cancellation channel, read separately from {@link outerFrom}.
+ *
+ * A stdio session has no `ctx.http`, so folding the signal into `OuterRequest` would either lose it
+ * there or synthesize an outer request that never existed — which would start calling the host's
+ * identity projector on a transport that carries no headers.
+ */
+function deadlineFrom(ctx) {
+    const signal = ctx?.mcpReq?.signal;
+    return signal === undefined ? undefined : { signal };
+}
+/**
+ * Guard: `ctx.http.req` is a Web `Request`, so its `Headers` has to be flattened into the Node
+ * record every identity carrier and value provider in this SDK reads. Iterating `Headers` already
+ * lower-cases each name and joins repeats with ", " — the same shape Node produces — so a carrier
+ * configured for `x-tenant-id` keeps matching across the v1 to v2 move.
+ */
+function headersOf(headers) {
+    const record = {};
+    for (const [name, value] of headers) {
+        record[name] = value;
+    }
+    return record;
+}
+function outerFrom(ctx) {
+    const request = ctx?.http?.req;
+    if (request === undefined) {
+        return undefined;
+    }
+    const connection = currentOuterConnection();
+    const auth = ctx?.http?.authInfo;
+    return {
+        headers: headersOf(request.headers),
+        ...(connection === undefined ? {} : { connection }),
+        ...(auth === undefined ? {} : { auth }),
+    };
+}
+function emitGuarded(deps, produce) {
+    return emitWithin((target) => budgetFor(deps, target), produce);
+}
+export function registerSezzleeTools(server, deps) {
+    const generationMeta = () => ({
+        [catalogGenerationMetaKey]: deps.catalog.generation,
+    });
+    server.registerTool("search_tools", {
+        description: searchDescription,
+        _meta: generationMeta(),
+        inputSchema: z.object({
+            query: z.string().default("").describe(searchQueryDescription),
+            limit: z
+                .number()
+                .int()
+                .default(defaultSearchLimit)
+                .describe(searchLimitDescription),
+            /**
+             * Guard: `.catch` is what makes an unrecognised `detail` fall back to `card`
+             * instead of failing validation. Without it zod rejects the call while the .NET
+             * SDK, whose `[AllowedValues]` only decorates the published schema, answers with
+             * cards — two SDKs disagreeing on one argument. It does not change the published
+             * schema, which still carries `enum` and `default`.
+             */
+            detail: z
+                .enum(["card", "schema"])
+                .catch("card")
+                .default("card")
+                .describe(searchDetailDescription),
+            /**
+             * Guard: `meta` publishes the `default: null` that the ASP.NET SDK emits for this argument
+             * and cannot omit, because a C# array parameter's default has to be a compile-time
+             * constant and `null` is the only one. Without it the two SDKs publish different schemas
+             * for the same argument, which search-semantics.md makes contract. It decorates the
+             * schema only; `parse` still yields `undefined` for an absent value. Pinned by T16 and by
+             * test/meta-tools.spec.ts.
+             */
+            tags: z
+                .array(z.string())
+                .describe(searchTagsDescription)
+                .optional()
+                .meta({ default: null }),
+        }),
+    }, async ({ query, limit, detail, tags }, ctx) => emitGuarded(deps, async () => {
+        deps.catalog.ensureValid();
+        const outer = outerFrom(ctx);
+        const decide = await decider(deps, outer);
+        const visibility = deps.options.visibility;
+        return searchCatalog({
+            catalog: deps.catalog.current,
+            query,
+            limit,
+            detail,
+            tags,
+            decide,
+            visible: (decision) => deps.visibility.visible(decision),
+            ...rankerFor(deps),
+            ...deadlineFrom(ctx),
+            ...(visibility.tier === "probe"
+                ? {
+                    probe: {
+                        budget: visibility.probeTopK,
+                        canProbe: (entry) => deps.visibility.canProbe(entry),
+                        run: (entry) => deps.visibility.probe(scopeFor(deps, outer), entry, outer),
+                    },
+                }
+                : {}),
+        });
+    }));
+    server.registerTool("load_tool", {
+        description: loadDescription,
+        _meta: generationMeta(),
+        inputSchema: z
+            .object({ name: namedArgument(operationNameDescription) })
+            .meta({ required: ["name"] }),
+    }, async ({ name }, ctx) => emitGuarded(deps, async () => {
+        if (name === undefined) {
+            return missingArgument("load_tool", "name");
+        }
+        if (typeof name !== "string") {
+            return wrongArgumentType("load_tool", "name", name);
+        }
+        deps.catalog.ensureValid();
+        const entry = deps.catalog.find(name);
+        if (entry === undefined) {
+            return unknownTool(name);
+        }
+        const outer = outerFrom(ctx);
+        const decide = await decider(deps, outer);
+        let decision = decide(entry);
+        if (decision === "unknown" &&
+            deps.options.visibility.tier === "probe" &&
+            deps.options.visibility.probeTopK > 0 &&
+            deps.visibility.canProbe(entry)) {
+            decision = await deps.visibility.probe(scopeFor(deps, outer), entry, outer);
+        }
+        if (!deps.visibility.visible(decision)) {
+            return unknownTool(name);
+        }
+        return textResult(createLoadedTool(entry.tool, decision), false);
+    }));
+    server.registerTool("invoke_tool", {
+        description: invokeDescription,
+        _meta: generationMeta(),
+        /**
+         * Guard: `arguments` publishes a description and no `type`, so a value that is not an object
+         * reaches the handler and leaves as an sezzlee envelope. A schema that constrained it was
+         * rejected during the framework's own argument binding, and the caller got an answer carrying
+         * neither the envelope nor the leak filter. Pinned by test/meta-tools.spec.ts and by T18.
+         */
+        inputSchema: z
+            .object({
+            name: namedArgument(operationNameDescription),
+            arguments: z.unknown().optional().meta({
+                description: invokeArgumentsDescription,
+            }),
+            /**
+             * Guard: `meta` publishes the `default: null` the ASP.NET SDK emits for this optional
+             * string and cannot omit, the same trap `tags` has. It binds as `unknown` so a value that
+             * is not a string reaches checkPinnedVersion and leaves as an envelope. Pinned by T18 and
+             * by test/meta-tools.spec.ts.
+             */
+            version: z.unknown().optional().meta({
+                type: "string",
+                description: invokeVersionDescription,
+                default: null,
+            }),
+        })
+            .meta({ required: ["name", "arguments"] }),
+    }, async ({ name, arguments: args, version }, ctx) => emitGuarded(deps, async () => {
+        if (name === undefined) {
+            return missingArgument("invoke_tool", "name");
+        }
+        if (typeof name !== "string") {
+            return wrongArgumentType("invoke_tool", "name", name);
+        }
+        deps.catalog.ensureValid();
+        const entry = deps.catalog.find(name);
+        if (entry === undefined) {
+            return unknownTool(name);
+        }
+        const stale = checkPinnedVersion(entry.tool, version);
+        if (stale !== undefined) {
+            return stale;
+        }
+        if (entry.template === undefined) {
+            return notInvocable(name);
+        }
+        const outer = outerFrom(ctx);
+        const normalized = normalizeInvokeArguments(args);
+        if (normalized.unwrapped) {
+            logger.warn(`invoke_tool received the arguments for '${name}' as JSON text instead of a JSON object; the text was parsed. A client that double-encodes this argument is defective.`);
+        }
+        /**
+         * Sources are resolved once per invocation and the same map feeds every composition, so a
+         * source that is not constant cannot make validation and dispatch disagree.
+         */
+        const target = {
+            tool: entry.tool.name,
+            method: entry.descriptor.method,
+            route: entry.descriptor.route,
+        };
+        const files = {
+            target,
+            maxInlineFileBytes: deps.options.invoke.maxInlineFileBytes,
+            maxFileBytes: deps.options.invoke.maxFileBytes,
+        };
+        let deferred;
+        try {
+            deferred = await resolveDeferredWith(entry.template, deps.options.arguments.providers, callerOf(outer));
+            compose(entry.template, normalized.value, deferred, {
+                maxInlineFileBytes: files.maxInlineFileBytes,
+            });
+        }
+        catch (error) {
+            if (error instanceof SezzleeArgumentError) {
+                return errorResult(error.code, error.message);
+            }
+            throw error;
+        }
+        const timeoutMs = timeoutFor(deps, target);
+        let result;
+        try {
+            result = await deps.dispatcher.dispatch(entry.template, normalized.value, outer, deferred, { ...deadlineFrom(ctx), timeoutMs }, files);
+        }
+        catch (error) {
+            if (error instanceof SezzleeDispatchAborted &&
+                error.reason === "timeout") {
+                return { payload: refuseTimedOutInvoke(timeoutMs), isError: true };
+            }
+            if (error instanceof SezzleeArgumentError) {
+                return errorResult(error.code, error.message);
+            }
+            if (error instanceof SezzleeFileRefused) {
+                return {
+                    payload: refuseUnresolvedFile(error.field, error.reason, error.limit),
+                    isError: true,
+                };
+            }
+            throw error;
+        }
+        const outcome = deps.mapper.map(result, knownFields(entry.tool), vocabularyOf(entry.template));
+        return textResult(outcome, isInvokeError(outcome), {
+            summaryOf: isInvokeError(outcome) ? outcome : outcome.body,
+            narrowing: narrowingArguments(entry.tool.inputSchema),
+            target,
+        });
+    }));
+}
+async function decider(deps, outer) {
+    const snapshot = deps.catalog.current;
+    const facts = await deps.visibility.facts(scopeFor(deps, outer), outer, snapshot.policyNames);
+    return (entry) => deps.visibility.decide(entry.descriptor.auth, facts);
+}
+function scopeFor(deps, outer) {
+    return deps.scopes.resolve(outer);
+}

package/dist/options-validation.d.ts

@@ -0,0 +1,17 @@
+import type { SezzleeOptions } from "./options.js";
+export declare class SezzleeConfigurationError extends Error {
+    readonly failures: readonly string[];
+    constructor(failures: readonly string[]);
+}
+/**
+ * Mirrors the ASP.NET `SezzleeOptionsValidator` so the two surfaces can be audited side by side.
+ *
+ * @param options the configured options
+ * @returns one message per invalid setting, empty when the configuration is usable
+ */
+export declare function collectConfigurationFailures(options: SezzleeOptions): readonly string[];
+/**
+ * @param options the configured options
+ * @throws SezzleeConfigurationError when any setting is unusable
+ */
+export declare function validateSezzleeOptions(options: SezzleeOptions): void;

package/dist/options-validation.js

@@ -0,0 +1,79 @@
+export class SezzleeConfigurationError extends Error {
+    failures;
+    constructor(failures) {
+        super(`sezzlee: invalid configuration.\n  ${failures.join("\n  ")}`);
+        this.failures = failures;
+        this.name = "SezzleeConfigurationError";
+    }
+}
+/**
+ * Mirrors the ASP.NET `SezzleeOptionsValidator` so the two surfaces can be audited side by side.
+ *
+ * @param options the configured options
+ * @returns one message per invalid setting, empty when the configuration is usable
+ */
+export function collectConfigurationFailures(options) {
+    const failures = [];
+    if (options.cache.lifetimeMs < 0) {
+        failures.push("cache.lifetimeMs must be zero or positive.");
+    }
+    if (options.cache.maxCallers < 1) {
+        failures.push("cache.maxCallers must be at least 1.");
+    }
+    if (options.visibility.probeTopK < 0) {
+        failures.push("visibility.probeTopK must be zero or positive.");
+    }
+    if (options.visibility.probeConcurrency < 1) {
+        failures.push("visibility.probeConcurrency must be at least 1.");
+    }
+    if (options.invoke.maxResponseBytes < 1) {
+        failures.push("invoke.maxResponseBytes must be at least 1.");
+    }
+    if (options.invoke.timeoutMs < 0) {
+        failures.push("invoke.timeoutMs must be zero or positive.");
+    }
+    if (options.invoke.maxInlineFileBytes < 0) {
+        failures.push("invoke.maxInlineFileBytes must be zero or positive.");
+    }
+    if (options.invoke.maxFileBytes < 1) {
+        failures.push("invoke.maxFileBytes must be at least 1.");
+    }
+    if (!Number.isInteger(options.search.rankerTimeoutMs) ||
+        options.search.rankerTimeoutMs < 0) {
+        failures.push("search.rankerTimeoutMs must be zero or a positive integer.");
+    }
+    if (!["fallback", "error"].includes(options.search.onRankerFailure)) {
+        failures.push('search.onRankerFailure must be "fallback" or "error".');
+    }
+    if (!Number.isInteger(options.families.loadTimeoutMs) ||
+        options.families.loadTimeoutMs < 1) {
+        failures.push("families.loadTimeoutMs must be a positive integer.");
+    }
+    const refDescription = options.files.resolver?.refDescription;
+    if (refDescription !== undefined && refDescription.trim() === "") {
+        failures.push("files.resolver.refDescription must say what a ref is; an agent reads it to find one.");
+    }
+    /**
+     * A blank field is not the catch-all: the catch-all omits the field, while `route: ""` matches
+     * only the empty string and no composed route is empty, so the rule would decide nothing.
+     */
+    (options.selection.rules ?? []).forEach((rule, position) => {
+        for (const field of ["route", "method"]) {
+            const value = rule[field];
+            if (value !== undefined && value.trim() === "") {
+                failures.push(`selection.rules[${position}].${field} must not be blank; omit it to match every ${field}.`);
+            }
+        }
+    });
+    return failures;
+}
+/**
+ * @param options the configured options
+ * @throws SezzleeConfigurationError when any setting is unusable
+ */
+export function validateSezzleeOptions(options) {
+    const failures = collectConfigurationFailures(options);
+    if (failures.length > 0) {
+        throw new SezzleeConfigurationError(failures);
+    }
+}

package/dist/options.d.ts

@@ -0,0 +1,201 @@
+import type { IncomingHttpHeaders } from "node:http";
+import type { OAuthTokenVerifier } from "@modelcontextprotocol/express";
+import type { RankerFailureMode, Recognizer, SelectionDefault, SelectionRule } from "@sezzlee/core";
+import type { ArgumentRule, JsonValue } from "./decorators.js";
+import type { CatalogSeverity } from "./discovery/diagnostics.js";
+import type { TypeShapeBinderOptions } from "./discovery/type-shape.js";
+import { ToolFamilyOptions } from "./families.js";
+import type { SezzleeFileOptions } from "./files.js";
+import type { OuterConnection } from "./outer-connection.js";
+export interface OuterRequest {
+    readonly headers: IncomingHttpHeaders;
+    readonly protocol?: string;
+    readonly connection?: OuterConnection;
+    /**
+     * The MCP transport's verified token, when `resourceServer` is configured.
+     *
+     * Without it a value provider sees headers only and decodes the token itself; the C# side reads
+     * `HttpContext.User` and always has one. The two platforms are not symmetric here.
+     */
+    readonly auth?: VerifiedToken;
+}
+export interface VerifiedToken {
+    readonly clientId?: string;
+    readonly scopes?: readonly string[];
+    readonly resource?: string | URL;
+    readonly expiresAt?: number;
+    readonly extra?: Readonly<Record<string, unknown>>;
+}
+/** What a value provider sees. */
+export interface McpCaller {
+    readonly subject?: string;
+    readonly clientId?: string;
+    readonly scopes: readonly string[];
+    readonly resource?: string;
+    readonly expiresAt?: Date;
+    claim(name: string): string | undefined;
+    header(name: string): string | undefined;
+}
+export declare function callerOf(outer: OuterRequest | undefined): McpCaller;
+export type ArgumentValueProvider = (caller: McpCaller) => JsonValue | undefined | Promise<JsonValue | undefined>;
+export interface CurationTarget {
+    readonly controller?: NewableFunction;
+    readonly handler?: string;
+    readonly method?: string;
+    /** Matched against the final descriptor route, after prefixes and versioning. */
+    readonly route?: string;
+}
+export interface CurationRule {
+    readonly target: CurationTarget;
+    readonly rules: Readonly<Record<string, ArgumentRule>>;
+    readonly sealed: boolean;
+    readonly specificity: number;
+}
+/**
+ * Central curation: rules for controllers the host cannot decorate, and rules that repeat.
+ *
+ * `seal` exists because plain "most specific wins" lets a method decorator defeat a tenancy rule.
+ * A sealed field cannot be overridden by any layer; attempting it is a build error.
+ */
+export declare class ArgumentCurationOptions {
+    private readonly valueProviders;
+    private readonly declarations;
+    get providers(): ReadonlyMap<string, ArgumentValueProvider>;
+    get rules(): readonly CurationRule[];
+    provide(name: string, provider: ArgumentValueProvider): this;
+    curate(target: CurationTarget, rules: Readonly<Record<string, ArgumentRule>>): this;
+    everywhere(rules: Readonly<Record<string, ArgumentRule>>): this;
+    seal(target: CurationTarget, rules: Readonly<Record<string, ArgumentRule>>): this;
+}
+export type SyntheticHeaders = Record<string, string>;
+export declare class IdentityForwardingOptions {
+    private readonly names;
+    projector?: (outer: OuterRequest, syntheticHeaders: SyntheticHeaders) => void;
+    get carriers(): ReadonlySet<string>;
+    forward(name: string): this;
+    clear(): this;
+    project(projector: (outer: OuterRequest, syntheticHeaders: SyntheticHeaders) => void): this;
+}
+export interface SyntheticRequestOptions {
+    host?: string;
+    scheme?: string;
+    accept?: string;
+    userAgent?: string;
+}
+export interface SezzleeCacheOptions {
+    lifetimeMs: number;
+    maxCallers: number;
+}
+/** What a per-endpoint budget or timeout override sees. */
+export interface InvokeTarget {
+    readonly tool: string;
+    readonly method: string;
+    readonly route: string;
+}
+export interface SezzleeInvokeOptions {
+    /** The largest tool response, in UTF-8 bytes, that may reach the agent. */
+    maxResponseBytes: number;
+    /**
+     * How long an invocation waits for the backend, in whole milliseconds. Zero means no deadline.
+     *
+     * Values at or above 60000 are unreachable through a stock MCP client, whose own request timeout
+     * (`DEFAULT_REQUEST_TIMEOUT_MSEC` in the TypeScript client) cancels first.
+     */
+    timeoutMs: number;
+    maxResponseBytesFor?: (target: InvokeTarget) => number | undefined;
+    timeoutMsFor?: (target: InvokeTarget) => number | undefined;
+    /** Decoded `base64` file bytes one call may carry inline. */
+    maxInlineFileBytes: number;
+    /** The bytes one resolved `ref` file may carry. */
+    maxFileBytes: number;
+}
+export declare class ErrorMappingOptions {
+    private readonly items;
+    get recognizers(): readonly Recognizer[];
+    recognize(recognizer: Recognizer): this;
+}
+export interface SezzleeResourceServerOptions {
+    resource: URL;
+    authorizationServers: URL[];
+    scopesSupported?: string[];
+    resourceName?: string;
+    verifier: OAuthTokenVerifier;
+    mcpPath?: string;
+}
+/**
+ * Config-level selection, for routes the host cannot or will not decorate.
+ *
+ * `rules` sits below both attribute levels and above `default`; order carries no meaning, and
+ * equally specific rules that disagree are a build error rather than a silent first-match win.
+ */
+export interface SezzleeSelectionOptions {
+    default: SelectionDefault;
+    rules?: readonly SelectionRule[];
+}
+/**
+ * How a named, object-typed query binding reaches the agent.
+ *
+ * `flatten` leaves today's binding alone; `group` publishes one object-valued
+ * argument the composer expands in the notation this SDK's backend parses. The
+ * default is `flatten` because switching rewrites the `inputSchema` of every
+ * affected tool and renames the namespace curation is keyed by.
+ */
+export interface SezzleeQueryOptions {
+    grouping: "flatten" | "group";
+}
+export interface SezzleeNamingOptions {
+    prefixMode: "always" | "onCollision";
+    prefix?: (container: string) => string | undefined;
+}
+export interface SezzleeDiagnosticsOptions {
+    failOn?: CatalogSeverity;
+    readonly escalate: Set<string>;
+    readonly downgrade: Set<string>;
+}
+/**
+ * How `search_tools` treats a ranker bound through `extensionTokens.toolRanker`.
+ *
+ * @param rankerTimeoutMs the ranker's deadline in whole milliseconds; zero means none
+ * @param onRankerFailure `fallback` ranks with BM25 and logs, `error` answers
+ * `search_ranker_unavailable`
+ */
+export interface SezzleeSearchOptions {
+    rankerTimeoutMs: number;
+    onRankerFailure: RankerFailureMode;
+}
+export type SezzleeVisibilityTier = "declarative" | "probe";
+export interface SezzleeVisibilityOptions {
+    tier: SezzleeVisibilityTier;
+    onUnknown: "show" | "hide";
+    probeTopK: number;
+    probeConcurrency: number;
+    readonly probeValues: Map<string, string>;
+}
+export declare class SezzleeOptions {
+    readonly identity: IdentityForwardingOptions;
+    readonly synthetic: SyntheticRequestOptions;
+    readonly cache: SezzleeCacheOptions;
+    readonly errors: ErrorMappingOptions;
+    readonly selection: SezzleeSelectionOptions;
+    readonly query: SezzleeQueryOptions;
+    readonly naming: SezzleeNamingOptions;
+    readonly diagnostics: SezzleeDiagnosticsOptions;
+    readonly arguments: ArgumentCurationOptions;
+    readonly families: ToolFamilyOptions;
+    readonly visibility: SezzleeVisibilityOptions;
+    readonly invoke: SezzleeInvokeOptions;
+    readonly search: SezzleeSearchOptions;
+    /** Binding `files.resolver` is what makes `ref` appear in a file argument's schema. */
+    readonly files: SezzleeFileOptions;
+    /**
+     * Grouping labels for a container the host cannot decorate. It sits below a `@McpTool({ tags })`
+     * declaration and above the container-derived default, and like a declaration it replaces that
+     * default rather than adding to it.
+     */
+    tags?: (container: string) => readonly string[] | undefined;
+    /** Search vocabulary for a container the host cannot decorate, below a `@McpTool({ searchTerms })`. */
+    searchTerms?: (container: string) => readonly string[] | undefined;
+    schema?: TypeShapeBinderOptions;
+    resourceServer?: SezzleeResourceServerOptions;
+}
+export declare const SEZZLEE_OPTIONS = "SEZZLEE_OPTIONS";