@aexhq/sdk 0.13.6

package/dist/_contracts/provider-support.d.ts

@@ -0,0 +1,220 @@
+import type { RunProvider, RuntimeKind } from "./submission.js";
+export declare const PROVIDER_SUPPORT_STATUSES: readonly ["supported", "live-unverified", "rejected"];
+export type ProviderSupportStatus = (typeof PROVIDER_SUPPORT_STATUSES)[number];
+export interface SupportPointer {
+    readonly label: string;
+    /** Markdown href, relative to `packages/sdk/docs/provider-runtime-capabilities.md`. */
+    readonly href: string;
+}
+export interface ProviderPublicSupport {
+    readonly displayName: string;
+    readonly status: ProviderSupportStatus;
+    readonly docsAnchor: string;
+    readonly docs: readonly SupportPointer[];
+    readonly evidence: readonly SupportPointer[];
+    readonly runtimeEvidence: Readonly<Partial<Record<RuntimeKind, readonly SupportPointer[]>>>;
+}
+export interface RuntimeValidationSupport {
+    readonly docsAnchor: string;
+    readonly docs: readonly SupportPointer[];
+    readonly evidence: readonly SupportPointer[];
+    readonly enforcement: string;
+}
+export declare const RUNTIME_VALIDATION_SUPPORT: {
+    readonly feature_runtime_mismatch: {
+        readonly docsAnchor: "managed-unsupported-features";
+        readonly docs: readonly [{
+            readonly label: "Runtime routing";
+            readonly href: "provider-runtime-capabilities.md#runtime-routing";
+        }];
+        readonly evidence: readonly [{
+            readonly label: "Submission parser and routing parity";
+            readonly href: "../../contracts/test/submission.test.ts";
+        }];
+        readonly enforcement: "collectManagedUnsupportedFeatures + selectRuntime";
+    };
+};
+/**
+ * Public provider support facts for generated SDK docs. Keep this metadata
+ * public-facing only: provider names, support status, docs anchors, and
+ * evidence pointers.
+ */
+export declare const PROVIDER_PUBLIC_SUPPORT: {
+    readonly anthropic: {
+        readonly displayName: "Anthropic";
+        readonly status: "supported";
+        readonly docsAnchor: "anthropic";
+        readonly docs: readonly [{
+            readonly label: "Credentials";
+            readonly href: "credentials.md";
+        }, {
+            readonly label: "Events";
+            readonly href: "events.md";
+        }];
+        readonly evidence: readonly [{
+            readonly label: "Submission parser and routing parity";
+            readonly href: "../../contracts/test/submission.test.ts";
+        }, {
+            readonly label: "Runtime support validator";
+            readonly href: "../../contracts/test/runtime-support.test.ts";
+        }, {
+            readonly label: "Generated matrix freshness";
+            readonly href: "../../../scripts/validate/capability-matrix.test.ts";
+        }, {
+            readonly label: "Installed-SDK live user matrix";
+            readonly href: "../../../apps/user-tests/test/live/live-sdk-comprehensive.test.ts";
+        }, {
+            readonly label: "Runtime support validator";
+            readonly href: "../../contracts/test/runtime-support.test.ts";
+        }];
+        readonly runtimeEvidence: {
+            readonly managed: readonly [{
+                readonly label: "Installed-SDK live user matrix";
+                readonly href: "../../../apps/user-tests/test/live/live-sdk-comprehensive.test.ts";
+            }, {
+                readonly label: "Runtime support validator";
+                readonly href: "../../contracts/test/runtime-support.test.ts";
+            }];
+        };
+    };
+    readonly deepseek: {
+        readonly displayName: "DeepSeek";
+        readonly status: "supported";
+        readonly docsAnchor: "deepseek";
+        readonly docs: readonly [{
+            readonly label: "Credentials";
+            readonly href: "credentials.md";
+        }, {
+            readonly label: "Events";
+            readonly href: "events.md";
+        }];
+        readonly evidence: readonly [{
+            readonly label: "Submission parser and routing parity";
+            readonly href: "../../contracts/test/submission.test.ts";
+        }, {
+            readonly label: "Runtime support validator";
+            readonly href: "../../contracts/test/runtime-support.test.ts";
+        }, {
+            readonly label: "Generated matrix freshness";
+            readonly href: "../../../scripts/validate/capability-matrix.test.ts";
+        }, {
+            readonly label: "Installed-SDK live user matrix";
+            readonly href: "../../../apps/user-tests/test/live/live-sdk-comprehensive.test.ts";
+        }, {
+            readonly label: "Runtime support validator";
+            readonly href: "../../contracts/test/runtime-support.test.ts";
+        }];
+        readonly runtimeEvidence: {
+            readonly managed: readonly [{
+                readonly label: "Installed-SDK live user matrix";
+                readonly href: "../../../apps/user-tests/test/live/live-sdk-comprehensive.test.ts";
+            }, {
+                readonly label: "Runtime support validator";
+                readonly href: "../../contracts/test/runtime-support.test.ts";
+            }];
+        };
+    };
+    readonly openai: {
+        readonly displayName: "OpenAI";
+        readonly status: "live-unverified";
+        readonly docsAnchor: "openai";
+        readonly docs: readonly [{
+            readonly label: "Credentials";
+            readonly href: "credentials.md";
+        }, {
+            readonly label: "Events";
+            readonly href: "events.md";
+        }];
+        readonly evidence: readonly [{
+            readonly label: "Submission parser and routing parity";
+            readonly href: "../../contracts/test/submission.test.ts";
+        }, {
+            readonly label: "Runtime support validator";
+            readonly href: "../../contracts/test/runtime-support.test.ts";
+        }, {
+            readonly label: "Generated matrix freshness";
+            readonly href: "../../../scripts/validate/capability-matrix.test.ts";
+        }];
+        readonly runtimeEvidence: {
+            readonly managed: readonly [{
+                readonly label: "Submission parser and routing parity";
+                readonly href: "../../contracts/test/submission.test.ts";
+            }, {
+                readonly label: "Runtime support validator";
+                readonly href: "../../contracts/test/runtime-support.test.ts";
+            }, {
+                readonly label: "Generated matrix freshness";
+                readonly href: "../../../scripts/validate/capability-matrix.test.ts";
+            }];
+        };
+    };
+    readonly gemini: {
+        readonly displayName: "Gemini";
+        readonly status: "live-unverified";
+        readonly docsAnchor: "gemini";
+        readonly docs: readonly [{
+            readonly label: "Credentials";
+            readonly href: "credentials.md";
+        }, {
+            readonly label: "Events";
+            readonly href: "events.md";
+        }];
+        readonly evidence: readonly [{
+            readonly label: "Submission parser and routing parity";
+            readonly href: "../../contracts/test/submission.test.ts";
+        }, {
+            readonly label: "Runtime support validator";
+            readonly href: "../../contracts/test/runtime-support.test.ts";
+        }, {
+            readonly label: "Generated matrix freshness";
+            readonly href: "../../../scripts/validate/capability-matrix.test.ts";
+        }];
+        readonly runtimeEvidence: {
+            readonly managed: readonly [{
+                readonly label: "Submission parser and routing parity";
+                readonly href: "../../contracts/test/submission.test.ts";
+            }, {
+                readonly label: "Runtime support validator";
+                readonly href: "../../contracts/test/runtime-support.test.ts";
+            }, {
+                readonly label: "Generated matrix freshness";
+                readonly href: "../../../scripts/validate/capability-matrix.test.ts";
+            }];
+        };
+    };
+    readonly mistral: {
+        readonly displayName: "Mistral";
+        readonly status: "live-unverified";
+        readonly docsAnchor: "mistral";
+        readonly docs: readonly [{
+            readonly label: "Credentials";
+            readonly href: "credentials.md";
+        }, {
+            readonly label: "Events";
+            readonly href: "events.md";
+        }];
+        readonly evidence: readonly [{
+            readonly label: "Submission parser and routing parity";
+            readonly href: "../../contracts/test/submission.test.ts";
+        }, {
+            readonly label: "Runtime support validator";
+            readonly href: "../../contracts/test/runtime-support.test.ts";
+        }, {
+            readonly label: "Generated matrix freshness";
+            readonly href: "../../../scripts/validate/capability-matrix.test.ts";
+        }];
+        readonly runtimeEvidence: {
+            readonly managed: readonly [{
+                readonly label: "Submission parser and routing parity";
+                readonly href: "../../contracts/test/submission.test.ts";
+            }, {
+                readonly label: "Runtime support validator";
+                readonly href: "../../contracts/test/runtime-support.test.ts";
+            }, {
+                readonly label: "Generated matrix freshness";
+                readonly href: "../../../scripts/validate/capability-matrix.test.ts";
+            }];
+        };
+    };
+};
+export declare function providerPublicSupport(provider: RunProvider): ProviderPublicSupport;

