structformatter 0.1.2

package/dist/enforce/engine.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceJsonSchema = enforceJsonSchema;
+const parse_1 = require("../json/parse");
+const patch_1 = require("../patch/patch");
+const build_1 = require("../prompt/build");
+const errors_1 = require("../validate/errors");
+const errors_2 = require("./errors");
+function extractCandidateText(resp) {
+    const c = resp.choices?.[0];
+    const content = c?.message?.content;
+    return typeof content === 'string' ? content : null;
+}
+function finishReason(resp) {
+    const fr = resp.choices?.[0]?.finish_reason;
+    return typeof fr === 'string' ? fr : null;
+}
+function usageFrom(resp) {
+    const u = resp.usage ?? {};
+    return {
+        prompt_tokens: typeof u.prompt_tokens === 'number' ? u.prompt_tokens : 0,
+        completion_tokens: typeof u.completion_tokens === 'number' ? u.completion_tokens : 0,
+        total_tokens: typeof u.total_tokens === 'number' ? u.total_tokens : 0,
+    };
+}
+function addUsage(a, b) {
+    return {
+        prompt_tokens: a.prompt_tokens + b.prompt_tokens,
+        completion_tokens: a.completion_tokens + b.completion_tokens,
+        total_tokens: a.total_tokens + b.total_tokens,
+    };
+}
+async function enforceJsonSchema(args) {
+    const validate = args.validatorCache.get(args.schema);
+    let lastCandidate;
+    let lastErrors;
+    let usage = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+    const traces = [];
+    for (let attempt = 1; attempt <= args.policy.maxAttempts; attempt++) {
+        const messages = (0, build_1.buildMessages)({
+            original: args.originalRequest.messages,
+            schema: args.schema,
+            attempt,
+            lastCandidate,
+            lastErrors,
+        });
+        const req = {
+            ...args.originalRequest,
+            model: args.upstreamModel,
+            messages,
+            stream: false,
+        };
+        // Prefer upstream JSON mode to reduce syntax errors.
+        if (args.adapter.supports.json_object)
+            req.response_format = { type: 'json_object' };
+        else
+            delete req.response_format;
+        const ctx = {
+            requestId: args.requestId,
+            timeoutMs: args.policy.timeoutMsPerAttempt,
+            provider: args.provider,
+            baseUrl: args.baseUrl,
+            upstreamModel: args.upstreamModel,
+        };
+        let upstreamResp;
+        try {
+            upstreamResp = await args.adapter.chatCompletions(req, ctx);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            traces.push({ attempt, kind: 'upstream_error', message: msg });
+            return (0, errors_2.upstreamError)({
+                message: msg,
+                attempts: attempt,
+                attemptTraces: args.debug ? traces : undefined,
+            });
+        }
+        usage = addUsage(usage, usageFrom(upstreamResp));
+        const fr = finishReason(upstreamResp);
+        if (fr === 'refusal' || fr === 'content_filter') {
+            traces.push({ attempt, kind: 'refusal', finish_reason: fr });
+            return (0, errors_2.refusalError)({
+                finishReason: fr,
+                attempts: attempt,
+                attemptTraces: args.debug ? traces : undefined,
+            });
+        }
+        const candidateText = extractCandidateText(upstreamResp);
+        if (!candidateText) {
+            lastCandidate = undefined;
+            lastErrors = [{ path: '/', keyword: 'parse', message: 'missing assistant content' }];
+            traces.push({ attempt, kind: 'no_content' });
+            continue;
+        }
+        const parsed = (0, parse_1.tryParseJson)(candidateText, { enableRepair: args.policy.enableJsonRepair });
+        if (!parsed.ok) {
+            lastCandidate = undefined;
+            lastErrors = [{ path: '/', keyword: 'parse', message: parsed.error }];
+            traces.push({ attempt, kind: 'parse_error', error: parsed.error });
+            continue;
+        }
+        const candidateObj = parsed.value;
+        const valid = validate(candidateObj);
+        if (valid) {
+            const jsonText = JSON.stringify(candidateObj);
+            traces.push({ attempt, kind: 'ok' });
+            return {
+                ok: true,
+                json: candidateObj,
+                jsonText,
+                usage,
+                attempts: attempt,
+                attemptTraces: args.debug ? traces : undefined,
+            };
+        }
+        let errors = (0, errors_1.summarizeAjvErrors)(validate.errors);
+        let finalCandidate = candidateObj;
+        if (args.policy.enableDeterministicFix) {
+            const patched = (0, patch_1.patchToSchema)(args.schema, candidateObj, {
+                enableTypeCoercion: args.policy.enableTypeCoercion,
+            });
+            const valid2 = validate(patched);
+            if (valid2) {
+                const jsonText = JSON.stringify(patched);
+                traces.push({ attempt, kind: 'patched_ok' });
+                return {
+                    ok: true,
+                    json: patched,
+                    jsonText,
+                    usage,
+                    attempts: attempt,
+                    attemptTraces: args.debug ? traces : undefined,
+                };
+            }
+            errors = (0, errors_1.summarizeAjvErrors)(validate.errors);
+            finalCandidate = patched;
+        }
+        lastCandidate = finalCandidate;
+        lastErrors = errors;
+        traces.push({ attempt, kind: 'schema_invalid', errors });
+    }
+    const excerpt = lastCandidate ? JSON.stringify(lastCandidate).slice(0, 500) : '';
+    return (0, errors_2.structuredOutputFailed)({
+        attempts: args.policy.maxAttempts,
+        lastCandidateExcerpt: excerpt,
+        validationErrors: lastErrors ?? [],
+        attemptTraces: args.debug ? traces : undefined,
+    });
+}

