@velum-labs/cursorkit 0.1.0

package/dist/src/models/registry.js

@@ -0,0 +1,30 @@
+export class ModelRegistry {
+    models = new Map();
+    register(model) {
+        if (this.models.has(model.id)) {
+            throw new Error(`Model already registered: ${model.id}`);
+        }
+        this.models.set(model.id, model);
+    }
+    get(id) {
+        if (id === undefined) {
+            return undefined;
+        }
+        return this.models.get(id);
+    }
+    list() {
+        return Array.from(this.models.values());
+    }
+}
+export function registerConfiguredModels(registry, configs, providerFactory) {
+    for (const config of configs) {
+        registry.register({
+            id: config.id,
+            displayName: config.displayName,
+            baseUrl: config.baseUrl,
+            apiKey: config.apiKey,
+            contextTokenLimit: config.contextTokenLimit,
+            provider: providerFactory(config),
+        });
+    }
+}

package/dist/src/proto.d.ts

@@ -0,0 +1,13 @@
+import protobuf from "protobufjs";
+export interface CursorProto {
+    root: protobuf.Root;
+    AvailableModelsRequest: protobuf.Type;
+    AvailableModelsResponse: protobuf.Type;
+    StreamUnifiedChatRequestWithTools: protobuf.Type;
+    StreamUnifiedChatResponseWithTools: protobuf.Type;
+}
+export declare function loadCursorProto(): Promise<CursorProto>;
+export declare function resolveProtoDirectory(): string;
+export declare function listProtoFiles(directory: string): string[];
+export declare function encodeMessage(type: protobuf.Type, value: Record<string, unknown>): Buffer;
+export declare function decodeMessage(type: protobuf.Type, payload: Uint8Array): Record<string, unknown>;

package/dist/src/proto.js

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import protobuf from "protobufjs";
+const currentDir = path.dirname(fileURLToPath(import.meta.url));
+export async function loadCursorProto() {
+    const root = await protobuf.load(listProtoFiles(resolveProtoDirectory()));
+    return {
+        root,
+        AvailableModelsRequest: root.lookupType("aiserver.v1.AvailableModelsRequest"),
+        AvailableModelsResponse: root.lookupType("aiserver.v1.AvailableModelsResponse"),
+        StreamUnifiedChatRequestWithTools: root.lookupType("aiserver.v1.StreamUnifiedChatRequestWithTools"),
+        StreamUnifiedChatResponseWithTools: root.lookupType("aiserver.v1.StreamUnifiedChatResponseWithTools"),
+    };
+}
+export function resolveProtoDirectory() {
+    for (const candidate of candidateRoots()) {
+        const protoDir = path.join(candidate, "proto");
+        if (fs.existsSync(path.join(protoDir, "aiserver", "v1", "aiserver.proto"))) {
+            return protoDir;
+        }
+    }
+    throw new Error("Unable to locate proto/aiserver/v1/aiserver.proto");
+}
+export function listProtoFiles(directory) {
+    const entries = fs.readdirSync(directory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...listProtoFiles(fullPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".proto")) {
+            files.push(fullPath);
+        }
+    }
+    return files.sort();
+}
+export function encodeMessage(type, value) {
+    const error = type.verify(value);
+    if (error) {
+        throw new Error(`${type.fullName} verification failed: ${error}`);
+    }
+    return Buffer.from(type.encode(type.create(value)).finish());
+}
+export function decodeMessage(type, payload) {
+    return type.toObject(type.decode(payload), {
+        defaults: false,
+        longs: String,
+        enums: Number,
+        bytes: Buffer,
+    });
+}
+function candidateRoots() {
+    return [
+        process.cwd(),
+        path.resolve(currentDir, ".."),
+        path.resolve(currentDir, "..", ".."),
+        path.resolve(currentDir, "..", "..", ".."),
+    ];
+}

package/dist/src/providers/openai.d.ts

