@caeliq/llms 1.0.59 → 1.0.61

package/dist/routing/inbound-pipeline.d.ts

@@ -7,14 +7,12 @@ export interface PreparedInboundRequest {
     protocolContext: ClientProtocolContext;
     /** Original client wire body (preserved for Anthropic custom routers). */
     originalBody: any;
-    /**
-     * Client wire body after protocol adaptation and CCR-only cleanup
-     * (subagent tag stripped, REWRITE_SYSTEM_PROMPT applied). This — not
-     * originalBody — is what an exact-wire passthrough must send upstream.
-     */
+    /** Client wire body after protocol adaptation and CCR-only cleanup. */
     clientWireBody: any;
     /** Normalized Unified body used for routing and provider conversion. */
     unifiedBody: UnifiedChatRequest;
+    /** Unified projection before destination-specific Anthropic emulation. */
+    prePolicyUnifiedBody: UnifiedChatRequest;
     providerName: string;
     modelName: string;
 }
@@ -27,5 +25,10 @@ export declare function resolveDestination(model: string | undefined, protocol?:
     providerName: string;
     modelName: string;
 };
+/**
+ * Decode a discovery alias before scenario routing. Aliases are constrained to
+ * configured canonical routes; ordinary `provider,model` ids are unchanged.
+ */
+export declare function resolveConfiguredClaudeModelAlias(model: string | undefined, isConfigured: (canonicalId: string) => boolean, protocol?: ClientProtocolContext["protocol"]): string | undefined;
 export declare function throwProtocolError(protocol: ClientProtocolContext["protocol"] | undefined, message: string, statusCode: number, code: string, type?: string): never;
 export declare function protocolAwareBypass(provider: any, transformer: Transformer, protocolContext: ClientProtocolContext | undefined, modelName: string | undefined): boolean;

package/dist/routing/protocol-adapter.d.ts