package/dist/enforce/errors.d.ts

@@ -0,0 +1,18 @@
+import type { StructuredError } from '../types/internal';
+import type { ValidationErrorSummary } from '../validate/errors';
+export declare function structuredOutputFailed(args: {
+    attempts: number;
+    lastCandidateExcerpt: string;
+    validationErrors: ValidationErrorSummary[];
+    attemptTraces?: unknown[];
+}): StructuredError;
+export declare function upstreamError(args: {
+    message: string;
+    attempts: number;
+    attemptTraces?: unknown[];
+}): StructuredError;
+export declare function refusalError(args: {
+    finishReason: string;
+    attempts: number;
+    attemptTraces?: unknown[];
+}): StructuredError;

package/dist/enforce/errors.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.structuredOutputFailed = structuredOutputFailed;
+exports.upstreamError = upstreamError;
+exports.refusalError = refusalError;
+function structuredOutputFailed(args) {
+    return {
+        ok: false,
+        attempts: args.attempts,
+        attemptTraces: args.attemptTraces,
+        error: {
+            type: 'structured_output_failed',
+            message: `Failed to produce schema-valid JSON after ${args.attempts} attempts`,
+            details: {
+                attempts: args.attempts,
+                last_candidate_excerpt: args.lastCandidateExcerpt,
+                validation_errors: args.validationErrors,
+            },
+        },
+    };
+}
+function upstreamError(args) {
+    return {
+        ok: false,
+        attempts: args.attempts,
+        attemptTraces: args.attemptTraces,
+        error: { type: 'upstream_error', message: args.message, details: { attempts: args.attempts } },
+    };
+}
+function refusalError(args) {
+    return {
+        ok: false,
+        attempts: args.attempts,
+        attemptTraces: args.attemptTraces,
+        error: {
+            type: 'refusal',
+            message: 'Upstream refused to answer',
+            details: { finish_reason: args.finishReason, attempts: args.attempts },
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { loadConfig, summarizeConfig } from './config/load';
+export type { AppConfig } from './config/schema';
+export { createServer } from './server';

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = exports.summarizeConfig = exports.loadConfig = void 0;
+var load_1 = require("./config/load");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return load_1.loadConfig; } });
+Object.defineProperty(exports, "summarizeConfig", { enumerable: true, get: function () { return load_1.summarizeConfig; } });
+var server_1 = require("./server");
+Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_1.createServer; } });

