@tensorcost/sdk 1.2.0 → 1.3.1

package/dist/admit-client.d.ts

@@ -1,40 +0,0 @@
-/**
- * Govern-layer admit — metadata-only POST /api/inference-proxy/v1/admit.
- *
- * Fail-open on transport failure: the customer's call proceeds to the
- * provider and an error observation is emitted when transport is available.
- */
-import type { ControlLayer } from "./layer.js";
-import type { Operation, Provider } from "./types.js";
-import type { ObservationTransport } from "./transport.js";
-export interface AdmitMetadata {
-    provider: Provider;
-    model: string;
-    operation: Operation;
-    correlation_id: string;
-    environment?: string | null;
-    connection_id?: string | null;
-    agent_id?: string;
-    workflow_id?: string;
-    customer?: string;
-    feature?: string;
-    application?: string | null;
-    tags?: string[];
-    team_id?: string | null;
-}
-export interface AdmitRequestOptions {
-    baseUrl: string;
-    bearerToken: string;
-    maxLayer: ControlLayer;
-    metadata: AdmitMetadata;
-    transport?: ObservationTransport;
-    failOpen?: boolean;
-    timeoutMs?: number;
-    fetchImpl?: typeof fetch;
-}
-export interface AdmitResult {
-    allowed: boolean;
-    decisionHeader: string | null;
-}
-export declare function admitRequest(opts: AdmitRequestOptions): Promise<AdmitResult>;
-//# sourceMappingURL=admit-client.d.ts.map

package/dist/applied.d.ts

@@ -1,104 +0,0 @@
-/**
- * Applied-mode wiring — Layer 2.
- *
- * When the customer opts into applied mode, the SDK routes every inference
- * request through the TensorCost inference-proxy instead of directly to the
- * upstream AI provider. The proxy decides per-request whether to re-route
- * or pass through unchanged; the SDK doesn't make that call.
- *
- * The mechanism is straightforward: at `wrap()` time we read the
- * provider's original baseURL and auth from the client, permanently
- * redirect the client's baseURL to the proxy endpoint, and inject two
- * custom headers the proxy expects:
- *
- *   x-tc-provider-url   — the original provider base URL
- *   x-tc-provider-auth  — the auth header value to forward upstream
- *
- * Both the OpenAI SDK and the Anthropic SDK expose `baseURL` and
- * `defaultHeaders` as first-class properties, so we can set them
- * without monkey-patching the HTTP layer.
- *
- * Bedrock is not supported in v1. The AWS SDK uses SigV4 signing on
- * regional endpoints and doesn't expose baseURL / defaultHeaders in
- * the same shape. Passing a Bedrock-shaped client with appliedMode=true
- * throws `TensorCostConfigError` at wrap time.
- *
- * Observe-only telemetry (the 0.2.x substrate) continues to fire
- * after every call regardless of this setting.
- */
-/**
- * Client shapes we understand. All detection is duck-typed; no import
- * of the actual openai or @anthropic-ai/sdk packages.
- */
-/** Header value the proxy expects for OpenAI + Azure OpenAI. */
-declare function bearerAuth(apiKey: string): string;
-/** Header value the proxy expects for Anthropic. */
-declare function anthropicAuth(apiKey: string): string;
-/**
- * Read the original baseURL from a duck-typed client. Both the OpenAI
- * and Anthropic SDKs expose a `baseURL` string property on the client
- * instance (the actual HTTP origin, e.g. "https://api.openai.com/v1").
- * Returns null when the property is absent or not a string.
- */
-declare function readBaseUrl(client: Record<string, unknown>): string | null;
-/**
- * Read the API key from the client. OpenAI SDK exposes `client.apiKey`;
- * Anthropic SDK exposes `client.apiKey` too. Returns null when absent.
- */
-declare function readApiKey(client: Record<string, unknown>): string | null;
-/**
- * Detect whether this client looks like an Azure OpenAI client (the
- * openai package's `AzureOpenAI` subclass). Azure uses `api-key` header
- * auth and a custom endpoint URL, so the auth value we forward differs
- * from vanilla OpenAI.
- *
- * Detection: Azure clients have an `azure` property set to true, OR
- * their baseURL contains `.openai.azure.com`.
- */
-declare function isAzureOpenAI(client: Record<string, unknown>): boolean;
-/**
- * Azure OpenAI uses an `api-key` header rather than `Authorization: Bearer`.
- * The proxy forwards `x-tc-provider-auth` verbatim as the upstream auth
- * header, so we need to format it as the proxy expects: "api-key <value>".
- *
- * Note: The proxy currently only supports `Authorization` and `api-key`
- * style headers. This value is forwarded in the `x-tc-provider-auth`
- * header and then sent by the proxy as the upstream Authorization.
- */
-declare function azureAuth(apiKey: string): string;
-/**
- * Install applied-mode routing on the client. Called once by `wrap()`.
- *
- * Mutates `client.baseURL` to point at the proxy endpoint and injects
- * `x-tc-provider-url` / `x-tc-provider-auth` into `client.defaultHeaders`.
- * These headers survive for the lifetime of the client — every subsequent
- * request automatically carries them.
- *
- * @param client   - The customer's AI SDK client (duck-typed).
- * @param proxyUrl - The TensorCost proxy base URL (already stripped of trailing slash).
- * @param provider - "openai" | "anthropic", as detected by detectProvider().
- *
- * @throws TensorCostConfigError
- *   - If the client doesn't expose `baseURL` (can't determine the original
- *     provider URL to forward in `x-tc-provider-url`).
- *   - If the client doesn't expose `apiKey` (can't build `x-tc-provider-auth`).
- *   - If the provider is "bedrock" (not yet supported in v1).
- */
-export declare function installAppliedMode(client: unknown, proxyUrl: string, provider: "openai" | "anthropic", scope?: {
-    application?: string | null;
-    tags?: string[];
-    customer?: string | null;
-    feature?: string | null;
-    teamId?: string | null;
-}): void;
-export declare const PROXY_PATH_SUFFIX = "/api/inference-proxy/v1/chat/completions";
-export declare const __test__: {
-    readBaseUrl: typeof readBaseUrl;
-    readApiKey: typeof readApiKey;
-    isAzureOpenAI: typeof isAzureOpenAI;
-    bearerAuth: typeof bearerAuth;
-    anthropicAuth: typeof anthropicAuth;
-    azureAuth: typeof azureAuth;
-};
-export {};
-//# sourceMappingURL=applied.d.ts.map

