@caeliq/llms 1.0.59 → 1.0.60

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/tests/anthropic.client-policy.d.ts

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

package/dist/tests/reasoning.effort-levels.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/types/llm.d.ts

@@ -84,7 +84,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;

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/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/openai.responses.util.d.ts

@@ -11,11 +11,15 @@ export declare function mapCallId(map: ResponsesCallIdMap, id: unknown, directio
  * Client Responses wire → Unified (Chat Completions shape).
  * Supports the Responses MVP subset; rejects CCR-unsupported stateful fields.
  */
-export declare function responsesRequestToUnified(body: any, callIdMap?: ResponsesCallIdMap): UnifiedChatRequest;
+export declare function responsesRequestToUnified(body: any, callIdMap?: ResponsesCallIdMap, customToolNames?: Set<string>): UnifiedChatRequest;
+/** Synthetic argument key used to carry a `custom` tool's freeform text
+ * through the Unified/Chat Completions function-call shape. */
+export declare const CUSTOM_TOOL_INPUT_KEY = "input";
 /** Unified Chat JSON → Responses API non-stream response. */
 export declare function unifiedResponseToResponses(chat: any, options?: {
     originalModel?: string;
     callIdMap?: ResponsesCallIdMap;
+    customToolNames?: Set<string>;
 }): any;
 export interface ResponsesStreamState {
     responseId: string;
@@ -31,6 +35,7 @@ export interface ResponsesStreamState {
         added: boolean;
         outputIndex: number;
         emittedArgumentsLength: number;
+        isCustom: boolean;
     }>;
     nextOutputIndex: number;
     finished: boolean;
@@ -39,10 +44,12 @@ export interface ResponsesStreamState {
     finishReasonSeen: boolean;
     usage?: any;
     callIdMap: ResponsesCallIdMap;
+    customToolNames: Set<string>;
 }
 export declare function createResponsesStreamState(options?: {
     model?: string;
     callIdMap?: ResponsesCallIdMap;
+    customToolNames?: Set<string>;
 }): ResponsesStreamState;
 /**
  * Convert one Unified Chat Completions chunk into zero or more Responses

package/dist/utils/reasoning-effort.d.ts

@@ -0,0 +1,13 @@
+import type { ThinkLevel, UnifiedChatRequest } from "../types/llm";
+type UnifiedReasoning = UnifiedChatRequest["reasoning"];
+/** Normalize effort tokens at the protocol boundary without rejecting extensions. */
+export declare function normalizeReasoningEffort(value: unknown): ThinkLevel | undefined;
+/** `none` and an explicit enabled:false are the canonical off signals. */
+export declare function isReasoningDisabled(reasoning: UnifiedReasoning | undefined, thinking?: UnifiedChatRequest["thinking"]): boolean;
+/** Build the canonical reasoning state used by every inbound protocol. */
+export declare function canonicalReasoning(effortValue: unknown, enabledWhenEffortAbsent?: boolean): UnifiedReasoning | undefined;
+/** Serialize Unified reasoning onto the Chat Completions wire shape in place. */
+export declare function applyOpenAIChatReasoning(request: UnifiedChatRequest): UnifiedChatRequest;
+/** Anthropic accepts low..max, while CCR/OpenAI may additionally emit minimal/ultra/none. */
+export declare function toAnthropicReasoningEffort(effortValue: unknown): Exclude<ThinkLevel, "none" | "minimal" | "ultra"> | undefined;
+export {};

package/dist/utils/redact.d.ts

@@ -24,6 +24,7 @@ export declare function sanitizeBodyForLog(value: string, maxBytes?: number): st
 export declare function sanitizeErrorForLog(error: unknown): {
     message: string;
     code?: string;
+    type?: string;
     name?: string;
     statusCode?: number;
     stack?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caeliq/llms",
-  "version": "1.0.59",
+  "version": "1.0.60",
   "description": "A universal LLM API transformation server",
   "main": "dist/cjs/server.cjs",
   "module": "dist/esm/server.mjs",
@@ -30,7 +30,7 @@
   ],
   "dependencies": {
     "@anthropic-ai/sdk": "^0.115.0",
-    "@caeliq/ccr-shared": "^2.1.1",
+    "@caeliq/ccr-shared": "^2.1.2",
     "@cursor/sdk": "^1.0.26",
     "@fastify/cors": "^11.3.0",
     "@fastify/rate-limit": "^10.3.0",