package/dist/_contracts/provider-support.js

@@ -0,0 +1,90 @@
+export const PROVIDER_SUPPORT_STATUSES = [
+    "supported",
+    "live-unverified",
+    "rejected"
+];
+const COMMON_DOCS = [
+    { label: "Credentials", href: "credentials.md" },
+    { label: "Events", href: "events.md" }
+];
+const COMMON_EVIDENCE = [
+    { label: "Submission parser and routing parity", href: "../../contracts/test/submission.test.ts" },
+    { label: "Runtime support validator", href: "../../contracts/test/runtime-support.test.ts" },
+    { label: "Generated matrix freshness", href: "../../../scripts/validate/capability-matrix.test.ts" }
+];
+const LIVE_USER_MATRIX_EVIDENCE = [
+    { label: "Installed-SDK live user matrix", href: "../../../apps/user-tests/test/live/live-sdk-comprehensive.test.ts" }
+];
+const MANAGED_PROXY_EVIDENCE = [
+    ...LIVE_USER_MATRIX_EVIDENCE,
+    { label: "Runtime support validator", href: "../../contracts/test/runtime-support.test.ts" }
+];
+export const RUNTIME_VALIDATION_SUPPORT = {
+    feature_runtime_mismatch: {
+        docsAnchor: "managed-unsupported-features",
+        docs: [{ label: "Runtime routing", href: "provider-runtime-capabilities.md#runtime-routing" }],
+        evidence: [{ label: "Submission parser and routing parity", href: "../../contracts/test/submission.test.ts" }],
+        enforcement: "collectManagedUnsupportedFeatures + selectRuntime"
+    }
+};
+/**
+ * Public provider support facts for generated SDK docs. Keep this metadata
+ * public-facing only: provider names, support status, docs anchors, and
+ * evidence pointers.
+ */
+export const PROVIDER_PUBLIC_SUPPORT = {
+    anthropic: {
+        displayName: "Anthropic",
+        status: "supported",
+        docsAnchor: "anthropic",
+        docs: COMMON_DOCS,
+        evidence: [...COMMON_EVIDENCE, ...MANAGED_PROXY_EVIDENCE],
+        runtimeEvidence: {
+            managed: MANAGED_PROXY_EVIDENCE
+        }
+    },
+    deepseek: {
+        displayName: "DeepSeek",
+        status: "supported",
+        docsAnchor: "deepseek",
+        docs: COMMON_DOCS,
+        evidence: [...COMMON_EVIDENCE, ...MANAGED_PROXY_EVIDENCE],
+        runtimeEvidence: {
+            managed: MANAGED_PROXY_EVIDENCE
+        }
+    },
+    openai: {
+        displayName: "OpenAI",
+        status: "live-unverified",
+        docsAnchor: "openai",
+        docs: COMMON_DOCS,
+        evidence: COMMON_EVIDENCE,
+        runtimeEvidence: {
+            managed: COMMON_EVIDENCE
+        }
+    },
+    gemini: {
+        displayName: "Gemini",
+        status: "live-unverified",
+        docsAnchor: "gemini",
+        docs: COMMON_DOCS,
+        evidence: COMMON_EVIDENCE,
+        runtimeEvidence: {
+            managed: COMMON_EVIDENCE
+        }
+    },
+    mistral: {
+        displayName: "Mistral",
+        status: "live-unverified",
+        docsAnchor: "mistral",
+        docs: COMMON_DOCS,
+        evidence: COMMON_EVIDENCE,
+        runtimeEvidence: {
+            managed: COMMON_EVIDENCE
+        }
+    }
+};
+export function providerPublicSupport(provider) {
+    return PROVIDER_PUBLIC_SUPPORT[provider];
+}
+//# sourceMappingURL=provider-support.js.map