@@ -24,10 +24,9 @@ export declare function normalizeClientToUnified(protocol: ClientProtocolContext
  */
 export declare function cloneProtocolBody<T>(value: T): T;
 /**
- * Preserve only known protocol/version and SDK metadata headers for exact-wire
- * passthrough. An allowlist prevents an arbitrary client header from becoming
- * an upstream credential or tenant-routing secret. Provider authentication is
- * generated independently.
+ * Preserve all end-to-end application headers for a native client. Only
+ * credentials, cookies, CCR/proxy routing metadata and hop-by-hop transport
+ * headers are removed; provider authentication is generated independently.
  */
 export declare function sanitizePassthroughHeaders(headers: Headers | Record<string, unknown> | undefined): Record<string, string>;
 /**

package/dist/routing/protocol-endpoints.d.ts

@@ -1,4 +1,5 @@
 import type { RouterScenarioType } from "../utils/router";
+import type { AnthropicClientKind, AnthropicProviderMode } from "../utils/anthropic-client-policy";
 /**
  * Inbound client protocols supported by CCR's gateway lifecycle.
  */
@@ -17,12 +18,23 @@ export interface ClientProtocolContext {
     /** Alias path that matched, if different from canonical */
     matchedPath: string;
     originalModel?: string;
+    /** Client selected the gateway's trailing `[1m]` context variant. */
+    requestedOneMillion?: boolean;
     stream: boolean;
     scenarioType?: RouterScenarioType;
     /** Source-only Anthropic semantics retained before destination routing. */
     anthropicSource?: AnthropicSourceRequestFields;
-    /** Keep explicit source cache directives or add provider-native automatic caching. */
-    anthropicCacheMode?: "preserve" | "automatic";
+    /** Client fingerprint captured before Anthropic normalization. */
+    anthropicClientKind?: AnthropicClientKind;
+    /** In-scope Anthropic destination/auth variant selected after routing. */
+    anthropicProviderMode?: AnthropicProviderMode;
+    anthropicDestinationInScope?: boolean;
+    /** Native Desktop/CLI requests must bypass body and response conversion. */
+    anthropicNativeWire?: boolean;
+    /** Third-party emulation has already modified the Unified projection. */
+    anthropicPolicyApplied?: boolean;
+    anthropicSystemTransformed?: boolean;
+    claudeAuthToolNameMap?: Map<string, string>;
     /** Claude Code routing metadata extracted without mutating the source billing block. */
     claudeCodeSubagent?: boolean;
     taggedSubagentModel?: string;

package/dist/server.d.ts

@@ -60,3 +60,5 @@ export { sanitizeHeadersForLog, diffHeadersForLog, sanitizeBodyForLog, DEFAULT_L
 export { exchangeAuthorizationCode, fetchUserEmail, resolveProjectId, saveTokens, loadTokens, getValidAccessToken, ANTIGRAVITY_CLIENT_ID, ANTIGRAVITY_CLIENT_SECRET, ANTIGRAVITY_REDIRECT_URI, ANTIGRAVITY_SCOPES, type AntigravityTokens, } from "./utils/antigravity-auth";
 export { matchClientProtocol, isRoutedLlmPost, listClientRouteRegistrations, type ClientProtocol, type ClientProtocolContext, type ProtocolRouteMatch, } from "./routing/protocol-endpoints";
 export { protocolErrorBody } from "./routing/protocol-errors";
+export { setHealthReporter } from "./utils/health-reporter";
+export type { HealthReporter } from "./utils/health-reporter";

package/dist/tests/anthropic.client-policy.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/assistant-turn-order.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cache-prefix-debug.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cross-protocol.cache-prefix.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cross-protocol.config-matrix.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/cross-protocol.responses-grok.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/mistral.thinking-history.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/reasoning.effort-levels.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/responses.reasoning-duplication.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/sse-debug-tap.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/sse.client-keepalive.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/xai-auth.reliability.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transformer/claude-auth.transformer.d.ts

@@ -1,5 +1,6 @@
 import { UnifiedChatRequest } from "../types/llm";
 import { Transformer, TransformerContext } from "../types/transformer";
+import { HeaderRecord } from "../utils/headers";
 import { ClaudeModelCatalogEntry } from "../utils/claude-model-catalog";
 /** Anthropic beta required for Claude subscription / Claude Code OAuth Bearer auth. */
 export declare const CLAUDE_OAUTH_REQUIRED_BETA = "oauth-2025-04-20";
@@ -20,13 +21,26 @@ export declare function resolveClaudeAuthAnthropicBeta(input: {
 }): string;
 /**
  * Build outbound anthropic-beta for the non-Claude-Code (full synthesis)
- * branch, mirroring Claude Code's own model-driven beta selection. Never
- * derived from model-name prefix matching — always from the capability
- * catalog. `ANTHROPIC_BETA_FLAGS` replaces the list wholesale.
+ * branch, mirroring Claude Code's current model-driven beta selection. Model
+ * capabilities come from the catalog; the CLI's one family-level exception
+ * (the ordinary Haiku profile omits the Claude Code beta) is retained from the
+ * decompiled `cui()` branch. Current CLI `ANTHROPIC_BETAS` values are appended
+ * to the profile; OAuth callers still add their required OAuth beta at the auth
+ * boundary.
  */
 export declare function resolveClaudeAuthBetas(modelId: string | undefined, opts?: {
     envBeta?: string;
+    includeOAuthBeta?: boolean;
+    includeToolSearch?: boolean;
+    includeEffort?: boolean;
+    includeFallbackCredit?: boolean;
 }): string;
+/**
+ * Recreate the SDK's context marker only for models whose 1M window is a beta.
+ * Native-1M models still accept the gateway picker suffix, but must not receive
+ * the legacy context beta upstream.
+ */
+export declare function modelIdForRequestedOneMillionBeta(modelId: string | undefined, requestedOneMillion: boolean | undefined): string | undefined;
 /**
  * Reshape a built Anthropic body's `thinking`/`output_config`/`max_tokens`
  * to what the resolved model actually supports, replacing a hand-rolled
@@ -37,10 +51,19 @@ export declare function resolveClaudeAuthBetas(modelId: string | undefined, opts
 export declare function applyClaudeModelCapabilityAdjustments(anthropicBody: Record<string, any>, entry: ClaudeModelCatalogEntry | undefined): void;
 /** Test-only reset hook so session-id state doesn't leak across test cases. */
 export declare function __resetClaudeAuthTransformerStateForTests(): void;
+/** Synthesized Claude Code identity headers for the non-Claude-Code branch. */
+export declare function buildSynthesizedIdentityHeaders(): HeaderRecord;
+export declare function buildSynthesizedUserMetadata(): Record<string, string>;
 export declare class ClaudeAuthTransformer implements Transformer {
     name: string;
     logger?: any;
     transformRequestIn(request: UnifiedChatRequest, provider: any, context?: TransformerContext): Promise<Record<string, any>>;
+    /**
+     * Auth-only path used by native Desktop/CLI raw-wire requests. It keeps the
+     * original body and application headers untouched while still replacing the
+     * caller credential with CCR's OAuth token.
+     */
+    auth(request: any, provider: any, context?: TransformerContext): Promise<any>;
     /**
      * Body/URL/wire-format conversion belong to AnthropicTransformer's
      * provider pair, which already ran (response-side order is reversed, so

package/dist/transformer/index.d.ts

@@ -29,6 +29,7 @@ import { OpencodeHeadersTransformer } from "./opencode-headers.transformer";
 import { ClaudeAuthTransformer } from "./claude-auth.transformer";
 import { CursorSdkTransformer } from "./cursor-sdk.transformer";
 import { AntigravityAuthTransformer } from "./antigravity-auth.transformer";
+import { XaiAuthTransformer } from "./xai-auth.transformer";
 declare const _default: {
     AnthropicTransformer: typeof AnthropicTransformer;
     GeminiTransformer: typeof GeminiTransformer;
@@ -61,5 +62,6 @@ declare const _default: {
     ClaudeAuthTransformer: typeof ClaudeAuthTransformer;
     CursorSdkTransformer: typeof CursorSdkTransformer;
     AntigravityAuthTransformer: typeof AntigravityAuthTransformer;
+    XaiAuthTransformer: typeof XaiAuthTransformer;
 };
 export default _default;

package/dist/transformer/openai.responses.transformer.d.ts

@@ -23,6 +23,7 @@ export declare class OpenAIResponsesTransformer implements Transformer {
      * allocated per Responses item by `toolIndexFor`.
      */
     private convertStreamEvent;
+    private convertStreamEventCore;
     private normalizeRequestContent;
     private convertResponseToChat;
     private buildImageContent;

package/dist/transformer/xai-auth.transformer.d.ts

@@ -0,0 +1,24 @@
+import { Transformer } from "../types/transformer";
+export declare class XaiAuthTransformer implements Transformer {
+    name: string;
+    logger?: any;
+    private resolveAuth;
+    /**
+     * openai-responses only converts the body — it doesn't own the outbound
+     * URL (its endPoint is a client-facing inbound route registration, not an
+     * outbound path). The generic pipeline falls back to a bare
+     * `provider.baseUrl` when no transformer sets config.url (routes.ts:739),
+     * so this transformer must build the actual `/responses` URL itself,
+     * mirroring CodexTransformer's `${baseUrl}/responses`.
+     */
+    private buildConfig;
+    transformRequestIn(request: any, provider: any): Promise<Record<string, any>>;
+    auth(_request: any, provider: any): Promise<any>;
+    /**
+     * 401 recovery. PAT mode has nothing to recover — a bad literal key or
+     * env value can't be fixed by CCR. OAuth mode reloads the token file
+     * (another process may have already refreshed it), otherwise refreshes
+     * and persists, mirroring ClaudeAuthTransformer.recoverUnauthorizedAuth.
+     */
+    private recoverUnauthorizedAuth;
+}

package/dist/types/llm.d.ts

@@ -63,7 +63,12 @@ export interface UnifiedMessage {
     };
     thinking?: {
         content: string;
+        /** Anthropic thinking signature; never treat as Responses ciphertext. */
         signature?: string;
+        /** Provider-minted Responses/Codex reasoning ciphertext for replay. */
+        encrypted_content?: string;
+        /** Responses reasoning item id (`rs_…`); not interchangeable with ciphertext. */
+        id?: string;
     };
 }
 export interface UnifiedTool {
@@ -84,7 +89,8 @@ export interface UnifiedTool {
         ttl?: "5m" | "1h";
     };
 }
-export type ThinkLevel = "none" | "low" | "medium" | "high" | "xhigh" | "max";
+export declare const THINK_LEVELS: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+export type ThinkLevel = (typeof THINK_LEVELS)[number];
 export interface UnifiedChatRequest {
     messages: UnifiedMessage[];
     model: string;
@@ -160,6 +166,8 @@ export interface StreamChunk {
             thinking?: {
                 content?: string;
                 signature?: string;
+                encrypted_content?: string;
+                id?: string;
             };
             tool_calls?: Array<{
                 id?: string;

package/dist/utils/anthropic-client-policy.d.ts

@@ -0,0 +1,45 @@
+import { UnifiedChatRequest } from "../types/llm";
+export type AnthropicClientKind = "claude_desktop" | "claude_code" | "other";
+export type AnthropicProviderMode = "api_key" | "claude_oauth" | "out_of_scope";
+export interface AnthropicClientFingerprintSignals {
+    desktopMarker: boolean;
+    desktopUserAgent: boolean;
+    desktopAgentSdkUserAgent: boolean;
+    cliUserAgent: boolean;
+    cliApp: boolean;
+    cliSession: boolean;
+    stainlessPackage: boolean;
+    billingSystem: boolean;
+    identitySystem: boolean;
+}
+export interface AnthropicClientPolicyContext {
+    anthropicClientKind?: AnthropicClientKind;
+    anthropicProviderMode?: AnthropicProviderMode;
+    anthropicDestinationInScope?: boolean;
+    anthropicNativeWire?: boolean;
+    anthropicPolicyApplied?: boolean;
+    anthropicSystemTransformed?: boolean;
+    claudeAuthToolNameMap?: Map<string, string>;
+}
+export declare function readHeaderValue(headers: Record<string, unknown> | undefined, name: string): string | undefined;
+/**
+ * Classify the original Anthropic wire request. A generic SDK UA is never
+ * enough to grant native pass-through; incomplete fingerprints fail closed to
+ * the third-party emulation path.
+ */
+export declare function classifyAnthropicClient(headers: Record<string, unknown> | undefined, body: any): AnthropicClientKind;
+/** Return only non-sensitive boolean fingerprint signals for debug logging. */
+export declare function inspectAnthropicClientFingerprint(headers: Record<string, unknown> | undefined, body: any): AnthropicClientFingerprintSignals;
+/**
+ * The feature is intentionally scoped to CCR's real Anthropic provider, with
+ * either the exact Anthropic API-key chain or the exact claude-auth + Anthropic
+ * OAuth chain. Adjacent middleware makes a provider out of scope.
+ */
+export declare function getAnthropicProviderMode(provider: any, endpointTransformerName?: string): AnthropicProviderMode;
+export declare function isNativeAnthropicClient(kind: AnthropicClientKind): boolean;
+/**
+ * Apply the one and only system transformation allowed by the gateway policy.
+ * This runs after routing has identified an in-scope Anthropic destination and
+ * before the provider's Anthropic body builder runs.
+ */
+export declare function applyThirdPartyAnthropicPolicy(request: UnifiedChatRequest, context: AnthropicClientPolicyContext, configService: any): Promise<void>;

package/dist/utils/anthropic-url.d.ts

@@ -0,0 +1 @@
+export declare function buildAnthropicMessagesUrl(baseUrl: string | undefined): string;

package/dist/utils/cache-prefix-debug.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Pipeline position a snapshot was taken at. `client` is the Unified/exact-wire
+ * body handed to the provider chain; `wire` is what actually left for upstream.
+ * Comparing the two attributes a broken prefix to the client or to our own
+ * transformer chain without a bisect.
+ */
+export type CachePrefixStage = "client" | "wire";
+export type CacheAffinityHeaders = {
+    sessionId?: string;
+    threadId?: string;
+    clientRequestId?: string;
+};
+export type CachePrefixSegment = {
+    path: string;
+    role?: string;
+    type?: string;
+    hash: string;
+    /** Rough token weight (JSON chars / 4) — enough to rank misses by cost. */
+    approxTokens: number;
+    breakpoints: number;
+    reasoningId?: string;
+};
+export type CachePrefixSnapshot = {
+    createdAt: number;
+    model?: string;
+    prompt_cache_key?: string;
+    session_id?: string;
+    affinity?: CacheAffinityHeaders;
+    lastAssistantBlockOrder?: string[];
+    breakpointPaths: string[];
+    systemHash?: string;
+    toolsHash?: string;
+    approxTokens: number;
+    unstableIds: string[];
+    segments: CachePrefixSegment[];
+};
+export type CachePrefixChange = "none" | "appended" | "modified" | "removed";
+export type CachePrefixIdSource = "session" | "cache_key" | "fingerprint";
+export type CachePrefixDiff = {
+    conversationId: string;
+    conversationIdSource: CachePrefixIdSource;
+    stage: CachePrefixStage;
+    firstTurn: boolean;
+    prefixIntact: boolean;
+    change: CachePrefixChange;
+    unchangedPrefixCount: number;
+    previousSegmentCount: number;
+    currentSegmentCount: number;
+    /** Approximate tokens of prefix that stayed byte-identical. */
+    unchangedPrefixApproxTokens: number;
+    /** Approximate tokens the provider must re-read because the prefix moved. */
+    approxPrefixTokensLost: number;
+    /** Gap since the previous turn — separates a real break from TTL expiry. */
+    msSinceLastTurn?: number;
+    prompt_cache_keyChanged: boolean;
+    affinityChanged: boolean;
+    lastAssistantBlockOrderChanged: boolean;
+    modelChanged: boolean;
+    systemHashChanged: boolean;
+    toolsHashChanged: boolean;
+    breakpointsMoved: boolean;
+    /** Ids carrying an embedded timestamp — they rewrite the prefix every turn. */
+    unstableIds?: string[];
+    firstDivergencePath?: string;
+    firstDivergence?: {
+        previous?: DivergenceSide;
+        current?: DivergenceSide;
+    };
+    appendedPaths?: string[];
+    removedPaths?: string[];
+    prompt_cache_key?: {
+        previous?: string;
+        current?: string;
+    };
+    affinity?: {
+        previous?: CacheAffinityHeaders;
+        current?: CacheAffinityHeaders;
+    };
+    lastAssistantBlockOrder?: {
+        previous?: string[];
+        current?: string[];
+    };
+};
+export type CachePrefixDiffOptions = {
+    stage?: CachePrefixStage;
+    provider?: string;
+    model?: string;
+    /**
+     * Persist this snapshot as the baseline for the next turn. Pass false when
+     * upstream rejected the request — a body that was never cached must not
+     * become the baseline the following turn is judged against.
+     */
+    commit?: boolean;
+};
+export declare function __resetCachePrefixSnapshotsForTests(): void;
+/**
+ * Compact, content-free snapshot of the outbound fields prompt caching uses.
+ */
+export declare function snapshotOutboundCachePrefix(body: Record<string, any> | null | undefined, affinity?: CacheAffinityHeaders): CachePrefixSnapshot | null;
+type DivergenceSide = Pick<CachePrefixSegment, "path" | "role" | "type" | "approxTokens" | "breakpoints" | "reasoningId">;
+export declare function diffCachePrefixSnapshots(conversationId: string, previous: CachePrefixSnapshot | undefined, current: CachePrefixSnapshot, meta?: {
+    stage?: CachePrefixStage;
+    conversationIdSource?: CachePrefixIdSource;
+}): CachePrefixDiff;
+/**
+ * Compare this outbound body to the last one for the conversation, then
+ * remember the current snapshot. Returns null when there is nothing cacheable.
+ *
+ * Snapshots are keyed per stage and per provider/model: a routed fallback to a
+ * different destination is a legitimate cache miss, not prefix corruption, and
+ * must not be reported as one.
+ */
+export declare function rememberAndDiffOutboundCachePrefix(conversationId: string | undefined, body: Record<string, any> | null | undefined, affinity?: CacheAffinityHeaders, options?: CachePrefixDiffOptions): CachePrefixDiff | null;
+/**
+ * Attribute a broken wire prefix to the stage that broke it. The client leg is
+ * checked first: if Claude Code itself rewrote history there is nothing our
+ * transformer chain could have preserved.
+ */
+export declare function attributeDivergenceStage(clientDiff: CachePrefixDiff | null | undefined, wireDiff: CachePrefixDiff | null | undefined): CachePrefixStage | "none" | undefined;
+export {};

package/dist/utils/claude-billing.d.ts

@@ -3,10 +3,15 @@ import { TextContent, UnifiedChatRequest, UnifiedMessage } from "../types/llm";
 export declare const BILLING_SALT = "59cf53e54c78";
 export declare const CC_VERSION: string;
 export declare const CC_ENTRYPOINT: string;
+export declare const CC_USER_AGENT_ENTRYPOINT: string;
 export declare const SYSTEM_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
 export declare function extractFirstUserMessageText(messages: UnifiedMessage[] | undefined): string;
 export declare function computeVersionSuffix(text: string, version: string): string;
-/** 5 lowercase hex chars, cached per process — not a content hash. */
+/**
+ * Current first-party Anthropic requests use the literal cch marker. Older
+ * captures showed a random session value; the current 2.1.226 decompilation
+ * gates this field to first-party/Vertex and emits `00000`.
+ */
 export declare function sessionCch(): string;
 export declare function __resetClaudeBillingStateForTests(): void;
 export declare function buildClaudeBillingHeaderValue(messages: UnifiedMessage[] | undefined, version?: string, entrypoint?: string): string;
@@ -21,14 +26,15 @@ export declare function normalizeSystemToArray(request: UnifiedChatRequest): Tex
 /** Drop any existing billing entry (dedupe) and prepend a fresh one at system[0]. */
 export declare function applyClaudeBillingSystemBlock(system: TextContent[], messages: UnifiedMessage[] | undefined): void;
 /**
- * Insert SYSTEM_IDENTITY as its own entry at system[1]. Any remaining
- * caller system content is left in place here — relocateForeignSystemContent
- * (called separately, afterwards) is what moves it out of system[].
+ * Insert SYSTEM_IDENTITY after the billing block (normally system[1], or
+ * system[0] when attribution is disabled). Any remaining caller system
+ * content is left in place here — relocateForeignSystemContent (called
+ * separately, afterwards) is what moves it out of system[].
  */
 export declare function applyClaudeSystemIdentity(system: TextContent[]): void;
 /**
- * Move everything in `system[]` past the identity block (index 1) into the
- * first user message instead. Anthropic's OAuth billing validator appears to
+ * Move everything in `system[]` past the identity block into the first user
+ * message instead. Anthropic's OAuth billing validator appears to
  * inspect `system[]` content beyond the identity prefix and reject requests
  * whose system array carries a foreign harness prompt with an "out of extra
  * usage" 400 — the same approach used by third-party Claude Code OAuth

package/dist/utils/claude-model-catalog.d.ts

@@ -1,5 +1,6 @@
 /**
- * Claude Code's bundled model capability catalog (extracted from v2.1.220).
+ * Claude Code's bundled model capability catalog, revalidated against the
+ * installed v2.1.226 CLI decompilation.
  *
  * Every model-dependent decision in the claude-auth impersonation path (beta
  * flags, effort support, thinking shape, max_tokens ceiling) is driven by

package/dist/utils/gemini-thinking.d.ts

@@ -51,7 +51,8 @@ export declare function resolveThinkingDialect(model: string): ThinkingDialect;
  *
  * Rounds *up* when the exact level is missing so a request never silently loses
  * reasoning depth: `medium` on Gemini 3 Pro (low|high) becomes `high`, and
- * Claude's `xhigh`/`max` — which are not Gemini enum values — become `high`.
+ * Claude/CCR's `xhigh`/`max`/`ultra` — which are not Gemini enum values —
+ * become `high`.
  */
 export declare function translateThinkingLevel(effort: string, levels: GeminiThinkingLevel[]): GeminiThinkingLevel;
 /**

package/dist/utils/health-reporter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Optional process vitals for the `/health` probe.
+ *
+ * The API routes are registered inside encapsulated Fastify plugins, which
+ * snapshot the instance they inherit from at registration time — a decorator
+ * added to the root afterwards is invisible to them. Whoever owns the process
+ * (the server package, which builds its health heartbeat after the routes are
+ * up) therefore publishes the reporter here instead.
+ */
+export type HealthReporter = () => unknown;
+export declare function setHealthReporter(fn: HealthReporter | undefined): void;
+/** Vitals for the current instant, or `undefined` when none are published. */
+export declare function readHealthVitals(): unknown;