@@ -0,0 +1,64 @@
+import type { LocalModelConfig } from "../config.js";
+import type { Logger } from "../logger.js";
+import type { ModelProvider } from "../models/registry.js";
+export interface ChatMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    tool_call_id?: string;
+    tool_calls?: OpenAIToolCall[];
+}
+export interface OpenAIToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export interface OpenAIToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export type OpenAICompletionEvent = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_calls";
+    toolCalls: OpenAIToolCall[];
+};
+export type OpenAIBackendErrorCode = "http_error" | "malformed_sse" | "request_aborted" | "request_timeout";
+export interface OpenAIStreamOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    /**
+     * Observability correlation id forwarded to the model backend (gateway) as
+     * `x-fusion-trace-id`. The gateway honors it so the Cursor edge shares one
+     * observable session with the downstream fusion run.
+     */
+    traceId?: string;
+}
+export declare class OpenAIBackendError extends Error {
+    readonly code: OpenAIBackendErrorCode;
+    constructor(code: OpenAIBackendErrorCode, message: string, options?: ErrorOptions);
+}
+export declare class OpenAIStreamParseError extends OpenAIBackendError {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class OpenAICompatibleProvider implements ModelProvider {
+    private readonly config;
+    private readonly logger?;
+    private readonly options;
+    readonly name = "openai-compatible";
+    constructor(config: LocalModelConfig, logger?: Logger | undefined, options?: {
+        logFullPayload: boolean;
+    });
+    streamCompletion(messages: ChatMessage[], options?: OpenAIStreamOptions): AsyncGenerator<string>;
+    streamCompletionEvents(messages: ChatMessage[], tools?: OpenAIToolDefinition[], options?: OpenAIStreamOptions): AsyncGenerator<OpenAICompletionEvent>;
+}
+export declare function parseOpenAIStream(stream: AsyncIterable<Uint8Array>): AsyncGenerator<string | Extract<OpenAICompletionEvent, {
+    type: "tool_calls";
+}>>;

package/dist/src/providers/openai.js

@@ -0,0 +1,355 @@
+import { emitTrace, newSpanId, TRACE_ID_HEADER, TRACE_SPAN_HEADER, } from "../trace.js";
+export class OpenAIBackendError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = "OpenAIBackendError";
+    }
+}
+export class OpenAIStreamParseError extends OpenAIBackendError {
+    constructor(message, options) {
+        super("malformed_sse", message, options);
+        this.name = "OpenAIStreamParseError";
+    }
+}
+const DEFAULT_BACKEND_REQUEST_TIMEOUT_MS = 120_000;
+export class OpenAICompatibleProvider {
+    config;
+    logger;
+    options;
+    name = "openai-compatible";
+    constructor(config, logger, options = {
+        logFullPayload: false,
+    }) {
+        this.config = config;
+        this.logger = logger;
+        this.options = options;
+    }
+    async *streamCompletion(messages, options = {}) {
+        for await (const event of this.streamCompletionEvents(messages, [], options)) {
+            if (event.type === "text") {
+                yield event.text;
+            }
+        }
+    }
+    async *streamCompletionEvents(messages, tools = [], options = {}) {
+        if (this.config.hardcodedResponse !== undefined) {
+            this.logger?.info("model backend hardcoded response", {
+                modelId: this.config.id,
+                providerModel: this.config.providerModel,
+                responseChars: this.config.hardcodedResponse.length,
+            });
+            yield { type: "text", text: this.config.hardcodedResponse };
+            return;
+        }
+        const url = `${this.config.baseUrl.replace(/\/$/, "")}/chat/completions`;
+        const requestBody = {
+            model: this.config.providerModel,
+            messages,
+            stream: true,
+            ...(tools.length > 0 ? { tools } : {}),
+        };
+        const requestTimeoutMs = options.timeoutMs ??
+            this.config.requestTimeoutMs ??
+            DEFAULT_BACKEND_REQUEST_TIMEOUT_MS;
+        const traceId = options.traceId ?? process.env.FUSION_TRACE_ID ?? undefined;
+        const traceSpan = newSpanId();
+        const traceHeaders = traceId !== undefined
+            ? { [TRACE_ID_HEADER]: traceId, [TRACE_SPAN_HEADER]: traceSpan }
+            : {};
+        emitTrace({
+            event_type: "cursor.route",
+            traceId,
+            spanId: traceSpan,
+            modelId: this.config.id,
+            payload: {
+                message: "model backend request",
+                provider_model: this.config.providerModel,
+                url,
+                tool_count: tools.length,
+                message_count: messages.length,
+            },
+        });
+        this.logger?.info("model backend request", {
+            modelId: this.config.id,
+            providerModel: this.config.providerModel,
+            url,
+            stream: true,
+            requestTimeoutMs,
+            toolCount: tools.length,
+            toolNames: tools.map((tool) => tool.function.name),
+            ...summarizeMessages(messages),
+            ...(this.options.logFullPayload
+                ? {
+                    payload: requestBody,
+                }
+                : {}),
+        });
+        const started = Date.now();
+        const abortContext = createRequestAbortContext(requestTimeoutMs, options.signal);
+        let response;
+        try {
+            response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    connection: "close",
+                    "content-type": "application/json",
+                    ...(this.config.apiKey
+                        ? { authorization: `Bearer ${this.config.apiKey}` }
+                        : {}),
+                    ...traceHeaders,
+                },
+                body: JSON.stringify(requestBody),
+                signal: abortContext.signal,
+            });
+        }
+        catch (error) {
+            const classified = classifyBackendError(error, abortContext);
+            this.logger?.warn("model backend request failed", {
+                modelId: this.config.id,
+                providerModel: this.config.providerModel,
+                url,
+                durationMs: Date.now() - started,
+                error: classified instanceof Error ? classified.message : String(error),
+                code: classified instanceof OpenAIBackendError
+                    ? classified.code
+                    : undefined,
+                cause: error instanceof Error && error.cause instanceof Error
+                    ? error.cause.message
+                    : undefined,
+            });
+            abortContext.dispose();
+            throw classified;
+        }
+        if (!response.ok || response.body === null) {
+            const body = await response.text().catch(() => "");
+            const error = new OpenAIBackendError("http_error", `Model backend returned ${response.status}: ${body}`);
+            this.logger?.warn("model backend response failed", {
+                modelId: this.config.id,
+                providerModel: this.config.providerModel,
+                url,
+                status: response.status,
+                durationMs: Date.now() - started,
+                bodyPreview: body.slice(0, 500),
+                code: error.code,
+            });
+            abortContext.dispose();
+            throw error;
+        }
+        let chunkCount = 0;
+        let responseChars = 0;
+        try {
+            for await (const text of parseOpenAIStream(response.body)) {
+                if (typeof text === "string") {
+                    chunkCount += 1;
+                    responseChars += text.length;
+                    yield { type: "text", text };
+                }
+                else if (text.type === "tool_calls") {
+                    chunkCount += 1;
+                    yield text;
+                }
+            }
+            this.logger?.info("model backend response complete", {
+                modelId: this.config.id,
+                providerModel: this.config.providerModel,
+                url,
+                status: response.status,
+                durationMs: Date.now() - started,
+                chunkCount,
+                responseChars,
+            });
+            emitTrace({
+                event_type: "cursor.route",
+                traceId,
+                spanId: traceSpan,
+                modelId: this.config.id,
+                payload: {
+                    message: "model backend response complete",
+                    status: response.status,
+                    duration_ms: Date.now() - started,
+                    chunk_count: chunkCount,
+                    response_chars: responseChars,
+                },
+            });
+        }
+        catch (error) {
+            const classified = classifyBackendError(error, abortContext);
+            this.logger?.warn("model backend stream failed", {
+                modelId: this.config.id,
+                providerModel: this.config.providerModel,
+                url,
+                status: response.status,
+                durationMs: Date.now() - started,
+                chunkCount,
+                responseChars,
+                error: classified instanceof Error ? classified.message : String(error),
+                code: classified instanceof OpenAIBackendError
+                    ? classified.code
+                    : undefined,
+            });
+            throw classified;
+        }
+        finally {
+            abortContext.dispose();
+        }
+    }
+}
+function summarizeMessages(messages) {
+    return {
+        messageCount: messages.length,
+        messageRoles: messages.map((message) => message.role),
+        messageChars: messages.reduce((total, message) => total + message.content.length, 0),
+        firstMessagePreviewChars: messagePreviewChars(messages[0]?.content),
+        lastMessagePreviewChars: messagePreviewChars(messages.at(-1)?.content),
+    };
+}
+function messagePreviewChars(value) {
+    return value === undefined
+        ? undefined
+        : value.replace(/\s+/g, " ").trim().slice(0, 500).length;
+}
+function preview(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return value.replace(/\s+/g, " ").trim().slice(0, 500);
+}
+export async function* parseOpenAIStream(stream) {
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let buffer = "";
+    const state = {
+        done: false,
+        toolCalls: new Map(),
+    };
+    for await (const chunk of stream) {
+        buffer += decodeStreamText(decoder, chunk, true);
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? "";
+        yield* parseSseLines(lines, state);
+        if (state.done) {
+            return;
+        }
+    }
+    buffer += decodeStreamText(decoder, undefined, false);
+    if (buffer.length > 0 && !state.done) {
+        yield* parseSseLines(buffer.split(/\r?\n/), state);
+    }
+}
+function* parseSseLines(lines, state) {
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0 || trimmed.startsWith(":")) {
+            continue;
+        }
+        if (!trimmed.startsWith("data:")) {
+            continue;
+        }
+        const data = trimmed.slice("data:".length).trim();
+        if (data.length === 0) {
+            continue;
+        }
+        if (data === "[DONE]") {
+            state.done = true;
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(data);
+        }
+        catch (error) {
+            throw new OpenAIStreamParseError(`OpenAI stream contained malformed JSON data: ${preview(data)}`, error instanceof Error ? { cause: error } : undefined);
+        }
+        const content = parsed.choices?.[0]?.delta?.content;
+        if (typeof content === "string" && content.length > 0) {
+            yield content;
+        }
+        const deltas = parsed.choices?.[0]?.delta?.tool_calls;
+        if (Array.isArray(deltas)) {
+            mergeToolCallDeltas(state.toolCalls, deltas);
+        }
+        if (parsed.choices?.[0]?.finish_reason === "tool_calls") {
+            yield {
+                type: "tool_calls",
+                toolCalls: Array.from(state.toolCalls.values()),
+            };
+            state.toolCalls.clear();
+        }
+    }
+}
+function mergeToolCallDeltas(toolCalls, deltas) {
+    for (const delta of deltas) {
+        const index = delta.index ?? toolCalls.size;
+        const current = toolCalls.get(index) ??
+            {
+                id: delta.id ?? `tool-${String(index)}`,
+                type: "function",
+                function: { name: "", arguments: "" },
+            };
+        if (delta.id !== undefined) {
+            current.id = delta.id;
+        }
+        if (delta.type === "function") {
+            current.type = "function";
+        }
+        if (delta.function?.name !== undefined) {
+            current.function.name += delta.function.name;
+        }
+        if (delta.function?.arguments !== undefined) {
+            current.function.arguments += delta.function.arguments;
+        }
+        toolCalls.set(index, current);
+    }
+}
+function decodeStreamText(decoder, chunk, stream) {
+    try {
+        return chunk === undefined
+            ? decoder.decode()
+            : decoder.decode(chunk, { stream });
+    }
+    catch (error) {
+        throw new OpenAIStreamParseError("OpenAI stream contained malformed UTF-8", error instanceof Error ? { cause: error } : undefined);
+    }
+}
+function createRequestAbortContext(timeoutMs, upstreamSignal) {
+    const controller = new AbortController();
+    let didTimeout = false;
+    const timer = setTimeout(() => {
+        didTimeout = true;
+        controller.abort();
+    }, timeoutMs);
+    const abortFromUpstream = () => controller.abort();
+    if (upstreamSignal !== undefined) {
+        if (upstreamSignal.aborted) {
+            controller.abort();
+        }
+        else {
+            upstreamSignal.addEventListener("abort", abortFromUpstream, {
+                once: true,
+            });
+        }
+    }
+    return {
+        signal: controller.signal,
+        timedOut: () => didTimeout,
+        dispose: () => {
+            clearTimeout(timer);
+            upstreamSignal?.removeEventListener("abort", abortFromUpstream);
+        },
+    };
+}
+function classifyBackendError(error, abortContext) {
+    if (error instanceof OpenAIBackendError) {
+        return error;
+    }
+    if (abortContext.signal.aborted) {
+        const code = abortContext.timedOut()
+            ? "request_timeout"
+            : "request_aborted";
+        return new OpenAIBackendError(code, code === "request_timeout"
+            ? "Model backend request timed out"
+            : "Model backend request was aborted", error instanceof Error ? { cause: error } : undefined);
+    }
+    return error;
+}