package/dist/_contracts/proxy-protocol.d.ts

@@ -0,0 +1,257 @@
+/**
+ * Wire-protocol version. Bumped on any breaking change to the request or
+ * response shape. The CLI sends this in the `X-Aex-Proxy-Protocol`
+ * header on every request; the BFF rejects mismatches with HTTP 426
+ * `unsupported_protocol`.
+ *
+ * Bumps are coordinated: CLI and BFF release together, the worker
+ * bundles the matching CLI artifact, and the e2e suite runs both with
+ * the new version.
+ */
+export declare const PROXY_PROTOCOL_VERSION: "1";
+export declare const PROXY_PROTOCOL_HEADER = "x-aex-proxy-protocol";
+/**
+ * Default `User-Agent` the proxy attaches to every outbound request when
+ * the caller did not supply one via `allowHeaders`. Some upstreams reject
+ * requests that arrive without a meaningful UA — notably the Wikimedia
+ * family (Wikidata, Wikipedia, Wikimedia Commons), whose policy requires
+ * a contactable identifier and otherwise returns HTTP 403 with a
+ * `Please identify your user agent` body.
+ *
+ * Callers can override per request by listing `user-agent` in their
+ * endpoint's `allowHeaders` and setting it on the proxy call; the
+ * default only fires when nothing was forwarded.
+ *
+ * See <https://meta.wikimedia.org/wiki/User-Agent_policy>.
+ */
+export declare const PROXY_DEFAULT_USER_AGENT = "aex-proxy/1.0 (+https://aex.dev/contact)";
+export declare const PROXY_METHOD_HEADER = "x-aex-method";
+export declare const PROXY_PATH_HEADER = "x-aex-path";
+export declare const PROXY_QUERY_HEADER = "x-aex-query";
+export declare const PROXY_HEADERS_HEADER = "x-aex-headers";
+export declare const PROXY_RESPONSE_MODE_HEADER = "x-aex-response-mode";
+export declare const PROXY_ALLOWED_METHODS: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"];
+export type ProxyMethod = (typeof PROXY_ALLOWED_METHODS)[number];
+export declare const PROXY_RESPONSE_MODES: readonly ["status_only", "headers_only", "full"];
+export type ProxyResponseMode = (typeof PROXY_RESPONSE_MODES)[number];
+/**
+ * Returns the narrower of the two response modes (lower width wins).
+ * Pure function so the CLI and BFF can both call it without import cycles.
+ */
+export declare function narrowResponseMode(policy: ProxyResponseMode, requested: ProxyResponseMode): ProxyResponseMode;
+/**
+ * Error codes returned by the proxy route. Stable strings — the CLI
+ * matches against them in scripts. Adding a new code is non-breaking;
+ * removing or renaming an existing code requires a protocol bump.
+ */
+export declare const PROXY_ERROR_CODES: readonly ["unsupported_protocol", "unauthorized", "endpoint_not_found", "policy_denied", "rate_limited", "budget_exceeded", "ssrf_denied", "upstream_timeout", "upstream_error", "exceeded_cap", "bad_request", "internal_error"];
+export type ProxyErrorCode = (typeof PROXY_ERROR_CODES)[number];
+/**
+ * Shape of the JSON written to the per-run manifest mounted inside
+ * the container (`/mnt/session/uploads/aex/index.json`).
+ *
+ * Always present (every run), regardless of whether any proxy endpoints
+ * were declared. With zero endpoints, `endpoints` is `[]` and
+ * `proxyBaseUrl` is `null` — this keeps `aex --help` working
+ * uniformly and makes the always-on surface observable in tests.
+ *
+ * Auth values NEVER appear in this file. The file is mounted into the
+ * container; treat it as world-readable from the agent's perspective.
+ */
+export interface ProxyIndexFile {
+    readonly protocolVersion: typeof PROXY_PROTOCOL_VERSION;
+    readonly runId: string;
+    readonly proxyBaseUrl: string | null;
+    readonly endpoints: readonly ProxyIndexEntry[];
+}
+export interface ProxyIndexEntry {
+    readonly name: string;
+    readonly baseUrl: string;
+    readonly authShape: ProxyAuthShape;
+    readonly allowMethods: readonly ProxyMethod[];
+    readonly allowPathPrefixes: readonly string[];
+    readonly allowHeaders: readonly string[];
+    readonly responseMode: ProxyResponseMode;
+    readonly maxRequestBytes: number;
+    readonly maxResponseBytes: number;
+    readonly timeoutMs: number;
+    readonly perCallBudget: number;
+    readonly responseByteBudget: number;
+}
+/**
+ * Default caps for a proxy endpoint when the submission doesn't specify
+ * one. Conservative on purpose. Lives in the protocol module (next to the
+ * index-file shape) so {@link buildProxyIndexFile} can fill every optional
+ * cap with a concrete value; the submission parser re-exports it.
+ */
+export declare const PROXY_ENDPOINT_DEFAULTS: {
+    readonly allowHeaders: readonly string[];
+    readonly responseMode: ProxyResponseMode;
+    readonly maxRequestBytes: number;
+    readonly maxResponseBytes: number;
+    readonly timeoutMs: 10000;
+    readonly perCallBudget: 60;
+    readonly responseByteBudget: number;
+};
+/**
+ * Non-secret endpoint policy the index builder consumes. Structurally a
+ * subset of `PlatformProxyEndpoint` (submission.ts) — declared here so the
+ * protocol module stays free of an import cycle with the submission parser.
+ */
+export interface ProxyEndpointPolicy {
+    readonly name: string;
+    readonly baseUrl: string;
+    readonly authShape: ProxyAuthShape;
+    readonly allowMethods: readonly ProxyMethod[];
+    readonly allowPathPrefixes: readonly string[];
+    readonly allowHeaders?: readonly string[];
+    readonly responseMode?: ProxyResponseMode;
+    readonly maxRequestBytes?: number;
+    readonly maxResponseBytes?: number;
+    readonly timeoutMs?: number;
+    readonly perCallBudget?: number;
+    readonly responseByteBudget?: number;
+}
+export interface BuildProxyIndexFileInput {
+    readonly runId: string;
+    /**
+     * Dashboard host that serves `/api/runs/:runId/proxy/:endpointName`
+     * (the BFF proxy route). Distinct from the api Worker host. When unset
+     * (or empty) the run has no reachable proxy plane and `proxyBaseUrl`
+     * resolves to `null`.
+     */
+    readonly proxyPublicBaseUrl?: string;
+    readonly endpoints?: readonly ProxyEndpointPolicy[];
+}
+/**
+ * Build the per-run {@link ProxyIndexFile} mounted into the container at
+ * `/mnt/session/uploads/aex/index.json`. Pure: applies
+ * {@link PROXY_ENDPOINT_DEFAULTS} so every optional cap is concrete, and
+ * carries ONLY the non-secret endpoint policy — auth values never appear.
+ *
+ * ALWAYS emits a file (the always-on surface). With zero endpoints OR no
+ * `proxyPublicBaseUrl`, `proxyBaseUrl` is `null` and `endpoints` is `[]`.
+ * Otherwise `proxyBaseUrl` is `<trimmed base>/api/runs/<runId>/proxy`, the
+ * prefix the in-container runtime bridge appends `/<endpointName>` to (proxy.ts).
+ */
+export declare function buildProxyIndexFile(input: BuildProxyIndexFileInput): ProxyIndexFile;
+/**
+ * Structural description of how the upstream endpoint expects auth.
+ * The actual auth value lives in the run's Vault bundle under
+ * `secrets.proxyEndpointAuth[i].value` and is never reflected back
+ * into the container or index file.
+ *
+ * The `none` variant declares an upstream that takes no auth (public
+ * APIs like Wikimedia Commons or NASA Images). It still routes through
+ * the proxy for unified egress, audit, and budget enforcement, but
+ * carries no `proxyEndpointAuth[]` entry and the BFF injects no
+ * header or query value.
+ */
+export type ProxyAuthShape = {
+    readonly type: "none";
+} | {
+    readonly type: "bearer";
+} | {
+    readonly type: "basic";
+} | {
+    readonly type: "header";
+    readonly name: string;
+} | {
+    readonly type: "query";
+    readonly name: string;
+};
+export type ProxyAuthType = ProxyAuthShape["type"];
+/**
+ * Header name (lowercase) that an upstream auth shape uses as its
+ * carrier. Returns `undefined` for query-based and keyless auth.
+ *
+ * Used by the submission parser to forbid `allowHeaders` from listing
+ * the auth header (avoids leaks via caller-supplied headers), and by
+ * the proxy route to strip any caller header that would collide with
+ * the auth carrier at request time.
+ */
+export declare function authShapeHeaderName(shape: ProxyAuthShape): string | undefined;
+/**
+ * Query-string key that an upstream query-based auth shape uses as its
+ * carrier. Returns `undefined` for non-query shapes (including "none").
+ */
+export declare function authShapeQueryName(shape: ProxyAuthShape): string | undefined;
+/**
+ * Inbound request headers every Aex proxy plane STRIPS before
+ * forwarding a runtime/runner request upstream. Three categories:
+ *
+ *   - Credential carriers (`authorization`, `x-api-key`, `cookie`,
+ *     `proxy-authorization`) — these belong to Aex's own auth gate
+ *     (the per-run bearer) or to the caller, never the upstream. The
+ *     legitimate upstream credential is injected server-side from the
+ *     run's Vault bundle / endpoint auth shape AFTER this strip, so it is
+ *     never sourced from an inbound header.
+ *   - Hop-by-hop fields (RFC 7230 §6.1: `connection`, `keep-alive`,
+ *     `transfer-encoding`, `te`, `trailer`, `upgrade`, `expect`,
+ *     `proxy-authenticate`, `proxy-connection`) — must not survive a
+ *     proxy hop.
+ *   - Routing primitives a compromised runner could spoof to bypass an
+ *     upstream's IP allowlist / rate-limit (`host`, `content-length`,
+ *     `x-forwarded-*`, `x-real-ip`, `forwarded`).
+ *
+ * The api Worker provider-proxy and the dashboard MCP proxy strip exactly
+ * this set (both inject upstream auth separately — the provider key, or the
+ * Vault MCP-bundle headers, applied AFTER the strip). The dashboard
+ * customer HTTP proxy hard-denies this set MINUS `x-api-key`, because a
+ * customer endpoint may legitimately declare `x-api-key` as its auth
+ * carrier; it derives from this constant so the hop-by-hop + routing
+ * entries never drift. Keeping the membership here is the single source of
+ * truth that stops those surfaces diverging.
+ */
+export declare const PROXY_STRIPPED_INBOUND_HEADERS: ReadonlySet<string>;
+/**
+ * JSON body returned on a successful proxy call. The actual HTTP
+ * response from the BFF to the CLI is always 200 once the BFF accepts
+ * the request; the upstream's status/headers/body are reflected inside
+ * this envelope so the CLI can decide what to write to stdout/stderr.
+ */
+export interface ProxyResponseEnvelope {
+    readonly endpointName: string;
+    readonly upstreamStatus: number;
+    /** Lowercase header names → values. Allowlist-filtered by the BFF. */
+    readonly upstreamHeaders: Readonly<Record<string, string>>;
+    /**
+     * Base64-encoded upstream body. Present only when the effective
+     * response mode is `full`. Truncated to `maxResponseBytes`; if the
+     * upstream exceeded the cap, `truncated` is `true`.
+     */
+    readonly upstreamBodyBase64?: string;
+    readonly truncated?: boolean;
+    /**
+     * Echoed back so the CLI can warn the agent when its requested mode
+     * was clamped against the policy ceiling.
+     */
+    readonly effectiveResponseMode: ProxyResponseMode;
+    readonly modeClamped: boolean;
+    /** Remaining per-endpoint per-run budget after this call. */
+    readonly remainingCalls: number;
+    readonly remainingResponseBytes: number;
+}
+/**
+ * JSON body returned on any error. The CLI emits this verbatim on
+ * stderr and exits non-zero. Audit row carries the same `code`.
+ */
+export interface ProxyErrorBody {
+    readonly error: ProxyErrorCode;
+    /** Human-readable message. Never includes auth values. */
+    readonly message: string;
+    /**
+     * Optional diagnostic fields. Always safe to surface — auth values
+     * and full URLs are stripped at the BFF.
+     */
+    readonly endpointName?: string;
+    readonly upstreamStatus?: number;
+    /** Server-supplied protocol version on `unsupported_protocol`. */
+    readonly serverProtocolVersion?: string;
+}
+/**
+ * Status code → error code mapping used by the BFF to ensure the audit
+ * row's error code and the HTTP response line up. Kept here so callers
+ * can do a sanity check in tests.
+ */
+export declare const PROXY_ERROR_HTTP_STATUS: Record<ProxyErrorCode, number>;