package/dist/circuit-observations.d.ts

@@ -1,12 +0,0 @@
-/**
- * Emit circuit-breaker state transitions as observations (Phase 4).
- */
-import type { CircuitState } from "./circuit.js";
-import type { ObservationTransport } from "./transport.js";
-import type { Provider } from "./types.js";
-export declare function bindCircuitObservations(transport: ObservationTransport, ctx: {
-    provider: Provider;
-    tenantId: string | null;
-    environment: string | null;
-}): (from: CircuitState, to: CircuitState) => void;
-//# sourceMappingURL=circuit-observations.d.ts.map

package/dist/circuit.d.ts

@@ -1,67 +0,0 @@
-/**
- * Circuit breaker for the fail-open fallback (Feature E).
- *
- * Tracks consecutive proxy failures. When the failure count hits
- * `openThreshold`, the circuit opens and all subsequent requests route
- * directly to the provider instead of through the proxy. The circuit
- * moves back to closed once `closeThreshold` consecutive probe calls
- * (which go through the proxy) succeed.
- *
- * State machine:
- *
- *   CLOSED ──(failures >= openThreshold)──> OPEN
- *   OPEN   ──(single-flight probe)───────> HALF_OPEN
- *   HALF_OPEN ──(proxy 2xx)──────────────> probeSuccesses++
- *              ──(proxy 5xx/err)──────────> back to OPEN (resets probes)
- *   HALF_OPEN ──(probeSuccesses >= closeThreshold)──> CLOSED
- *
- * This is intentionally simple and synchronous — the circuit lives on the
- * SDK client instance and is not shared across network calls.
- */
-export type CircuitState = "CLOSED" | "OPEN" | "HALF_OPEN";
-export interface CircuitBreakerConfig {
-    /** Number of consecutive proxy failures before the circuit opens. Default: 3. */
-    openThreshold: number;
-    /** Number of consecutive successful probes before the circuit closes. Default: 5. */
-    closeThreshold: number;
-}
-export declare const DEFAULT_CIRCUIT_CONFIG: CircuitBreakerConfig;
-export type CircuitTransitionListener = (from: CircuitState, to: CircuitState) => void;
-export declare class CircuitBreaker {
-    private state;
-    private consecutiveFailures;
-    private probeSuccesses;
-    /** True while a HALF_OPEN probe is in flight (single-flight). */
-    private probeInFlight;
-    readonly config: CircuitBreakerConfig;
-    private readonly onTransition?;
-    constructor(config?: CircuitBreakerConfig, onTransition?: CircuitTransitionListener);
-    private transition;
-    /** Current circuit state. */
-    get currentState(): CircuitState;
-    /** How many consecutive failures have been recorded. */
-    get failures(): number;
-    /**
-     * Returns true when calls should bypass the proxy and go directly to the
-     * provider. The caller must always call `recordSuccess` or `recordFailure`
-     * afterwards to keep the state machine moving.
-     */
-    shouldBypass(): boolean;
-    /**
-     * Returns true when this caller should run the single-flight HALF_OPEN
-     * probe (OPEN → HALF_OPEN). Concurrent OPEN callers get false and bypass.
-     */
-    shouldProbe(): boolean;
-    /** Call after a proxy request succeeds. */
-    recordSuccess(): void;
-    /**
-     * Clear a HALF_OPEN probe that never reached recordSuccess/recordFailure
-     * (e.g. token exchange threw before the HTTP call). Idempotent once the
-     * probe has settled.
-     */
-    releaseStuckProbe(): void;
-    /** Call after a proxy request fails (5xx or network error). */
-    recordFailure(): void;
-    private reset;
-}
-//# sourceMappingURL=circuit.d.ts.map