package/dist/src/redaction.d.ts

@@ -0,0 +1,4 @@
+export declare function redactValue(value: string): string;
+export declare function redactHeaders(headers: Headers | NodeJS.Dict<string | string[] | undefined>): Record<string, string>;
+export declare function redactHeaderValue(name: string, value: string): string;
+export declare function redactForLogging(value: unknown): unknown;

package/dist/src/redaction.js

@@ -0,0 +1,65 @@
+const SENSITIVE_HEADER_NAMES = new Set([
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "x-cursor-token",
+    "x-api-key",
+    "api-key",
+]);
+const SENSITIVE_OBJECT_KEY_PATTERN = /authorization|cookie|set-cookie|x-cursor-token|x-api-key|api[-_]?key|(?:^|[-_])token$|access[-_]?token|secret|password/i;
+const SECRET_VALUE_PATTERN = /(bearer\s+)[a-z0-9._~+/-]+|([?&](?:token|key|api_key|access_token)=)[^&\s]+/gi;
+export function redactValue(value) {
+    return value.replace(SECRET_VALUE_PATTERN, (_match, bearerPrefix, queryPrefix) => {
+        if (bearerPrefix !== undefined) {
+            return `${bearerPrefix}[REDACTED]`;
+        }
+        if (queryPrefix !== undefined) {
+            return `${queryPrefix}[REDACTED]`;
+        }
+        return "[REDACTED]";
+    });
+}
+export function redactHeaders(headers) {
+    const result = {};
+    if (headers instanceof Headers) {
+        headers.forEach((value, key) => {
+            result[key] = redactHeaderValue(key, value);
+        });
+        return result;
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        if (value === undefined) {
+            continue;
+        }
+        result[key] = redactHeaderValue(key, Array.isArray(value) ? value.join(", ") : value);
+    }
+    return result;
+}
+export function redactHeaderValue(name, value) {
+    if (SENSITIVE_HEADER_NAMES.has(name.toLowerCase())) {
+        return "[REDACTED]";
+    }
+    return redactValue(value);
+}
+export function redactForLogging(value) {
+    return redactObjectValue(value, undefined);
+}
+function redactObjectValue(value, key) {
+    if (key !== undefined && SENSITIVE_OBJECT_KEY_PATTERN.test(key)) {
+        return "[REDACTED]";
+    }
+    if (typeof value === "string") {
+        return redactValue(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => redactObjectValue(item, undefined));
+    }
+    if (typeof value !== "object" || value === null) {
+        return value;
+    }
+    const result = {};
+    for (const [entryKey, entryValue] of Object.entries(value)) {
+        result[entryKey] = redactObjectValue(entryValue, entryKey);
+    }
+    return result;
+}

