@aexhq/sdk 0.35.0 → 0.36.0

package/docs/vision-skills.md

@@ -1,73 +1,57 @@
 ---
-title: Call a vision (or any model) API from a skill
+title: Call a vision API from a skill
 ---
 
-# Call a vision (or any model) API from a skill
+# Call a vision API from a skill
 
-aex has no built-in vision tool. The agent's `provider`/`model` selects the
-*reasoning* model — it is not an endpoint a skill can POST an image to mid-run.
-To give a run image understanding (or to call any other model/HTTP API), ship a
-**skill** that POSTs to the provider's OpenAI-compatible endpoint **through the
-managed proxy**, with the key supplied on a `ProxyEndpoint.bearer(...)` instance.
-The raw key never enters the container.
+aex has no built-in vision tool. The agent's `provider` / `model` selects the
+reasoning model for the run; if a skill needs image understanding mid-run, ship a
+skill that calls the vision provider with normal HTTP and pass that provider key
+as a runtime secret.
 
-This is the same proxy described in `credentials.md` — this page is the worked
-recipe for the model-API case, which has two wrinkles a plain JSON call does not:
-the image rides as a **base64 data URL** in the request body, and that body is
-large enough to need a raised `maxRequestBytes`.
+The runnable example lives at [`examples/vision-skill/`](../../../examples/vision-skill).
+It captions a frame with ByteDance Doubao Seed Vision (Ark) and returns a
+per-noun "does the frame depict X?" verdict.
 
-The canonical, runnable example lives in the repo at
-[`examples/vision-skill/`](../../../examples/vision-skill) (`SKILL.md`,
-`caption_frame.py`, `verify_frame.py`, `run_with_vision_skill.mjs`). It
-captions a frame with ByteDance Doubao Seed Vision (Ark) and returns a per-noun
-"does the frame depict X?" verdict. Everything below is taken from it.
-
-## 1. Declare the model endpoint as a proxy endpoint
-
-The vision provider's API is just an HTTPS host. Declare it with
-`ProxyEndpoint.bearer(...)`, which carries the key on the instance. The two
-model-specific settings are `responseMode: "full"` (so the skill gets the upstream
-JSON back) and a raised `maxRequestBytes` (so the base64 image fits):
+## Submit the run
 
 ```ts
-import { Aex, Models, Tools, ProxyEndpoint } from "@aexhq/sdk";
+import { Aex, Models, Secret, Tools } from "@aexhq/sdk";
 
 const aex = new Aex({ apiToken: process.env.AEX_API_TOKEN! });
 
-const doubaoArk = ProxyEndpoint.bearer({
-  name: "doubao-ark",
-  baseUrl: "https://ark.ap-southeast.bytepluses.com", // intl BytePlus gateway
-  token: process.env.DOUBAO_API_KEY!,
-  allowMethods: ["POST"],
-  allowPathPrefixes: ["/api/v3/chat/completions"],
-  maxRequestBytes: 2_000_000, // base64 image POSTs — see note below
-  responseMode: "full",
-  timeoutMs: 60_000
-});
-
-await aex.run({
+const result = await aex.run({
   model: Models.CLAUDE_HAIKU_4_5,
-  message: "…read skills/frame-vision-gate/SKILL.md, then caption + verify the frame…",
+  message: "Read skills/frame-vision-gate/SKILL.md, then caption and verify the frame.",
   tools: [await Tools.fromSkillDir("./vision-skill", { name: "frame-vision-gate" })],
-  proxyEndpoints: [doubaoArk],
+  environment: {
+    secrets: {
+      DOUBAO_API_KEY: Secret.value(process.env.DOUBAO_API_KEY!)
+    },
+    networking: {
+      mode: "limited",
+      allowedHosts: ["ark.ap-southeast.bytepluses.com"]
+    }
+  },
   apiKeys: { anthropic: process.env.ANTHROPIC_API_KEY! }
 });
+
+console.log(result.runId, result.text);
 ```
 