package/dist/compliance-guard.d.ts

@@ -1,16 +0,0 @@
-/**
- * Client-side compliance — team narrow-check + in-process DLP before provider calls.
- */
-import { type DlpScanResult } from "./dlp.js";
-import type { CompiledComplianceSnapshot } from "./layer.js";
-export interface ComplianceStamp {
-    compliance_frameworks?: string[];
-    dlp_action?: string;
-}
-export declare function assertTeamScope(args: {
-    tokenTeamId?: string | null;
-    clientTeamId?: string | null;
-}): void;
-export declare function enforceInProcessDlp(text: string, snapshot: CompiledComplianceSnapshot | null | undefined, args?: unknown[]): DlpScanResult;
-export declare function complianceStampFrom(snapshot: CompiledComplianceSnapshot | null | undefined, dlp: DlpScanResult): ComplianceStamp;
-//# sourceMappingURL=compliance-guard.d.ts.map

package/dist/compliance-team.d.ts

@@ -1,11 +0,0 @@
-/** Narrow-only team resolution — mirrors @tensorcost/contracts (no runtime dep). */
-export type TeamResolutionError = "compliance_team_mismatch";
-export interface ResolvedTeamContext {
-    teamId: string | null;
-    error?: TeamResolutionError;
-}
-export declare function resolveEffectiveTeam(args: {
-    tokenTeamId?: string | null;
-    clientTeamId?: string | null;
-}): ResolvedTeamContext;
-//# sourceMappingURL=compliance-team.d.ts.map

package/dist/config.d.ts

@@ -1,28 +0,0 @@
-/**
- * Configuration resolution for the SDK.
- *
- * Resolution order:
- *   1. Explicit options to wrap()
- *   2. Environment variables (TENSORCOST_API_KEY, TENSORCOST_BASE_URL,
- *      TENSORCOST_TENANT_ID, TENSORCOST_PROXY_URL)
- *   3. Defaults (only for baseUrl)
- *
- * If apiKey is still missing after resolution, MissingConfigError is
- * raised. This is the *one* case the SDK does not fail open — it means
- * the SDK was never configured at all, and silently dropping every
- * observation would be worse than a loud import-time failure.
- *
- * If maxLayer is steer or route and proxyUrl is missing from both options
- * and env, TensorCostConfigError is thrown.
- */
-import type { ResolvedConfig, WrapOptions } from "./types.js";
-export declare const DEFAULT_BASE_URL = "https://api.tensorcost.com";
-export declare class MissingConfigError extends Error {
-    constructor(message: string);
-}
-/** Thrown when applied mode is enabled but required config is absent. */
-export declare class TensorCostConfigError extends Error {
-    constructor(message: string);
-}
-export declare function resolveConfig(options?: WrapOptions): ResolvedConfig;
-//# sourceMappingURL=config.d.ts.map

