@linxiraos/pi-ai 1.1.27 → 1.2.0

package/dist/types/auth-gateway/dispatch.d.ts

@@ -17,6 +17,8 @@ export interface AuthGatewayRouteOptions {
     resolveModel: ModelResolver;
     /** Optional supplier for `/v1/models` listing. Returns the full model array. */
     listModels?: () => Iterable<Model<Api>>;
+    /** Providers the host does not serve; `/v1/usage` and `/v1/credentials/check` leave their accounts out. */
+    excludeProviders?: ReadonlySet<string>;
     /** Upstream transport for every provider call; defaults to global `fetch`. Test seam. */
     fetch?: FetchImpl;
 }
@@ -63,9 +65,11 @@ export declare function resolveGatewayApiKey(storage: AuthStorage, model: Model<
  *   to a sibling (usage-limit block vs credential invalidation by error class).
  *
  * `lastKey` tracks the most recent bearer so the switch step invalidates the
- * credential that actually failed. `onResolvedKey` observes every rotation;
- * routes that retain provider session state use it to re-key the account
- * lease, one-shot routes pass `undefined`.
+ * credential that actually failed; a retry context's `previousKey` wins, since
+ * concurrent operations sharing one resolver (split judgment chunks) each know
+ * the bearer they sent. `onResolvedKey` observes every rotation; routes that
+ * retain provider session state use it to re-key the account lease, one-shot
+ * routes pass `undefined`.
  */
 export declare function buildGatewayApiKeyResolver(storage: AuthStorage, model: Model<Api>, sessionId: string, initialKey: ResolvedApiKey, requestSignal: AbortSignal, format: string, peer: string, onResolvedKey?: (apiKey: string) => void): ApiKeyResolver;
 /**

package/dist/types/auth-gateway/http.d.ts

@@ -16,8 +16,6 @@ export declare function gatewayResponseHeaders(model: Model<Api>, info: {
     costUsd?: number;
     startedAt?: number;
 }): Record<string, string>;
-/** Use the socket peer unless the gateway explicitly trusts its reverse proxy. */
-export declare function resolvePeer(req: Request, socketAddress: string, trustProxyHeaders?: boolean): string;
 /** Keep configured gateway credentials out of URL and forwarded/logged request fields. */
 export declare function hasMisplacedBearer(req: Request, url: URL, tokens: ReadonlySet<string>): boolean;
 /**

package/dist/types/auth-gateway/server.d.ts

@@ -1,12 +1,12 @@
 /**
- * zeta auth-gateway router and HTTP server.
+ * zetacode auth-gateway router and HTTP server.
  *
  * Accepts any provider-format request (OpenAI chat-completions, Anthropic
  * messages, OpenAI Responses) and dispatches through pi-ai's `streamSimple()`
  * — which handles credential injection, anthropic-beta headers, codex
  * websocket transport, and all the per-provider intricacies. The gateway is
- * pure protocol translation: foreign wire → zeta Context → pi-ai stream() →
- * zeta events → foreign wire.
+ * pure protocol translation: foreign wire → omp Context → pi-ai stream() →
+ * omp events → foreign wire.
  *
  * Endpoints:
  *   GET  /healthz                          → unauth; ok + version

package/dist/types/auth-gateway/session-state.d.ts

@@ -63,6 +63,12 @@ export interface AuthGatewaySessionStateRequest {
      * continues.
      */
     context: Context;
+    /**
+     * `JSON.stringify(context.tools)` when the caller already serialized it
+     * (the gateway derives its `sessionId` from the same string). Recomputed
+     * from `context` when absent.
+     */
+    toolsJson?: string;
     /**
      * Stable identity of the account this request's credential resolved to.
      * A change means the gateway switched the session to a sibling credential,

package/dist/types/auth-storage.d.ts

@@ -1,6 +1,6 @@
 import type { AuthCredentialStore } from "./auth/store.js";
 import type { AuthAccountPolicies, AuthApiKeyOptions, AuthStorageOptions, BlocksApi, CredentialsApi, HealthApi, KeysApi, LimitsApi, OAuthApi, ResetsApi, SessionsApi, UsageApi } from "./auth/types.js";
-export { isSqliteBusyError, isSqliteCorruptionError, SqliteAuthCredentialStore } from "./auth/sqlite-credential-store.js";
+export { isSameOAuthAccount, isSqliteBusyError, isSqliteCorruptionError, matchesReplacementCredential, resolveCredentialIdentityKey, SqliteAuthCredentialStore, } from "./auth/sqlite-credential-store.js";
 export * from "./auth/store.js";
 export * from "./auth/types.js";
 /**
@@ -35,8 +35,9 @@ export declare class AuthStorage {
     /**
      * Apply new account routing policy (live `auth.accountPolicies` /
      * `retry.usageReservePct` change). Throws a configuration error, leaving the
-     * active policy untouched, when the policy is malformed or does not match the
-     * stored OAuth accounts.
+     * active policy untouched, when a policy is malformed, a selector matches
+     * several stored OAuth accounts, or two policies claim the same account; a
+     * policy naming an absent account stays inactive and logs a warning.
      */
     setAccountPolicies(config: {
         accountPolicies: AuthAccountPolicies;
@@ -46,9 +47,9 @@ export declare class AuthStorage {
      * Swap the backing credential store in place (live `auth.broker.url` change).
      * Loads `store` into fresh store-bound state — pins, blocks, and usage caches are
      * keyed by the old store's row ids — then closes the previous store. Runtime key
-     * overrides, account policies, usage-provider overrides, and credential event
-     * subscribers carry over. On a load failure `store` is closed and the current
-     * store stays active.
+     * overrides, account policies, session account restrictions, usage-provider
+     * overrides, and credential event subscribers carry over. On a load failure
+     * `store` is closed and the current store stays active.
      */
     replaceStore(store: AuthCredentialStore, options?: {
         sourceLabel?: string;

package/dist/types/dialect/terminator-wait.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Fast path for in-band scanners that sit inside a body waiting for one fixed
+ * terminator (a tool-call close tag) and emit nothing until it arrives.
+ *
+ * Appending each delta to the scanner's string buffer and calling `indexOf` on
+ * it flattens the growing rope on every delta, so a long in-band tool call cost
+ * O(n²) copying and scanning. While armed, deltas are set aside and only the new
+ * text plus the terminator-length overlap with what came before is searched;
+ * the buffer is rebuilt once, when the terminator shows up or the stream ends.
+ */
+export declare class TerminatorWait {
+    #private;
+    /** Start deferring; `buffered` is the scanner's pending body, known not to contain `terminator`. */
+    arm(terminator: string, buffered: string): void;
+    /** Take `text` while the terminator is still absent; false means the caller must {@link release} and scan. */
+    absorb(text: string): boolean;
+    /** Stop deferring and return `buffered` with every absorbed delta appended. */
+    release(buffered: string): string;
+}

package/dist/types/env-api-key.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Get API key for provider from known environment variables, e.g. OPENAI_API_KEY.
+ *
+ * Will not return API keys for providers that require OAuth tokens.
+ * Checks Bun.env, then cwd/.env, then ~/.env.
+ */
+export declare function getEnvApiKey(provider: string): string | undefined;
+/**
+ * Name of the environment variable that backs `getEnvApiKey` for a provider,
+ * when that provider maps to a single named variable (e.g. `github-copilot` →
+ * `COPILOT_GITHUB_TOKEN`). Returns undefined for providers whose env fallback
+ * is computed (multi-var pickers, Vertex ADC / Bedrock probes, …) since no
+ * single variable name describes the source.
+ */
+export declare function getEnvApiKeyName(provider: string): string | undefined;
+/**
+ * Enumerate every provider that has an env-var fallback for `getEnvApiKey`.
+ * Used by `zetacode auth-broker migrate --include-env` to discover env-sourced keys
+ * that should be uploaded to the broker.
+ */
+export declare function listProvidersWithEnvKey(): string[];

package/dist/types/error/auth.d.ts

@@ -10,6 +10,16 @@ export declare class MissingApiKeyError extends Error {
     readonly provider: string | undefined;
     constructor(provider?: string, message?: string);
 }
+/**
+ * Every usable OAuth credential for a provider failed to refresh with a
+ * retryable error (network blip, timeout, 5xx). The stored credentials are
+ * intact, so this is classified transient: retrying the request can succeed,
+ * unlike {@link MissingApiKeyError}. The refresh failure is kept as `cause`.
+ */
+export declare class OAuthRefreshUnavailableError extends Error {
+    readonly provider: string;
+    constructor(provider: string, cause: unknown);
+}
 /** A user-facing login flow required an `onPrompt` callback that was not supplied. */
 export declare class OnPromptRequiredError extends Error {
     constructor(providerLabel: string);

package/dist/types/error/flags.d.ts

@@ -23,6 +23,16 @@ export declare const Flag: {
     readonly FastModeUnsupported: 536870912;
     /** OAuth refresh failed definitively — the stored grant is dead, re-login required. */
     readonly OAuthExpiry: 1073741824;
+    /**
+     * An Anthropic-compatible endpoint rejected the `cache_control` field with a
+     * 400, so prompt-cache breakpoints must be dropped for it.
+     *
+     * Every bit from {@link Flag.Class} up is already taken, so this claims a low
+     * bit instead. Those belong to the raw-status lane — an unclassified id is an
+     * HTTP status (100-599, see `statusFromId`) — and 0x800 is 2048, above every
+     * status value, so no raw status id can set it.
+     */
+    readonly CacheControlUnsupported: 2048;
     /** HTTP 413 byte/media rejection — token compaction cannot shrink bytes or media budgets (#9235). */
     readonly PayloadRejected: 2147483648;
 };
@@ -113,6 +123,19 @@ export declare function isGrammarError(error: unknown): boolean;
  * Accessor for {@link Flag.FastModeUnsupported}.
  */
 export declare function isFastModeUnsupported(error: unknown): boolean;
+/**
+ * An Anthropic-compatible endpoint returned a 400 rejecting something about
+ * `cache_control`. Whether it refused the field or one nested option is not
+ * decidable here (see {@link CACHE_CONTROL_FIELD_PATTERN}); the caller's retry
+ * ladder settles it by replaying.
+ * Accessor for {@link Flag.CacheControlUnsupported}.
+ *
+ * Unlike the high-bit accessors this also requires a classified id. The flag
+ * sits in the raw-status lane (see {@link Flag.CacheControlUnsupported}), and
+ * while no HTTP status reaches 0x800, `is` is a bare bit test — the extra gate
+ * keeps a stray non-HTTP status out of the retry path.
+ */
+export declare function isCacheControlUnsupported(error: unknown): boolean;
 /**
  * Cline's gateway gates some roster entries (certain free-tier models) to its
  * own product surfaces with a 403. The API key is valid — the restriction is

package/dist/types/images/index.d.ts

@@ -1,4 +1,4 @@
-import type { Api, Model } from "@linxiraos/pi-catalog/types";
+import { type Api, type ImageGenerationApi, type Model } from "@linxiraos/pi-catalog/types";
 import type { ImageGenerationOptions, ImageGenerationRequest, ImageGenerationResult } from "./types.js";
 export * from "./google-antigravity.js";
 export * from "./google-generative-ai.js";
@@ -6,8 +6,7 @@ export * from "./openai-hosted.js";
 export * from "./openai-images.js";
 export * from "./openrouter-images.js";
 export * from "./types.js";
-/** Catalog APIs {@link generateImage} serves; the hosted Responses pair needs an explicit carrier model. */
-export type ImageGenerationApi = "openai-images" | "openrouter-images" | "google-generative-ai" | "google-gemini-cli" | "openai-responses" | "openai-codex-responses";
+export type { ImageGenerationApi } from "@linxiraos/pi-catalog/types";
 /** Whether a catalog API generates images through one of the pi-ai image clients. */
 export declare function isImageGenerationApi(api: Api): api is ImageGenerationApi;
 /** Generate (or edit, when `request.inputImages` is set) images through the transport selected by the model's `api`. */

package/dist/types/images/shared.d.ts

@@ -32,6 +32,12 @@ export declare function decodeImageResponse(value: unknown, fetch: FetchImpl, si
     images: GeneratedImage[];
     usage: Usage;
 }>;
+/**
+ * Mime type of a base64 image, read from its header only. 64 base64 chars
+ * decode to 48 bytes, past every magic number `parseImageMetadata` checks, so
+ * multi-MB payloads are never fully decoded just to be labelled.
+ */
+export declare function sniffBase64ImageMimeType(base64: string): string | undefined;
 export declare function toDataUrl(image: GeneratedImage): string;
 export declare function resolveOpenAIImageSize(aspectRatio?: string, imageSize?: string): string | undefined;
 export {};

package/dist/types/index.d.ts

@@ -39,6 +39,7 @@ export type * from "./providers/openai-responses.js";
 export type * from "./providers/synthetic.js";
 export * from "./registry/index.js";
 export { resolveCacheRetention } from "./utils.js";
+export * from "./env-api-key.js";
 export * from "./stream.js";
 export * from "./types.js";
 export * from "./usage.js";

package/dist/types/judgment/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./chat.js";
+export * from "./native.js";
+export * from "./question-file.js";
 export * from "./text.js";
 export * from "./types.js";
-export * from "./typesafe.js";

package/dist/types/judgment/native.d.ts

@@ -0,0 +1,80 @@
+import type { Api, FetchImpl } from "@linxiraos/pi-catalog/types";
+import { type ApiKey } from "../auth-retry.js";
+import * as AIError from "../error/index.js";
+import type { Model, Usage } from "../types.js";
+import { type Judge, type JudgeOptions, type JudgmentRequest, type JudgmentResult, type Questions } from "./types.js";
+import type { JudgmentWire } from "./wire.js";
+export declare const TYPESAFE_PROVIDER = "typesafe";
+export declare const TYPESAFE_DEFAULT_MODEL = "jev-latest";
+declare const JUDGMENT_WIRES: {
+    readonly typesafe: JudgmentWire;
+    readonly "openrouter-decisions": JudgmentWire;
+    readonly "workers-ai-systemone": JudgmentWire;
+    readonly "openai-decisions": JudgmentWire;
+};
+/** APIs {@link NativeJudge} can serve. */
+export type JudgmentApi = keyof typeof JUDGMENT_WIRES;
+/** Whether a catalog API answers judgments natively. */
+export declare function isJudgmentApi(api: Api): api is JudgmentApi;
+/** `TYPESAFE_BASE_URL` when set, else the public API root; trailing slashes stripped. */
+export declare function typesafeBaseUrl(): string;
+/** `TYPESAFE_DEFAULT_MODEL` when set, else {@link TYPESAFE_DEFAULT_MODEL}. */
+export declare function typesafeModel(): string;
+/** Credential and transport overrides for a judge; see {@link createNativeJudge}. */
+export interface NativeJudgeConnection {
+    apiKey: ApiKey;
+    /** Static headers attached to judgment requests (e.g. proxy routing, gateway auth). */
+    headers?: Record<string, string>;
+    fetch?: FetchImpl;
+}
+export interface NativeJudgeOptions extends NativeJudgeConnection {
+    /** Wire dialect; defaults to TypeSafe's own API. */
+    api?: JudgmentApi;
+    /** Catalog provider reported on results; defaults to {@link TYPESAFE_PROVIDER}. */
+    provider?: string;
+    /** Defaults to {@link typesafeBaseUrl}. */
+    baseUrl?: string;
+    /** Wire model id; defaults to {@link typesafeModel}. */
+    model?: string;
+    /** Per-attempt timeout; defaults to {@link DEFAULT_TIMEOUT_MS}. */
+    timeoutMs?: number;
+    /**
+     * Most questions per request the endpoint accepts, a positive integer; larger
+     * requests are split. Unset: no cap.
+     */
+    maxQuestions?: number;
+}
+/** Per-call options for {@link NativeJudge.judge}. */
+export interface NativeJudgeCallOptions extends JudgeOptions {
+    /**
+     * Called before a split judgment rejects, with the summed usage of the chunks that had already
+     * succeeded: billed upstream, but their answers are discarded with the failure. Not called when
+     * no chunk succeeded or the request was not split.
+     */
+    onPartialUsage?: (usage: Usage) => void;
+}
+/** Non-2xx response from a native judgment API. */
+export declare class JudgmentApiError extends AIError.ProviderHttpError {
+    readonly name = "JudgmentApiError";
+}
+export declare class NativeJudge implements Judge {
+    #private;
+    readonly label: string;
+    readonly api: JudgmentApi;
+    readonly provider: string;
+    /** Wire model id sent with every request. */
+    readonly model: string;
+    readonly baseUrl: string;
+    constructor(options: NativeJudgeOptions);
+    judge<Q extends Questions>(request: JudgmentRequest<Q>, options?: NativeJudgeCallOptions): Promise<JudgmentResult<Q>>;
+}
+/**
+ * The {@link NativeJudge} for a catalog judge model: its API's dialect, wire id
+ * (`requestModelId ?? id`), base URL, and catalog question cap
+ * (`judgment-questions-max`). Shared by the coding agent's judge chain and the
+ * auth-gateway System One route so both address a model the same way.
+ *
+ * @throws ConfigurationError when the model's API is not a judgment API.
+ */
+export declare function createNativeJudge(model: Model, connection: NativeJudgeConnection): NativeJudge;
+export {};

package/dist/types/judgment/openai-decisions.d.ts

@@ -0,0 +1,3 @@
+import { type JudgmentWire } from "./wire.js";
+/** OpenAI's `/v1/decisions` route. */
+export declare const openaiDecisionsWire: JudgmentWire;

package/dist/types/judgment/question-file.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Judge questions authored as JSON files: `instructions` plus optional
+ * `criteria`, keyed by question id. A JSON import widens every string, so a
+ * question's kind follows from the shape of its `criteria` rather than a
+ * `type` field — the same rule at compile time ({@link QuestionFor}) and at
+ * load ({@link judgeQuestions}):
+ * - a list of levels, lowest first → {@link ScoreQuestion}
+ * - absent, or only `true`/`false` rubrics → {@link NoulQuestion}
+ * - any other labels → {@link ChoiceQuestion} over them; `{}` when the caller
+ *   supplies every label (table rows, labels shared with another question)
+ *
+ * Instructions may be Handlebars templates; {@link renderQuestion} fills them.
+ *
+ * @example
+ * ```ts ignore
+ * import graph from "./auto-graph.json" with { type: "json" };
+ * const QUESTIONS = judgeQuestions(graph);
+ * QUESTIONS.shading; // ChoiceQuestion<"shared" | "series" | "row">
+ * renderQuestion(QUESTIONS.order, { column: "latency" });
+ * ```
+ */
+import { prompt } from "@linxiraos/pi-utils";
+import type { ChoiceQuestion, NoulQuestion, Question, ScoreQuestion } from "./types.js";
+/** One question as a JSON question file writes it; {@link QuestionFor} gives its kind. */
+export interface QuestionSpec {
+    instructions: string;
+    criteria?: string[] | {
+        readonly [label: string]: string | null;
+    };
+}
+/** A JSON question file: {@link QuestionSpec}s keyed by question id. */
+export interface QuestionFile {
+    readonly [id: string]: QuestionSpec;
+}
+/** The question a {@link QuestionSpec} declares, with choice labels taken from its criteria keys. */
+export type QuestionFor<S extends QuestionSpec> = S extends {
+    criteria: string[];
+} ? ScoreQuestion : S extends {
+    criteria: infer C extends object;
+} ? [keyof C] extends [never] ? ChoiceQuestion : [keyof C] extends ["true" | "false"] ? NoulQuestion : ChoiceQuestion<Extract<keyof C, string>> : NoulQuestion;
+/** Every question a {@link QuestionFile} declares, keyed as in the file. */
+export type QuestionsFor<F extends QuestionFile> = {
+    [K in keyof F]: QuestionFor<F[K]>;
+};
+/**
+ * The typed questions of a JSON question file; answers to them come back typed
+ * through {@link JudgmentResult}.
+ * @throws when a score question lists fewer than two levels.
+ */
+export declare function judgeQuestions<F extends QuestionFile>(file: F): QuestionsFor<F>;
+/** `question` with its instructions rendered as a Handlebars template over `context`. */
+export declare function renderQuestion<Q extends Question>(question: Q, context: prompt.TemplateContext): Q;

package/dist/types/judgment/systemone.d.ts

@@ -0,0 +1,7 @@
+import { type JudgmentWire } from "./wire.js";
+/** TypeSafe's own route, shared by every System One server. */
+export declare const typesafeWire: JudgmentWire;
+/** OpenRouter Decisions: the System One body under `/api/alpha`. */
+export declare const openrouterDecisionsWire: JudgmentWire;
+/** Cloudflare Workers AI decision models (Clef) through the account-scoped `ai/run` route. */
+export declare const workersAiWire: JudgmentWire;

package/dist/types/judgment/types.d.ts

@@ -7,7 +7,7 @@
  * — about one {@link JudgmentState}. Every question in a request sees the same
  * state and is answered independently, so callers batch independent questions
  * into one call. The shape mirrors TypeSafe's System One API so the native
- * backend ({@link TypeSafeJudge}) forwards requests verbatim, while the text
+ * backend ({@link NativeJudge}) forwards requests verbatim, while the text
  * bridge ({@link TextJudge}) renders the same questions into keyword prompts
  * for an ordinary chat model.
  */
@@ -75,7 +75,7 @@ export interface JudgmentRequest<Q extends Questions = Questions> {
     questions: Q;
 }
 export interface JudgmentResult<Q extends Questions = Questions> {
-    /** Transport that produced the answers (`typesafe`, or the chat model's api). */
+    /** Transport that produced the answers (a judgment api such as `typesafe`, or the chat model's api). */
     api: string;
     provider: string;
     model: string;

package/dist/types/judgment/wire.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Wire dialects of the native judgment APIs: how {@link NativeJudge} addresses,
+ * encodes, and decodes one request for each API it serves. Internal to the
+ * judgment module; `native.ts` maps every judgment API to its dialect.
+ */
+import type { Usage } from "../types.js";
+import type { JudgmentRequest } from "./types.js";
+/** Where one attempt posts and which bearer token it sends. */
+export interface JudgmentTarget {
+    url: string;
+    token: string;
+}
+/** One decoded response. */
+export interface DecodedJudgment {
+    /** Model that answered, when the response names one. */
+    model: string | undefined;
+    /** Wire answers keyed by question id; {@link NativeJudge} checks each against its question's type. */
+    answers: Readonly<Record<string, unknown>>;
+    /** Question ids the model declined to answer. */
+    refused: readonly string[];
+    usage: Usage;
+}
+/** How one judgment API addresses, encodes, and decodes a request. */
+export interface JudgmentWire {
+    /**
+     * Target of one attempt made with credential `key` against `model`.
+     * Throws when the credential cannot address the endpoint (e.g. no account id).
+     */
+    target(baseUrl: string, model: string, key: string): JudgmentTarget;
+    /** Request body for `model`. */
+    encode(request: JudgmentRequest, model: string): unknown;
+    /** The response's answers and usage; `undefined` when the payload is not this API's response shape. */
+    decode(payload: unknown): DecodedJudgment | undefined;
+}
+/** `value` when it is a finite number. */
+export declare function finiteNumber(value: unknown): number | undefined;

package/dist/types/provider-details.d.ts

@@ -14,7 +14,7 @@ export interface ProviderDetailsContext {
     authMode?: string;
     /**
      * Human-readable description of the active credential, e.g.
-     * `"broker http://omp.internal:8765 · oauth #5 (foo@bar.com)"`.
+     * `"broker http://zeta.internal:8765 · oauth #5 (foo@bar.com)"`.
      * Rendered as a `Source` field; omitted when undefined.
      */
     credentialSource?: string;

package/dist/types/provider-session-state.d.ts

@@ -18,8 +18,8 @@
  *   siblings are endpoint-scoped and stay: `strictToolsDisabled`
  *   (grammar-too-large 400 for the model's tool schema),
  *   `replayUnsignedThinkingDisabled` / `thinkingReplayDisabled` (the endpoint
- *   is a signing proxy), `prefixDroppedThinkingBlocks` (blocks the API itself
- *   dropped).
+ *   is a signing proxy), `prefixDroppedThinkingBlocks` (blocks a prefix-binding
+ *   400 made the client strip).
  * - **OpenAI Responses** — the `previous_response_id` chain baselines are
  *   account-scoped: a stored response belongs to the account that created it.
  *   Strict-tools / reasoning-effort fallbacks, replay warmup and the chaining

package/dist/types/providers/anthropic-client.d.ts

@@ -94,6 +94,13 @@ export interface AnthropicMessagesClientLike {
             create(params: MessageCreateParams, options?: AnthropicRequestOptions): unknown;
         };
     };
+    /**
+     * Endpoint the client targets, when it exposes one. SDK-style clients
+     * (`Anthropic`, `AnthropicVertex`) and {@link AnthropicMessagesClient}
+     * publish it; a client that exposes none keeps its transport opaque, and the
+     * provider must not assume the model's own routing on its behalf.
+     */
+    baseURL?: string;
 }
 export declare class AnthropicMessagesClient implements AnthropicMessagesClientLike {
     #private;
@@ -101,12 +108,15 @@ export declare class AnthropicMessagesClient implements AnthropicMessagesClientL
     readonly beta: {
         readonly messages: AnthropicMessages;
     };
+    /** Endpoint shared with the HTTP transport. */
+    get baseURL(): string;
     constructor(options: AnthropicClientOptions);
     request(path: string, params: MessageCreateParams, options?: AnthropicRequestOptions): AnthropicApiRequest;
 }
 /** Shared Anthropic HTTP transport for Messages and resource APIs. */
 export declare class AnthropicHttpClient {
     #private;
+    readonly baseURL: string;
     constructor(options: AnthropicClientOptions);
     request(method: "GET" | "POST", path: string, params?: unknown, options?: AnthropicRequestOptions): Promise<Response>;
 }

package/dist/types/providers/anthropic-state.d.ts

@@ -1,6 +1,8 @@
 import type { Api, Model, ProviderSessionState } from "../types.js";
 /** Root key for Anthropic's per-session provider state. */
 export declare const ANTHROPIC_PROVIDER_SESSION_STATE_KEY = "anthropic-messages";
+/** Caller-map anchor for session-scoped opaque injected clients. */
+export declare const ANTHROPIC_OPAQUE_CLIENT_ANCHOR_KEY = "anthropic-opaque-clients";
 /** Normalize an Anthropic base URL to its origin path without `/v1`. */
 export declare function normalizeAnthropicBaseUrl(baseUrl?: string): string | undefined;
 /** Resolve the endpoint for a first-party Anthropic model without loading its provider implementation. */

package/dist/types/providers/anthropic.d.ts

@@ -135,6 +135,13 @@ export type AnthropicClientOptionsArgs = {
     thinkingEnabled?: boolean;
     thinkingDisplay?: AnthropicThinkingDisplay;
     disableStrictTools?: boolean;
+    /**
+     * Withhold the prompt-cache betas (see `buildClaudeCodeBetas`). Set when the
+     * request carries no breakpoint at all, and also when it carries breakpoints
+     * stripped of `ttl`/`scope`: both betas govern those options, so a body
+     * without them must advertise neither.
+     */
+    dropPromptCacheBetas?: boolean;
     fetch?: FetchImpl;
     maxRetryDelayMs?: number;
     sessionId?: string;
@@ -169,6 +176,12 @@ export type AnthropicClientOptionsResult = {
  * omitted there.
  */
 export declare function resolveAnthropicCustomHeadersForBaseUrl(baseUrl: string | undefined): Record<string, string> | undefined;
+/**
+ * Merge headers case-insensitively; later sources win and preserve their key casing.
+ * Undefined sources are ignored. Differently cased duplicates are removed so the
+ * Headers constructor cannot join competing values comma-separated on the wire.
+ */
+export declare function mergeHeaders(...headerSources: (Record<string, string> | undefined)[]): Record<string, string>;
 export type AnthropicUsageLike = {
     cache_creation?: {
         ephemeral_5m_input_tokens?: number | null;
@@ -212,8 +225,17 @@ type SystemBlockOptions = {
     extraInstructions?: string[];
     /** Text of the first conversational wire user turn, used as the billing fingerprint seed. */
     firstUserMessageText?: string;
-    /** Cache lifetime shared by the OAuth system breakpoint and later message breakpoints. */
+    /**
+     * Cache lifetime shared by the OAuth system breakpoint and later message
+     * breakpoints. Omitted → the identity block keeps its default `ephemeral`
+     * breakpoint; see `dropCacheControl` to emit none at all.
+     */
     cacheControl?: AnthropicCacheControl;
+    /**
+     * Emit no `cache_control` on any block: the endpoint rejected the field.
+     * Distinct from an undefined `cacheControl`, which only means "default".
+     */
+    dropCacheControl?: boolean;
 };
 export declare function buildAnthropicSystemBlocks(systemPrompt: readonly string[] | undefined, options?: SystemBlockOptions): AnthropicSystemBlock[] | undefined;
 export declare function normalizeExtraBetas(betas?: string[] | string): string[];

package/dist/types/providers/connect-frame.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Connect-protocol streaming envelope shared by the Cursor and Devin
+ * transports: 1 flag byte + 4-byte big-endian payload length + payload.
+ */
+/** Flag bit: payload is compressed with the negotiated encoding (gzip). */
+export declare const CONNECT_COMPRESSED_FLAG = 1;
+/** Flag bit: payload is the end-of-stream JSON trailer. */
+export declare const CONNECT_END_STREAM_FLAG = 2;
+/** Wrap one Connect-protocol message: 1 flag byte + 4-byte big-endian length + payload. */
+export declare function frameConnectMessage(data: Uint8Array, flags?: number): Buffer;
+/** One decoded Connect envelope. */
+export interface ConnectFrame {
+    flags: number;
+    payload: Buffer;
+}
+/** Options for {@link ConnectFrameDecoder}. */
+export interface ConnectFrameDecoderOptions {
+    /**
+     * Payload cap: a length prefix above `maxPayloadBytes` throws `error(length)`
+     * before any of that payload is buffered. Uncapped when omitted.
+     */
+    limit?: {
+        maxPayloadBytes: number;
+        error: (length: number) => Error;
+    };
+}
+/**
+ * Incremental Connect frame decoder. Incoming chunks are kept as-is and a frame
+ * spanning several chunks is joined once, when the length the header announced
+ * has fully arrived — re-concatenating the pending bytes on every chunk made a
+ * multi-MB frame cost O(size × chunks).
+ *
+ * Payloads alias the chunk they came from whenever a frame fits in one chunk,
+ * so callers must not reuse chunk buffers they hand in.
+ */
+export declare class ConnectFrameDecoder {
+    #private;
+    constructor(options?: ConnectFrameDecoderOptions);
+    /**
+     * Buffer `chunk` (if any) and yield every frame now complete, in wire order.
+     * An oversize length prefix throws after the frames that precede it.
+     */
+    decode(chunk?: Uint8Array): Generator<ConnectFrame, void, undefined>;
+}

package/dist/types/providers/cursor/interaction-query.d.ts

@@ -7,8 +7,6 @@ type ProtoUnknownField = {
 interface CursorInteractionWriter {
     write(frame: Uint8Array): void;
 }
-/** Wrap one Connect-protocol message: 1 flag byte + 4-byte big-endian length + payload. */
-export declare function frameConnectMessage(data: Uint8Array, flags?: number): Buffer;
 /** Well-formed protobuf-es `$unknown` entries on `message`; anything else on the bag is ignored. */
 export declare function protoUnknownFields(message: object): ProtoUnknownField[];
 /**