-`Tools.fromSkillDir("./vision-skill", …)` is resolved relative to the process CWD, so
-run the script from the directory that *contains* `vision-skill/` (in the
-repo, that is `examples/`). The same pattern works for OpenAI, Gemini's
-OpenAI-compatible endpoint, or any other OpenAI-chat-shaped vision API — only
-`baseUrl` and the path prefix change.
+`Tools.fromSkillDir("./vision-skill", ...)` is resolved relative to the process
+CWD. Run the script from the directory that contains `vision-skill/` (in this
+repo, `examples/`).
 
-## 2. POST the image as a base64 data URL through the proxy
+## Call the provider from the skill
 
-Inside the run, the skill builds the OpenAI-compatible chat-completions body. The
-image is **base64-inlined as a data URL** in an `image_url` content part — it is
-not uploaded:
+Inside the run, the skill reads `DOUBAO_API_KEY` and makes an
+OpenAI-compatible chat-completions request with Python's standard HTTP client.
+The image is base64-inlined as a data URL in the request body:
 
 ```python
-import base64, json
+import base64, json, os, urllib.request
+
 b64 = base64.b64encode(open("/workspace/files/frame.jpg", "rb").read()).decode()
 request_body = {
     "model": "doubao-seed-1-6-vision-250815",
@@ -81,63 +65,30 @@ request_body = {
         ]}
     ]
 }
-```
-
-Write the body to a file and hand it to the mounted CLI with `--data @<file>`
-(the mount has no execute bit, so invoke through `bun`; see `credentials.md`):
 
-```python
-import subprocess
-body_path = "/workspace/.aex/_ark_request.json"
-open(body_path, "w").write(json.dumps(request_body))
-
-result = subprocess.run(
-    ["bun", "/mnt/session/uploads/aex/aex", "proxy", "doubao-ark",
-     "--method", "POST",
-     "--path", "/api/v3/chat/completions",
-     "--header", "content-type=application/json",
-     "--data", f"@{body_path}",
-     "--response-mode", "full"],
-    capture_output=True, text=True, timeout=90,
+req = urllib.request.Request(
+    "https://ark.ap-southeast.bytepluses.com/api/v3/chat/completions",
+    data=json.dumps(request_body).encode("utf-8"),
+    headers={
+        "Authorization": f"Bearer {os.environ['DOUBAO_API_KEY']}",
+        "Content-Type": "application/json"
+    },
+    method="POST",
 )
 ```
 
-In `--response-mode full` the CLI prints a `ProxyResponseEnvelope` on stdout. The
-upstream JSON is **base64-encoded** in `upstreamBodyBase64`; an error instead
-carries an `error` field. Unwrap it:
-
-```python
-envelope = json.loads(result.stdout)
-if "error" in envelope:
-    raise RuntimeError(f"proxy error: {envelope['error']}: {envelope['message']}")
-upstream = json.loads(base64.b64decode(envelope["upstreamBodyBase64"]).decode())
-content = upstream["choices"][0]["message"]["content"]  # the model's JSON answer
-```
-
-The key is injected by the hosted proxy on the outbound call; it never appears on disk in
-the container or in the model's context.
-
-## `maxRequestBytes` and timeout defaults
+The same pattern works for OpenAI, Gemini's OpenAI-compatible endpoint, or any
+other HTTPS model API. Put the key in `environment.secrets`, allow-list the host
+when using limited networking, and use the provider's normal SDK or HTTP API.
 
-The per-endpoint `maxRequestBytes` default is **10 MiB** and the default timeout
-is **5 minutes**. That fits typical base64 image/model POSTs without extra
-configuration. If a body does exceed the cap, the proxy rejects it before any
-upstream call with an explicit error naming the observed size, the configured
-cap, and how to raise it:
+## Payload size
 
-> request body is 2400000 bytes, which exceeds this endpoint's maxRequestBytes
-> (10485760). Raise the per-endpoint maxRequestBytes in the proxy endpoint policy …
+Base64 images are larger than their source files. Scale frames before captioning
+when possible, for example:
 
-Two ways to stay under the cap: raise `maxRequestBytes`, and/or scale frames
-before captioning (`ffmpeg -i source.mp4 -vf fps=1,scale=960:-1 frame_%03d.jpg`)
-so full-res frames do not add payload and model cost without useful signal.
-
-## Notes
+```bash
+ffmpeg -i source.mp4 -vf fps=1,scale=960:-1 frame_%03d.jpg
+```
 