package/dist/decision.d.ts

@@ -1,11 +0,0 @@
-/**
- * Parse x-tc-decision response header for observation metadata.
- */
-export interface ParsedDecision {
-    layer: string;
-    action: string;
-    reason?: string;
-}
-export declare function parseDecisionHeader(header: string | null | undefined): ParsedDecision | null;
-export declare function decisionMetadata(header: string | null | undefined): Record<string, string> | undefined;
-//# sourceMappingURL=decision.d.ts.map

package/dist/dlp.d.ts

@@ -1,16 +0,0 @@
-/**
- * In-process DLP — prompt text never leaves the customer process.
- */
-import type { CompiledComplianceSnapshot } from "./layer.js";
-export type { CompiledComplianceSnapshot };
-export type DlpOutcome = "none" | "redacted" | "refused";
-export interface DlpScanResult {
-    outcome: DlpOutcome;
-    matchedDetectors: string[];
-}
-export declare function extractAnthropicMessagesText(firstArg: unknown): string;
-export declare function extractOpenAiMessagesText(args: unknown[]): string;
-export declare function redactTextForCompliance(text: string, detectors: readonly string[]): string;
-export declare function applyDlpRedactionToOpenAiArgs(args: unknown[], matchedDetectors: readonly string[]): void;
-export declare function scanTextForCompliance(text: string, snapshot: CompiledComplianceSnapshot | null | undefined): DlpScanResult;
-//# sourceMappingURL=dlp.d.ts.map

package/dist/layer.d.ts

@@ -1,54 +0,0 @@
-/**
- * Control-layer ladder — mirrors @tensorcost/contracts/control-layer for
- * the published SDK (no contracts runtime dependency).
- */
-export declare const CONTROL_LAYERS: readonly ["off", "observe", "govern", "steer", "route"];
-export type ControlLayer = (typeof CONTROL_LAYERS)[number];
-export declare function layerRank(layer: ControlLayer): number;
-export declare function minLayer(a: ControlLayer, b: ControlLayer): ControlLayer;
-export declare function isControlLayer(value: string): value is ControlLayer;
-/** steer and route require a proxy URL. */
-export declare function needsProxyUrl(layer: ControlLayer): boolean;
-/** govern runs metadata-only admit before the direct provider call. */
-export declare function needsAdmit(layer: ControlLayer): boolean;
-export declare function resolveMaxLayer(options: {
-    maxLayer?: ControlLayer;
-    appliedMode?: boolean;
-}): ControlLayer;
-export declare const PROXY_OPERATION_PATHS: Record<string, string>;
-export declare function proxyPathForOperation(operation: string): string | null;
-export declare const ADMIT_PATH = "/api/inference-proxy/v1/admit";
-export declare const SDK_LAYER_PATH = "/api/inference-proxy/v1/sdk-layer";
-/** Wire shape from GET /v1/sdk-layer — mirrors @tensorcost/contracts (no runtime dep). */
-export type ComplianceEnforcementMode = "observe" | "enforce";
-export type ComplianceFailMode = "open" | "closed";
-export type DlpAction = "redact" | "refuse";
-export interface CompiledComplianceSnapshot {
-    frameworks: string[];
-    mode: ComplianceEnforcementMode;
-    fail_mode: ComplianceFailMode;
-    allowed_providers?: string[];
-    allowed_models?: string[];
-    allowed_regions?: string[];
-    max_grants: DataGrant[];
-    dlp: {
-        enabled: boolean;
-        detectors: string[];
-        action: DlpAction;
-    };
-    audit: {
-        stamp: boolean;
-    };
-}
-export declare const SDK_LAYER_CACHE_TTL_MS = 30000;
-export declare const SDK_LAYER_DECAY_MS: number;
-/** Cap on the blocking sdk-layer GET so a hung TensorCost cannot stall the agent. */
-export declare const SDK_LAYER_FETCH_TIMEOUT_MS = 250;
-/** Govern admit must fail-open quickly; agents already wait on the model. */
-export declare const ADMIT_TIMEOUT_MS = 500;
-/** Steer proxy must send response headers quickly or fail-open to direct. */
-export declare const PROXY_HEADERS_TIMEOUT_MS = 2000;
-export declare const DATA_GRANTS: readonly ["telemetry", "retain_completions", "retain_prompts", "retain_tools"];
-export type DataGrant = (typeof DATA_GRANTS)[number];
-export declare function intersectGrants(codeMax: readonly DataGrant[] | null | undefined, consoleGrants: readonly DataGrant[]): DataGrant[];
-//# sourceMappingURL=layer.d.ts.map