package/dist/json/extract.d.ts

@@ -0,0 +1,2 @@
+export declare function stripCodeFences(text: string): string;
+export declare function extractJsonCandidates(text: string): string[];

package/dist/json/extract.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripCodeFences = stripCodeFences;
+exports.extractJsonCandidates = extractJsonCandidates;
+const FENCE_RE = /```[a-zA-Z0-9_-]*\s*([\s\S]*?)```/gi;
+function stripCodeFences(text) {
+    const matches = [...text.matchAll(FENCE_RE)];
+    if (!matches.length)
+        return text;
+    const biggest = matches.reduce((a, b) => ((a[1]?.length ?? 0) >= (b[1]?.length ?? 0) ? a : b));
+    return biggest[1] ?? text;
+}
+function extractJsonCandidates(text) {
+    const cleaned = stripCodeFences(text).trim();
+    const candidates = [];
+    for (const [startChar, endChar] of [
+        ['{', '}'],
+        ['[', ']'],
+    ]) {
+        const start = cleaned.indexOf(startChar);
+        const end = cleaned.lastIndexOf(endChar);
+        if (start >= 0 && end > start)
+            candidates.push(cleaned.slice(start, end + 1).trim());
+    }
+    candidates.sort((a, b) => b.length - a.length);
+    return candidates;
+}

package/dist/json/parse.d.ts

@@ -0,0 +1,10 @@
+export type ParseResult = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function tryParseJson(text: string, opts: {
+    enableRepair: boolean;
+}): ParseResult;

package/dist/json/parse.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryParseJson = tryParseJson;
+const jsonrepair_1 = require("jsonrepair");
+const extract_1 = require("./extract");
+function tryParseJson(text, opts) {
+    const candidates = (0, extract_1.extractJsonCandidates)(text);
+    const all = candidates.length ? candidates : [text.trim()];
+    let lastError = 'failed to parse JSON';
+    for (const c of all) {
+        try {
+            return { ok: true, value: JSON.parse(c) };
+        }
+        catch (e) {
+            lastError = e instanceof Error ? e.message : String(e);
+        }
+        if (opts.enableRepair) {
+            try {
+                const repaired = (0, jsonrepair_1.jsonrepair)(c);
+                return { ok: true, value: JSON.parse(repaired) };
+            }
+            catch (e) {
+                lastError = e instanceof Error ? e.message : String(e);
+            }
+        }
+    }
+    return { ok: false, error: lastError };
+}

package/dist/patch/patch.d.ts

@@ -0,0 +1,3 @@
+export declare function patchToSchema(schema: unknown, value: unknown, opts: {
+    enableTypeCoercion: boolean;
+}): unknown;