-- **Host selection.** Use the provider endpoint that matches your account and
-  declare it as the proxy endpoint `baseUrl`.
-- **Keyless model hosts.** If the upstream takes no credential, declare the
-  endpoint with `ProxyEndpoint.none(...)` (see `credentials.md`).
-- **Response size.** `responseMode: "full"` is required to read the model's reply
-  back. Leave `maxResponseBytes` at its default (`0` = unlimited, streamed) unless
-  you want a truncation cap.
+This keeps upload size and model cost bounded without losing the signal most
+vision models need.

package/examples/feature-tour.ts

@@ -2,7 +2,7 @@
  * SDK feature tour: one managed session that uses typed model/runtime constants,
  * inline AGENTS.md guidance, uploaded files, a custom tool bundle, selected
  * built-in tools, runtime env vars/secrets, streamed events, output reads, and
- * corpus-scoped data tools.
+ * a follow-up session turn.
  *
  * Run from the repository root after building the workspace package:
  *
@@ -20,13 +20,11 @@ import {
   AgentsMd,
   Aex,
   BuiltinTools,
-  createCorpusTools,
   File,
   isRateLimited,
   isTextMessage,
   McpServer,
   Models,
-  ProxyEndpoint,
   Providers,
   Secret,
   Sizes,
@@ -132,17 +130,6 @@ const environmentSecrets = demoRuntimeSecret
   ? { DEMO_RUNTIME_SECRET: Secret.value(demoRuntimeSecret) }
   : undefined;
 
-const proxyEndpoints = [
-  ProxyEndpoint.none({
-    name: "httpbin",
-    baseUrl: "https://httpbin.org",
-    allowMethods: ["GET"],
-    allowPathPrefixes: ["/json"],
-    responseMode: "full",
-    timeoutMs: 10_000
-  })
-];
-
 console.log("creating feature-tour session...");
 console.log(`optional mcp: ${mcpServers.length > 0 ? "enabled" : "disabled"}`);
 console.log(`optional runtime secret: ${environmentSecrets ? "enabled" : "disabled"}`);
@@ -165,7 +152,6 @@ const session = await aex.openSession({
     BuiltinTools.code_execution,
     metricLookup
   ],
-  proxyEndpoints,
   mcpServers,
   environment: {
     networking: { mode: "open" },
@@ -201,8 +187,7 @@ const prompt = [
   "Analyze the attached quarterly metrics.",
   "Call metric_lookup for atlas, beacon, and cinder.",
   "Create /workspace/outputs/feature-tour-report.md with a short table, a ranking by q2_revenue_usd, and two risks.",
-  "Create /workspace/outputs/summary.json with keys topProduct, totalQ2RevenueUsd, highestActivationProduct, and riskCount.",
-  "Mention whether the httpbin proxy endpoint is declared, but do not call it unless you need to."
+  "Create /workspace/outputs/summary.json with keys topProduct, totalQ2RevenueUsd, highestActivationProduct, and riskCount."
 ].join(" ");
 
 const firstTurn = session.send(prompt);
@@ -272,10 +257,8 @@ if (report) {
   console.log(reportPreview.text || "(no risk lines found)");
 }
 
-const corpusTools = createCorpusTools(aex, { sessionIds: [session.id] }, { defaultReadBytes: 4_000 });
-const corpusOutputs = await corpusTools.execute("list_outputs", { session_id: session.id });
-console.log("corpus-scoped list_outputs result:");
-console.log(JSON.stringify(corpusOutputs, null, 2));
+const reopenedOutputs = await aex.sessions.outputs(session.id).list();
+console.log(`outputs via aex.sessions.outputs(...): ${reopenedOutputs.length}`);
 
 if (downloadPath) {
   const bytes = await session.download({ to: downloadPath });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aexhq/sdk",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "TypeScript SDK for running autonomous agent sessions across providers (Anthropic, OpenAI, DeepSeek, Gemini, Mistral) behind one interface.",
   "license": "Apache-2.0",
   "repository": {

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

@@ -1,305 +0,0 @@
-/**
- * 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 hosted API
- * bundles the matching CLI artifact, and the e2e suite runs both with
- * the new version.
- */
-export declare const PROXY_PROTOCOL_VERSION: "1";
-/**
- * Streaming named-proxy protocol. A client that sends `"2"` in
- * {@link PROXY_PROTOCOL_HEADER} opts into the streamed response path: the
- * hosted API pipes the upstream body back unbuffered (no base64, no
- * full-body JSON envelope) and carries the envelope metadata
- * in the `x-aex-proxy-*` response headers below instead of a JSON envelope.
- *
- * Additive: `"1"` stays valid and keeps the buffered
- * {@link ProxyResponseEnvelope}. Old runners keep working; new runners
- * stream. The version is on the request header so the hosted API can serve
- * both shapes without a coordinated CLI/BFF release.
- */
-export declare const PROXY_PROTOCOL_VERSION_V2: "2";
-export declare const PROXY_PROTOCOL_HEADER = "x-aex-proxy-protocol";
-/**
- * Response headers for the streamed (v2) named-proxy path. The hosted API sets
- * these BEFORE it starts streaming the upstream body, so the client can
- * reconstruct the same fields the v1 {@link ProxyResponseEnvelope} carried
- * without buffering. All values are plain strings; numeric fields are
- * decimal, booleans are `"true"`/`"false"`.
- */
-export declare const PROXY_RESP_STATUS_HEADER = "x-aex-proxy-status";
-export declare const PROXY_RESP_MODE_HEADER = "x-aex-proxy-effective-mode";
-/**
- * `"true"` when the cap forced truncation, `"false"` when the full body
- * fit, `"unknown"` when the upstream omitted `content-length` and the body
- * happened to reach the cap (can't distinguish exact-fit from over-cap
- * without buffering). See the streaming byte-cap note in proxy-routes.ts.
- */
-export declare const PROXY_RESP_TRUNCATED_HEADER = "x-aex-proxy-truncated";
-/** JSON object of lowercase upstream header names → values (mode-filtered). */
-export declare const PROXY_RESP_UPSTREAM_HEADERS_HEADER = "x-aex-proxy-upstream-headers";
-/**
- * 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];
-export declare const PROXY_RETRY_JITTERS: readonly ["full", "none"];
-export type ProxyRetryJitter = (typeof PROXY_RETRY_JITTERS)[number];
-export interface ProxyRetryPolicy {
-    /** Total attempts, including the initial request. */
-    readonly maxAttempts?: number;
-    readonly initialDelayMs?: number;
-    readonly maxDelayMs?: number;
-    readonly jitter?: ProxyRetryJitter;
-    readonly retryOnStatuses?: readonly number[];
-    readonly retryOnMethods?: readonly ProxyMethod[];
-    readonly respectRetryAfter?: boolean;
-}
-export type ResolvedProxyRetryPolicy = Required<ProxyRetryPolicy>;
-export declare const PROXY_RETRY_POLICY_DEFAULTS: ResolvedProxyRetryPolicy;
-export declare function resolveProxyRetryPolicy(policy: ProxyRetryPolicy): ResolvedProxyRetryPolicy;
-/**
- * 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", "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 retry?: ResolvedProxyRetryPolicy;
-}
-/**
- * Default caps for a proxy endpoint when the submission doesn't specify one.
- * 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.
- *
- * `maxResponseBytes: 0` means UNLIMITED — the v2 path streams the upstream body
- * unbuffered (O(1) memory regardless of size), so there is no cap to apply by
- * default. A customer can opt into a per-response truncation cap by setting a
- * positive value. There is no cumulative per-run call/byte budget: it needed a
- * per-call counter on the hot path and only existed to bound memory, which
- * streaming already does. The platform records named-proxy request bytes,
- * response bytes, attempts, and retries as run-log usage telemetry only; no
- * pricing/charging model is derived here.
- */
-export declare const PROXY_ENDPOINT_DEFAULTS: {
-    readonly allowHeaders: readonly string[];
-    readonly responseMode: ProxyResponseMode;
-    readonly maxRequestBytes: number;
-    readonly maxResponseBytes: 0;
-    readonly timeoutMs: 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 retry?: ProxyRetryPolicy;
-}
-export interface BuildProxyIndexFileInput {
-    readonly runId: string;
-    /**
-     * Hosted API origin that serves `/api/runs/:runId/proxy/:endpointName`.
-     * 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 and audit, 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 platform API 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;
-}
-/**
- * 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>;