package/dist/prewarm.d.ts

@@ -1,14 +0,0 @@
-/**
- * Prefetch JWT + published control layer so the first model call is not
- * blocked on cold `/sdk-token/exchange` or `/sdk-layer`.
- *
- * Call once at process/Lambda init (module scope), before traffic arrives:
- *
- *   import { prewarm } from "@tensorcost/sdk";
- *   await prewarm({ apiKey, tenantId, baseUrl });
- */
-import type { WrapOptions } from "./types.js";
-export declare function prewarm(options?: WrapOptions): Promise<void>;
-/** Best-effort drain of fire-and-forget observation POSTs before Lambda freeze. */
-export declare function flushObservations(options?: WrapOptions, timeoutMs?: number): Promise<void>;
-//# sourceMappingURL=prewarm.d.ts.map

package/dist/providers/anthropic.d.ts

@@ -1,41 +0,0 @@
-/**
- * Anthropic client wrapping.
- *
- * Intercepts `client.messages.create`. Same observation contract as the
- * OpenAI wrapper — only metadata is captured (model, input/output tokens),
- * never the message content itself.
- *
- * Applied-mode hardening (v0.4.0): messages.create routes through the
- * proxy-client module, which handles retries, timeouts, typed errors,
- * telemetry hooks, and the fail-open circuit breaker.
- */
-import type { ObservationTransport } from "../transport.js";
-import type { CircuitBreaker } from "../circuit.js";
-import type { LifecycleEventCallback } from "../telemetry.js";
-import type { RetryConfig } from "../retry.js";
-import type { ControlLayer } from "../layer.js";
-import type { SdkLayerClient } from "../sdk-layer.js";
-export interface AppliedModeHardeningOpts {
-    maxLayer: ControlLayer;
-    appliedMode: boolean;
-    proxyUrl: string | null;
-    baseUrl: string;
-    sdkLayer: SdkLayerClient;
-    retry: RetryConfig;
-    timeoutMs: number;
-    headersTimeoutMs: number;
-    onLifecycleEvent: LifecycleEventCallback | undefined;
-    failOpenEnabled: boolean;
-    circuit: CircuitBreaker;
-    application?: string | null;
-    tags?: string[];
-    customer?: string | null;
-    feature?: string | null;
-    teamId?: string | null;
-}
-export declare function install(client: unknown, transport: ObservationTransport, tenantId: string | null, environment: string | null, connectionId: string | null, hardening: AppliedModeHardeningOpts, deployment?: string | null, promptTemplateId?: string | null, agentId?: string | null, workflowId?: string | null): void;
-export declare const __test__: {
-    MARKER: string;
-    WITH_META_MARKER: string;
-};
-//# sourceMappingURL=anthropic.d.ts.map

package/dist/providers/detect.d.ts

@@ -1,19 +0,0 @@
-/**
- * Provider detection — duck-typed.
- *
- * We avoid importing `openai`, `@anthropic-ai/sdk`, or
- * `@aws-sdk/client-bedrock-runtime` at runtime so that the SDK has zero
- * peer-dep cost when the customer only uses one provider. Detection
- * inspects the shape of the client object instead.
- *
- * Bedrock detection uses the Smithy-generated `config.serviceId` field,
- * which is the most precise available discriminator — it's set by the
- * AWS SDK generator and does not depend on the constructor name (which
- * minifiers can change).
- */
-import type { Provider } from "../types.js";
-export declare class UnsupportedClientError extends Error {
-    constructor(message: string);
-}
-export declare function detectProvider(client: unknown): Provider;
-//# sourceMappingURL=detect.d.ts.map