package/dist/patch/patch.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchToSchema = patchToSchema;
+function schemaExpectsType(schema, expected) {
+    if (!schema || typeof schema !== 'object')
+        return false;
+    const t = schema.type;
+    if (typeof t === 'string')
+        return t === expected;
+    if (Array.isArray(t))
+        return t.includes(expected);
+    return false;
+}
+function coercePrimitive(schema, value) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === 'string' && schemaExpectsType(schema, 'integer')) {
+        const s = value.trim();
+        if (/^[+-]?\d+$/.test(s)) {
+            const n = Number(s);
+            if (Number.isSafeInteger(n))
+                return n;
+        }
+    }
+    if (typeof value === 'string' && schemaExpectsType(schema, 'number')) {
+        const s = value.trim();
+        if (/^[+-]?(?:\d+\.?\d*|\d*\.?\d+)(?:[eE][+-]?\d+)?$/.test(s)) {
+            const n = Number(s);
+            if (Number.isFinite(n))
+                return n;
+        }
+    }
+    if (typeof value === 'string' && schemaExpectsType(schema, 'boolean')) {
+        const s = value.trim().toLowerCase();
+        if (s === 'true')
+            return true;
+        if (s === 'false')
+            return false;
+    }
+    return value;
+}
+function patchToSchema(schema, value, opts) {
+    if (!schema || typeof schema !== 'object')
+        return value;
+    const patchedValue = opts.enableTypeCoercion ? coercePrimitive(schema, value) : value;
+    if (schemaExpectsType(schema, 'object') && patchedValue && typeof patchedValue === 'object') {
+        if (Array.isArray(patchedValue))
+            return patchedValue;
+        const s = schema;
+        const props = (s.properties && typeof s.properties === 'object' ? s.properties : {});
+        const additionalAllowed = s.additionalProperties !== false;
+        const out = {};
+        for (const [k, v] of Object.entries(patchedValue)) {
+            if (!additionalAllowed && !(k in props))
+                continue;
+            const childSchema = props[k];
+            out[k] =
+                childSchema && typeof childSchema === 'object'
+                    ? patchToSchema(childSchema, v, opts)
+                    : v;
+        }
+        return out;
+    }
+    if (schemaExpectsType(schema, 'array') && Array.isArray(patchedValue)) {
+        const s = schema;
+        const items = s.items;
+        if (items && typeof items === 'object') {
+            return patchedValue.map((v) => patchToSchema(items, v, opts));
+        }
+        return patchedValue;
+    }
+    return patchedValue;
+}

package/dist/prompt/build.d.ts

@@ -0,0 +1,9 @@
+import type { OpenAIChatMessage } from '../types/openai';
+import type { ValidationErrorSummary } from '../validate/errors';
+export declare function buildMessages(args: {
+    original: OpenAIChatMessage[];
+    schema: Record<string, unknown>;
+    attempt: number;
+    lastCandidate?: unknown;
+    lastErrors?: ValidationErrorSummary[];
+}): OpenAIChatMessage[];

package/dist/prompt/build.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMessages = buildMessages;
+const sanitize_schema_1 = require("./sanitize_schema");
+const templates_1 = require("./templates");
+function formatErrors(errors) {
+    if (!errors?.length)
+        return '(none)';
+    return errors.slice(0, 50).map((e) => `- ${e.path}: ${e.message}`).join('\n');
+}
+function buildMessages(args) {
+    const schemaJson = JSON.stringify((0, sanitize_schema_1.sanitizeSchemaForPrompt)(args.schema), null, 0);
+    const system = args.attempt === 1
+        ? (0, templates_1.firstAttemptSystemPrompt)(schemaJson)
+        : (0, templates_1.reaskSystemPrompt)({
+            schemaJson,
+            lastCandidateJson: JSON.stringify(args.lastCandidate ?? null),
+            errorsText: formatErrors(args.lastErrors),
+        });
+    return [{ role: 'system', content: system }, ...args.original];
+}

package/dist/prompt/sanitize_schema.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeSchemaForPrompt(value: unknown): unknown;

package/dist/prompt/sanitize_schema.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeSchemaForPrompt = sanitizeSchemaForPrompt;
+const DROP_KEYS = new Set([
+    'title',
+    'description',
+    'examples',
+    'default',
+    'deprecated',
+    'readOnly',
+    'writeOnly',
+]);
+function sanitizeSchemaForPrompt(value) {
+    if (Array.isArray(value))
+        return value.map(sanitizeSchemaForPrompt);
+    if (!value || typeof value !== 'object')
+        return value;
+    const obj = value;
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (DROP_KEYS.has(k))
+            continue;
+        out[k] = sanitizeSchemaForPrompt(v);
+    }
+    return out;
+}

package/dist/prompt/templates.d.ts

@@ -0,0 +1,6 @@
+export declare function firstAttemptSystemPrompt(schemaJson: string): string;
+export declare function reaskSystemPrompt(args: {
+    schemaJson: string;
+    lastCandidateJson: string;
+    errorsText: string;
+}): string;