package/dist/src/routeInventory.d.ts

@@ -0,0 +1,16 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { BridgeConfig } from "./config.js";
+import type { Logger } from "./logger.js";
+import type { RouteDecision } from "./routes.js";
+export type RouteOutcome = "health" | "plugin" | "intercept" | "pass-through";
+export interface RouteInventoryEntry {
+    method: string;
+    path: string;
+    contentType: string;
+    status: number;
+    framing: string;
+    policy: string;
+    outcome: RouteOutcome;
+}
+export declare function attachRouteInventoryLogger(config: BridgeConfig, logger: Logger, request: IncomingMessage, response: ServerResponse, decision: RouteDecision, outcome: () => RouteOutcome): void;
+export declare function framingForContentType(value: string | string[] | undefined): string;

package/dist/src/routeInventory.js

@@ -0,0 +1,39 @@
+import { redactValue } from "./redaction.js";
+export function attachRouteInventoryLogger(config, logger, request, response, decision, outcome) {
+    if (!config.routeInventoryEnabled) {
+        return;
+    }
+    response.once("finish", () => {
+        logger.info("desktop route inventory", {
+            method: request.method ?? "GET",
+            path: redactValue(decision.path),
+            contentType: headerValue(request.headers["content-type"]),
+            status: response.statusCode,
+            framing: framingForContentType(request.headers["content-type"]),
+            policy: decision.policy,
+            outcome: outcome(),
+        });
+    });
+}
+export function framingForContentType(value) {
+    const contentType = headerValue(value).toLowerCase();
+    if (contentType.includes("application/connect+proto")) {
+        return "connect-proto";
+    }
+    if (contentType.includes("application/proto")) {
+        return "proto";
+    }
+    if (contentType.includes("application/json")) {
+        return "json";
+    }
+    if (contentType.length === 0) {
+        return "none";
+    }
+    return "other";
+}
+function headerValue(value) {
+    if (value === undefined) {
+        return "";
+    }
+    return Array.isArray(value) ? value.join(", ") : value;
+}