package/dist/providers/index.d.ts

@@ -1,6 +0,0 @@
-export { detectProvider, UnsupportedClientError } from "./detect.js";
-export * as openaiProvider from "./openai.js";
-export * as anthropicProvider from "./anthropic.js";
-export * as bedrockProvider from "./bedrock.js";
-export * as vertexProvider from "./vertex.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/providers/openai.d.ts

@@ -1,46 +0,0 @@
-/**
- * OpenAI client wrapping.
- *
- * Intercepts:
- *   * `client.chat.completions.create`
- *   * `client.completions.create` (legacy text completions; v0 still ships)
- *
- * We capture only metadata (model, token usage) — never prompt content.
- * Customer prompts stay on their machine.
- *
- * Applied-mode hardening (v0.4.0): chat.completions.create routes through
- * the proxy-client module, which handles retries, timeouts, typed errors,
- * telemetry hooks, and the fail-open circuit breaker. When the circuit is
- * open or the proxy errors after retries, and `failOpenEnabled=true`, the
- * call falls back to the customer's direct provider path.
- */
-import type { ObservationTransport } from "../transport.js";
-import type { CircuitBreaker } from "../circuit.js";
-import type { LifecycleEventCallback } from "../telemetry.js";
-import type { RetryConfig } from "../retry.js";
-import type { ControlLayer } from "../layer.js";
-import type { SdkLayerClient } from "../sdk-layer.js";
-export interface AppliedModeHardeningOpts {
-    maxLayer: ControlLayer;
-    appliedMode: boolean;
-    proxyUrl: string | null;
-    baseUrl: string;
-    sdkLayer: SdkLayerClient;
-    retry: RetryConfig;
-    timeoutMs: number;
-    headersTimeoutMs: number;
-    onLifecycleEvent: LifecycleEventCallback | undefined;
-    failOpenEnabled: boolean;
-    circuit: CircuitBreaker;
-    application?: string | null;
-    tags?: string[];
-    customer?: string | null;
-    feature?: string | null;
-    teamId?: string | null;
-}
-export declare function install(client: unknown, transport: ObservationTransport, tenantId: string | null, environment: string | null, connectionId: string | null, hardening: AppliedModeHardeningOpts, deployment?: string | null, promptTemplateId?: string | null, agentId?: string | null, workflowId?: string | null): void;
-export declare const __test__: {
-    MARKER: string;
-    WITH_META_MARKER: string;
-};
-//# sourceMappingURL=openai.d.ts.map

package/dist/providers/vertex.d.ts

@@ -1,14 +0,0 @@
-/**
- * Google Vertex AI (google-genai Client, vertexai=true) — observe-only.
- *
- * Patches `client.models.generate_content` and `generate_content_stream`
- * on the unified `@google/genai` Client when constructed in Vertex mode.
- * Mirrors the Python `_vertex.py` provider and the Bedrock observe-only
- * contract: no applied mode, fail-open transport, streaming placeholders.
- */
-import type { ObservationTransport } from "../transport.js";
-export declare function install(client: unknown, transport: ObservationTransport, tenantId: string | null, environment: string | null, connectionId: string | null, deployment?: string | null, promptTemplateId?: string | null, agentId?: string | null, workflowId?: string | null, customer?: string | null, feature?: string | null): void;
-export declare const __test__: {
-    MARKER: string;
-};
-//# sourceMappingURL=vertex.d.ts.map

package/dist/proxy-client.d.ts