package/dist/prompt/templates.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstAttemptSystemPrompt = firstAttemptSystemPrompt;
+exports.reaskSystemPrompt = reaskSystemPrompt;
+function firstAttemptSystemPrompt(schemaJson) {
+    return [
+        'You MUST output ONLY valid JSON (no markdown, no code fences, no explanation).',
+        'The JSON MUST conform to the following JSON Schema:',
+        schemaJson,
+    ].join('\n');
+}
+function reaskSystemPrompt(args) {
+    return [
+        'You previously returned JSON that failed validation.',
+        'Return ONLY corrected JSON that conforms to the schema.',
+        'Do NOT add any keys not present in schema.',
+        'Do NOT include markdown.',
+        '',
+        'Schema:',
+        args.schemaJson,
+        '',
+        'Previous JSON:',
+        args.lastCandidateJson,
+        '',
+        'Validation errors:',
+        args.errorsText,
+    ].join('\n');
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,12 @@
+import type { AppConfig } from '../config/schema';
+import type { ProviderAdapter } from '../types/internal';
+export interface ResolvedModel {
+    provider: string;
+    upstreamModel: string;
+    routedModel: string;
+    requestedModel: string;
+}
+export declare function resolveModel(requestedModel: string, config: AppConfig): ResolvedModel;
+export declare function listModelIds(config: AppConfig): string[];
+export declare function createProviderRegistry(config: AppConfig): Map<string, ProviderAdapter>;
+export declare function getAdapter(registry: Map<string, ProviderAdapter>, providerName: string): ProviderAdapter;

package/dist/providers/index.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveModel = resolveModel;
+exports.listModelIds = listModelIds;
+exports.createProviderRegistry = createProviderRegistry;
+exports.getAdapter = getAdapter;
+const openai_compatible_1 = require("./openai_compatible");
+function resolveModel(requestedModel, config) {
+    const routed = config.routing.model_aliases[requestedModel] ?? requestedModel;
+    const idx = routed.indexOf('/');
+    if (idx <= 0 || idx === routed.length - 1) {
+        throw new Error('model must be "provider/model" (or mapped by routing.model_aliases)');
+    }
+    const provider = routed.slice(0, idx);
+    const upstreamModel = routed.slice(idx + 1);
+    return { provider, upstreamModel, routedModel: routed, requestedModel };
+}
+function listModelIds(config) {
+    const ids = new Set();
+    for (const [alias, routed] of Object.entries(config.routing.model_aliases)) {
+        ids.add(alias);
+        ids.add(routed);
+    }
+    return [...ids].sort();
+}
+function createProviderRegistry(config) {
+    const adapters = new Map();
+    for (const [name, providerCfg] of Object.entries(config.providers)) {
+        if (providerCfg.type === 'openai_compatible') {
+            adapters.set(name, new openai_compatible_1.OpenAICompatibleAdapter(name, providerCfg));
+            continue;
+        }
+        throw new Error(`Unsupported provider type: ${providerCfg.type}`);
+    }
+    return adapters;
+}
+function getAdapter(registry, providerName) {
+    const adapter = registry.get(providerName);
+    if (!adapter)
+        throw new Error(`Unknown provider: ${providerName}`);
+    return adapter;
+}

package/dist/providers/openai_compatible.d.ts

@@ -0,0 +1,22 @@
+import { fetch } from 'undici';
+import type { ProviderConfig } from '../config/schema';
+import type { OpenAIChatCompletionsRequest, OpenAIChatCompletionsResponse } from '../types/openai';
+import type { ProviderAdapter, RequestContext } from '../types/internal';
+export declare class UpstreamError extends Error {
+    readonly statusCode: number;
+    readonly bodyText: string;
+    constructor(statusCode: number, bodyText: string);
+}
+export declare class OpenAICompatibleAdapter implements ProviderAdapter {
+    readonly name: string;
+    readonly supports: ProviderConfig['capabilities'];
+    private readonly cfg;
+    private readonly agent;
+    constructor(name: string, cfg: ProviderConfig);
+    chatCompletionsRaw(req: OpenAIChatCompletionsRequest, ctx: RequestContext): Promise<{
+        response: Awaited<ReturnType<typeof fetch>>;
+        abort: () => void;
+        cleanup: () => void;
+    }>;
+    chatCompletions(req: OpenAIChatCompletionsRequest, ctx: RequestContext): Promise<OpenAIChatCompletionsResponse>;
+}

package/dist/providers/openai_compatible.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICompatibleAdapter = exports.UpstreamError = void 0;
+const undici_1 = require("undici");
+class UpstreamError extends Error {
+    statusCode;
+    bodyText;
+    constructor(statusCode, bodyText) {
+        super(`Upstream error ${statusCode}: ${bodyText}`);
+        this.statusCode = statusCode;
+        this.bodyText = bodyText;
+    }
+}
+exports.UpstreamError = UpstreamError;
+function chatCompletionsUrl(baseUrl) {
+    const trimmed = baseUrl.replace(/\/+$/, '');
+    if (trimmed.endsWith('/v1'))
+        return `${trimmed}/chat/completions`;
+    return `${trimmed}/v1/chat/completions`;
+}
+function dropParams(req, keys) {
+    if (!keys.length)
+        return req;
+    const out = { ...req };
+    for (const k of keys)
+        delete out[k];
+    return out;
+}
+class OpenAICompatibleAdapter {
+    name;
+    supports;
+    cfg;
+    agent;
+    constructor(name, cfg) {
+        this.name = name;
+        this.cfg = cfg;
+        this.supports = cfg.capabilities;
+        this.agent = new undici_1.Agent({ keepAliveTimeout: 60_000, keepAliveMaxTimeout: 60_000 });
+    }
+    async chatCompletionsRaw(req, ctx) {
+        const url = chatCompletionsUrl(this.cfg.base_url);
+        const headers = {
+            'Content-Type': 'application/json',
+            ...this.cfg.default_headers,
+        };
+        if (this.cfg.api_key_env && !headers.Authorization) {
+            const apiKey = process.env[this.cfg.api_key_env];
+            if (apiKey)
+                headers.Authorization = `Bearer ${apiKey}`;
+        }
+        const upstreamReq = dropParams(req, this.cfg.drop_params);
+        const ac = new AbortController();
+        const t = setTimeout(() => ac.abort(), ctx.timeoutMs);
+        t.unref?.();
+        let resp;
+        try {
+            resp = await (0, undici_1.fetch)(url, {
+                dispatcher: this.agent,
+                method: 'POST',
+                headers,
+                body: JSON.stringify(upstreamReq),
+                signal: ac.signal,
+            });
+        }
+        catch (e) {
+            clearTimeout(t);
+            throw e;
+        }
+        if (!resp.ok) {
+            const text = await resp.text();
+            clearTimeout(t);
+            throw new UpstreamError(resp.status, text);
+        }
+        return {
+            response: resp,
+            abort: () => ac.abort(),
+            cleanup: () => clearTimeout(t),
+        };
+    }
+    async chatCompletions(req, ctx) {
+        const raw = await this.chatCompletionsRaw(req, ctx);
+        try {
+            const text = await raw.response.text();
+            return JSON.parse(text);
+        }
+        finally {
+            raw.cleanup();
+        }
+    }
+}
+exports.OpenAICompatibleAdapter = OpenAICompatibleAdapter;

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+import type { AppConfig } from './config/schema';
+export declare function createServer(config: AppConfig): import("fastify").FastifyInstance<import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>, import("node:http").IncomingMessage, import("node:http").ServerResponse<import("node:http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault> & PromiseLike<import("fastify").FastifyInstance<import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>, import("node:http").IncomingMessage, import("node:http").ServerResponse<import("node:http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>> & {
+    __linterBrands: "SafePromiseLike";
+};