package/dist/src/routes.d.ts

@@ -0,0 +1,37 @@
+import type { IncomingMessage } from "node:http";
+export declare const AVAILABLE_MODELS_PATH = "/aiserver.v1.AiService/AvailableModels";
+export declare const GET_USABLE_MODELS_PATH = "/aiserver.v1.AiService/GetUsableModels";
+export declare const GET_DEFAULT_MODEL_FOR_CLI_PATH = "/aiserver.v1.AiService/GetDefaultModelForCli";
+export declare const GET_DEFAULT_MODEL_PATH = "/aiserver.v1.AiService/GetDefaultModel";
+export declare const NAME_AGENT_PATH = "/aiserver.v1.AiService/NameAgent";
+export declare const GET_SERVER_CONFIG_PATH = "/aiserver.v1.ServerConfigService/GetServerConfig";
+export declare const AGENT_RUN_PATH = "/agent.v1.AgentService/Run";
+export declare const AGENT_RUN_SSE_PATH = "/agent.v1.AgentService/RunSSE";
+export declare const BIDI_APPEND_PATH = "/aiserver.v1.BidiService/BidiAppend";
+export declare const STREAM_CHAT_WITH_TOOLS_PATH = "/aiserver.v1.ChatService/StreamUnifiedChatWithTools";
+export declare const UPLOAD_ISSUE_TRACE_PATH = "/aiserver.v1.AnalyticsService/UploadIssueTrace";
+export declare const AUTH_FULL_STRIPE_PROFILE_PATH = "/auth/full_stripe_profile";
+export declare const AUTH_STRIPE_PROFILE_PATH = "/auth/stripe_profile";
+export type RoutePolicy = "intercept" | "observe-only" | "pass-through";
+export type RouteSupportLevel = "implemented" | "conditional" | "observe-first" | "unsupported";
+export interface RouteContractSeed {
+    path: string;
+    packageName?: string;
+    service?: string;
+    method?: string;
+    policy: RoutePolicy;
+    supportLevel: RouteSupportLevel;
+    owner: "bridge-core" | "desktop-observation" | "upstream";
+    expectedMethods: string[];
+    expectedContentTypes: string[];
+    reason: string;
+    uncertainty: string;
+}
+export interface RouteDecision {
+    path: string;
+    policy: RoutePolicy;
+    reason: string;
+}
+export declare const ROUTE_CONTRACT_SEEDS: readonly RouteContractSeed[];
+export declare const INTERCEPTABLE_ROUTE_PATHS: string[];
+export declare function classifyRoute(request: IncomingMessage): RouteDecision;