@@ -1,114 +0,0 @@
-/**
- * Applied-mode proxy HTTP client.
- *
- * This is the single place that combines retries, timeouts, typed errors,
- * telemetry hooks, and the fail-open circuit breaker. The provider wrappers
- * (openai.ts, anthropic.ts) call `proxyRequest()` instead of hitting the
- * proxy directly.
- *
- * The contract:
- *   - Returns the parsed response body on success.
- *   - On all non-success outcomes, throws a subclass of TensorCostError.
- *   - Never swallows errors — the provider wrapper's fail-open logic
- *     (fall back to direct call on proxy failure) lives in the provider
- *     wrapper, not here.
- *
- * Timeout handling:
- *   - `headersTimeoutMs` (default 2s): abort if the proxy never returns
- *     response headers (TCP accepted but wedged). Fail-open to direct.
- *   - `timeoutMs` (default 60s): wall-clock budget for the full response
- *     body after headers (model time through the proxy).
- *   - Streaming through steer is refused at the provider wrapper; proxy
- *     server supports SSE but the SDK client does not consume streams yet.
- *
- * Retry logic:
- *   - Retries on 5xx + network errors + 429.
- *   - Respects Retry-After on 429.
- *   - Stops at maxAttempts.
- *   - Does not retry on 4xx (except 429).
- *
- * Circuit breaker:
- *   - Maintained on the CircuitBreaker instance passed in.
- *   - When open, throws TensorCostProxyError immediately with a clear
- *     message so the provider wrapper can activate the direct-provider
- *     fallback.
- */
-import { TensorCostError } from "./errors.js";
-import type { RetryConfig } from "./retry.js";
-import type { CircuitBreaker } from "./circuit.js";
-import type { LifecycleEventCallback } from "./telemetry.js";
-import type { Provider } from "./telemetry.js";
-import { type ControlLayer } from "./layer.js";
-export interface ProxyRequestOptions {
-    proxyUrl: string;
-    bearerToken: string;
-    providerUrl: string;
-    providerAuth: string;
-    body: Record<string, unknown>;
-    model: string;
-    provider: Provider;
-    operation: string;
-    correlationId: string;
-    environment: string | null;
-    /**
-     * Per-agent-run attribution, forwarded as `x-tc-agent-id` /
-     * `x-tc-workflow-id`. These are what let the proxy scope a spend cap to
-     * a run; without the workflow id it has no run to cap. Same values the
-     * observation envelope carries as `agent_id` / `workflow_id`.
-     */
-    agentId?: string | undefined;
-    workflowId?: string | undefined;
-    /** A-04 chargeback → `x-tc-customer`. */
-    customer?: string | undefined;
-    /** A-04 chargeback → `x-tc-feature`. */
-    feature?: string | undefined;
-    /** Routing-policy application scope → `x-tc-application`. */
-    application?: string | null | undefined;
-    /** Routing-policy tags → comma-separated `x-tc-tags`. */
-    tags?: string[] | undefined;
-    /** Compliance team scope → `x-tc-team-id`. */
-    teamId?: string | undefined;
-    retry?: RetryConfig;
-    timeoutMs?: number;
-    /** Max wait for proxy response headers before fail-open. Default 2s. */
-    headersTimeoutMs?: number;
-    onLifecycleEvent?: LifecycleEventCallback;
-    circuit: CircuitBreaker;
-    maxLayer?: ControlLayer;
-    /**
-     * When true (steer fail-open), do not retry proxy *network* errors —
-     * fail immediately so the wrapper can go direct. 429/5xx still retry.
-     * Timeouts still retry: a timeout usually means the upstream model is slow.
-     */
-    failOpenFast?: boolean;
-    /** Injected fetch implementation (for testing). Defaults to globalThis.fetch. */
-    fetchImpl?: typeof fetch;
-}
-export interface ProxyRequestResult {
-    body: unknown;
-    decisionHeader: string | null;
-}
-/**
- * Execute a single proxied request with retries, timeouts, telemetry,
- * and circuit-breaker integration.
- *
- * Throws a `TensorCostError` subclass on any failure.
- * Returns the parsed JSON body on success.
- */
-export declare function proxyRequest(opts: ProxyRequestOptions): Promise<ProxyRequestResult>;
-/**
- * Should a failed proxy attempt fall back to calling the provider
- * directly?
- *
- * The applied-mode fail-open contract exists so that TensorCost being
- * down never takes the customer's inference down with it. Every transport
- * failure — timeout, network error, 5xx, open circuit — is therefore a
- * "go around us" signal and returns true.
- *
- * A policy refusal (run budget, model governance, guardrail hard_stop) is
- * when the proxy is healthy and the refusal IS the product. Falling back
- * would issue the provider call anyway and turn enforcement into a log line.
- */
-export declare function shouldFallBackToProvider(err: unknown): boolean;
-export { TensorCostError };
-//# sourceMappingURL=proxy-client.d.ts.map