@caeliq/llms 1.0.70 → 1.0.72

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

@@ -10,6 +10,33 @@ export interface AnthropicSourceRequestFields {
     thinking?: Record<string, unknown>;
     outputConfig?: Record<string, unknown>;
     stopSequences?: string[];
+    /**
+     * Anthropic-defined (typed) tools such as `web_search_20250305` or
+     * `bash_20250124`, exactly as the client sent them. Unified `tools[]` keeps
+     * their function projection (by name) for routing and other providers.
+     */
+    tools?: Record<string, any>[];
+    /**
+     * Server tool blocks (`server_tool_use`, `web_search_tool_result`) of each
+     * assistant turn, indexed by assistant-turn ordinal, with that turn's
+     * joined text so the builder only re-attaches them to the same turn.
+     */
+    assistantServerBlocks?: Array<{
+        text: string;
+        blocks: any[];
+    } | undefined>;
+}
+/** Client asked for provider-hosted web search (any inbound protocol). */
+export interface HostedWebSearchRequest {
+    allowedDomains?: string[];
+    /** Per-request search cap from `WEB_SEARCH_MAX_USES` (none by default). */
+    maxUses?: number;
+    userLocation?: {
+        city?: string;
+        region?: string;
+        country?: string;
+        timezone?: string;
+    };
 }
 export interface ClientProtocolContext {
     protocol: ClientProtocol;
@@ -25,6 +52,12 @@ export interface ClientProtocolContext {
     scenarioType?: RouterScenarioType;
     /** Source-only Anthropic semantics retained before destination routing. */
     anthropicSource?: AnthropicSourceRequestFields;
+    /**
+     * Hosted web search requested by an Anthropic `web_search_*` tool, a
+     * Responses `web_search` tool or Chat `web_search_options`; Unified carries
+     * the `web_search` function projection.
+     */
+    hostedWebSearch?: HostedWebSearchRequest;
     /** Client fingerprint captured before Anthropic normalization. */
     anthropicClientKind?: AnthropicClientKind;
     /** In-scope Anthropic destination/auth variant selected after routing. */

package/dist/tests/anthropic.third-party-tool-names.d.ts

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

package/dist/tests/web-search.cross-protocol.d.ts

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

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

@@ -5,6 +5,14 @@ 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";
 export declare function mergeAnthropicBetaValues(...values: Array<string | undefined | null>): string;
+/**
+ * Beta tokens a third-party client sent for its Anthropic-defined computer use
+ * tool (e.g. `computer-use-2025-11-24` for `computer_20251124`). The emulated
+ * profile otherwise ignores client betas; the client already chose the one
+ * matching its tool version, so only that family is carried over, and only
+ * when the request actually declares a `computer_*` tool.
+ */
+export declare function clientComputerUseBetas(clientBeta: string | undefined, typedTools: Array<Record<string, any>> | undefined): string | undefined;
 /** Read a named header value from a Fastify/Node headers object (case-insensitive). */
 export declare function readHeaderValue(headers: Record<string, unknown> | undefined, name: string): string | undefined;
 /** True when the client's User-Agent identifies it as the genuine Claude Code CLI. */
@@ -67,8 +75,9 @@ export declare class ClaudeAuthTransformer implements Transformer {
     /**
      * Body/URL/wire-format conversion belong to AnthropicTransformer's
      * provider pair, which already ran (response-side order is reversed, so
-     * it runs before this stage). This stage only inspects the resulting
-     * response for subscription-specific overage observability.
+     * it runs before this stage). This stage inspects the resulting response
+     * for subscription-specific overage observability and restores tool names
+     * its own legacy branch renamed.
      */
     transformResponseOut(response: Response, context?: TransformerContext): Promise<Response>;
     /**

package/dist/types/llm.d.ts

@@ -18,6 +18,16 @@ export interface Annotation {
     type: "url_citation";
     url_citation?: UrlCitation;
 }
+/**
+ * A provider-executed web search (e.g. Anthropic's server `web_search`),
+ * surfaced so clients can render the call itself (Responses `web_search_call`).
+ * Internal: Chat Completions clients never receive it.
+ */
+export interface WebSearchCall {
+    id: string;
+    query: string;
+    status: "completed" | "failed";
+}
 export interface TextContent {
     type: "text";
     text: string;
@@ -137,6 +147,12 @@ export interface UnifiedChatRequest {
     anthropic_output_config?: Record<string, any>;
     anthropic_metadata?: Record<string, any>;
     anthropic_stop_sequences?: string[];
+    /**
+     * Anthropic-defined (typed) tools for legacy direct claude-auth callers,
+     * like the other anthropic_* fields. Routed requests carry them in
+     * `protocolContext.anthropicSource.tools` so no other provider sees them.
+     */
+    anthropic_tools?: Record<string, any>[];
     reasoning_effort?: string;
     /**
      * Responses opaque `include` list (e.g. `reasoning.encrypted_content`).
@@ -168,6 +184,7 @@ export interface UnifiedChatResponse {
         };
     }>;
     annotations?: Annotation[];
+    web_search_calls?: WebSearchCall[];
 }
 export interface StreamChunk {
     id: string;
@@ -195,6 +212,7 @@ export interface StreamChunk {
                 thought_signature?: string;
             }>;
             annotations?: Annotation[];
+            web_search_calls?: WebSearchCall[];
         };
         finish_reason?: string | null;
     }>;

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

@@ -1,4 +1,5 @@
 import { UnifiedChatRequest } from "../types/llm";
+import type { AnthropicSourceRequestFields, HostedWebSearchRequest } from "../routing/protocol-endpoints";
 export type AnthropicClientKind = "claude_desktop" | "claude_code" | "other";
 export type AnthropicProviderMode = "api_key" | "claude_oauth" | "out_of_scope";
 export interface AnthropicClientFingerprintSignals {
@@ -20,6 +21,8 @@ export interface AnthropicClientPolicyContext {
     anthropicPolicyApplied?: boolean;
     anthropicSystemTransformed?: boolean;
     claudeAuthToolNameMap?: Map<string, string>;
+    anthropicSource?: AnthropicSourceRequestFields;
+    hostedWebSearch?: HostedWebSearchRequest;
 }
 export declare function readHeaderValue(headers: Record<string, unknown> | undefined, name: string): string | undefined;
 /**
@@ -37,9 +40,26 @@ export declare function inspectAnthropicClientFingerprint(headers: Record<string
  */
 export declare function getAnthropicProviderMode(provider: any, endpointTransformerName?: string): AnthropicProviderMode;
 export declare function isNativeAnthropicClient(kind: AnthropicClientKind): boolean;
+/** `CLAUDE_AUTH_NATIVE_CACHE_TTL` values: `1h` (default) or `client`. */
+export type NativeClaudeOAuthCacheTtlMode = "1h" | "client";
+export declare function resolveNativeClaudeOAuthCacheTtlMode(value: unknown): NativeClaudeOAuthCacheTtlMode;
+/**
+ * Native Desktop/CLI on claude-auth OAuth: extend the client's default-TTL
+ * (5m) ephemeral breakpoints to 1h, the TTL the third-party profile already
+ * uses on this route. Breakpoint placement is untouched. A body that already
+ * sets a TTL on any breakpoint is left exactly as sent (an explicit client
+ * choice), as is every body when the mode is `client`. Returns whether the
+ * body changed.
+ */
+export declare function applyNativeClaudeOAuthCacheTtl(body: any, context: AnthropicClientPolicyContext | undefined, mode?: NativeClaudeOAuthCacheTtlMode): 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>;
+/**
+ * Names of Anthropic-defined tools in this request: typed tools sent by an
+ * Anthropic client, and hosted web search requested over another protocol.
+ */
+export declare function anthropicFixedToolNames(context: AnthropicClientPolicyContext): string[];

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

@@ -5,10 +5,14 @@
  * transformer chain without a bisect.
  */
 export type CachePrefixStage = "client" | "wire";
+/**
+ * Routing headers that pin prompt-cache affinity. `x-client-request-id` is
+ * deliberately absent: claude-auth mints a fresh one per request (as Claude
+ * Code does), and Codex sets it equal to `thread-id`, which is tracked here.
+ */
 export type CacheAffinityHeaders = {
     sessionId?: string;
     threadId?: string;
-    clientRequestId?: string;
 };
 export type CachePrefixSegment = {
     path: string;

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

@@ -25,6 +25,15 @@ export declare function buildClaudeBillingHeaderValue(messages: UnifiedMessage[]
 export declare function normalizeSystemToArray(request: UnifiedChatRequest): TextContent[];
 /** Drop any existing billing entry (dedupe) and prepend a fresh one at system[0]. */
 export declare function applyClaudeBillingSystemBlock(system: TextContent[], messages: UnifiedMessage[] | undefined): void;
+/**
+ * Drop any existing billing entry (dedupe) and reserve system[0] for a fresh
+ * one, so applyClaudeSystemIdentity places identity right after it. The value
+ * samples the first user text as sent, which relocation may still change, so
+ * fill it afterwards with fillClaudeBillingSystemBlock.
+ */
+export declare function reserveClaudeBillingSystemBlock(system: TextContent[]): TextContent;
+/** Fill a reserved billing block; remove it when attribution is disabled. */
+export declare function fillClaudeBillingSystemBlock(system: TextContent[], block: TextContent, messages: UnifiedMessage[] | undefined): void;
 /**
  * Insert SYSTEM_IDENTITY after the billing block (normally system[1], or
  * system[0] when attribution is disabled). Any remaining caller system
@@ -45,8 +54,13 @@ export declare function applyClaudeSystemIdentity(system: TextContent[]): void;
  * A no-op when there is no user message to attach the content to, so nothing
  * is silently dropped — the caller's system content stays in `system[]`
  * instead.
+ *
+ * Returns the inserted block unless the first user message has non-empty
+ * string content (the relocated text is then a standalone block a cache
+ * breakpoint can end on); non-empty string content is prefixed in place and
+ * returns undefined.
  */
-export declare function relocateForeignSystemContent(system: TextContent[], messages: UnifiedMessage[] | undefined): void;
+export declare function relocateForeignSystemContent(system: TextContent[], messages: UnifiedMessage[] | undefined): TextContent | undefined;
 /**
  * Claude Code's OAuth validator expects tool names in the mcp_PascalCase
  * spelling used by the official CLI. Non-Claude-Code clients commonly send
@@ -57,8 +71,23 @@ export declare function prefixClaudeToolName(name: string): string;
 /** Restore a Claude Code tool name to the caller's original spelling. */
 export declare function unprefixClaudeToolName(name: string): string;
 /** Rewrite tool names in a Unified request in place for the OAuth wire path. */
-export declare function prefixClaudeToolNames(request: UnifiedChatRequest, nameMap?: Map<string, string>): void;
-/** Rewrite tool names in a Unified/OpenAI-shaped response in place. */
-export declare function unprefixClaudeToolNames(value: any, nameMap?: Map<string, string>): void;
-/** Rewrite one OpenAI SSE data payload's tool names. */
-export declare function unprefixClaudeToolNamesInSseData(value: any, nameMap?: Map<string, string>): void;
+export declare function prefixClaudeToolNames(request: UnifiedChatRequest, nameMap?: Map<string, string>, fixedNames?: Iterable<string>): void;
+/**
+ * Rewrite tool names in a response payload in place and report whether any
+ * name changed. Accepts both shapes a response takes after the provider leg:
+ * Unified/OpenAI (`choices[].message|delta.tool_calls`) and Anthropic
+ * Messages wire (`content[]` tool_use blocks of a message, or the
+ * `content_block_start` stream event that carries a tool_use block's name).
+ *
+ * With a request-local `nameMap`, only names CCR itself prefixed are restored,
+ * which keeps the operation idempotent: a caller's own `mcp__server__tool`
+ * name is never stripped a second time. Without one, fall back to the
+ * spelling heuristic.
+ */
+export declare function unprefixClaudeToolNames(value: any, nameMap?: Map<string, string>): boolean;
+/**
+ * Restore CCR-prefixed tool names in a JSON or SSE response. SSE events and
+ * JSON bodies without a renamed tool are forwarded byte-identical, so
+ * exact-protocol responses keep the provider's usage and framing untouched.
+ */
+export declare function restoreClaudeToolNamesInResponse(response: Response, nameMap: Map<string, string>, logger?: any): Promise<Response>;

package/dist/utils/openai.responses.util.d.ts

@@ -1,4 +1,5 @@
 import { UnifiedChatRequest } from "../types/llm";
+import type { HostedWebSearchRequest } from "../routing/protocol-endpoints";
 export interface ResponsesCallIdMap {
     /** Original client call_id → sanitized id (and reverse). */
     forward: Map<string, string>;
@@ -170,6 +171,14 @@ export interface CodexIsolateConventionsOptions {
  * apply the exec/patch normalizers in one place so stream finalize, the
  * completed skeleton, and the non-stream JSON path cannot drift. */
 export declare function normalizeClientCustomToolInput(name: string | undefined, rawArguments: string, options?: CodexIsolateConventionsOptions): string;
+/**
+ * Hosted web search options from a Responses `web_search` tool. Unified keeps
+ * only the `web_search` function projection, so destinations that run the
+ * search themselves (Anthropic server tools) read these request-locally.
+ */
+export declare function hostedWebSearchFromResponsesTools(tools: unknown): HostedWebSearchRequest | undefined;
+/** Approximate location fields shared by Responses and Chat search options. */
+export declare function hostedUserLocation(location: any): Pick<HostedWebSearchRequest, "userLocation">;
 /** Unified Chat JSON → Responses API non-stream response. */
 export declare function unifiedResponseToResponses(chat: any, options?: {
     originalModel?: string;
@@ -185,10 +194,20 @@ export interface ResponsesStreamState {
     textClosed: boolean;
     textOutputIndex?: number;
     textContent: string;
+    /** Unified text length before the current text item (annotation offsets). */
+    textBase: number;
+    /** Unified text length emitted so far across all text items. */
+    totalTextLength: number;
+    textAnnotations: any[];
     closedTextItems: Array<{
         id: string;
         outputIndex: number;
         content: string;
+        annotations: any[];
+    }>;
+    webSearchCalls: Array<{
+        item: any;
+        outputIndex: number;
     }>;
     toolCalls: Map<number, {
         id: string;

package/dist/utils/tool-content.d.ts

@@ -39,6 +39,12 @@ export declare function unifiedToolTextOnly(content: unknown): string;
 export declare function unifiedToolHasMedia(content: unknown): boolean;
 /** Anthropic tool_result.content: string or (text|image|document)[]. */
 export declare function unifiedToolContentToAnthropic(content: unknown): string | any[];
+/**
+ * Anthropic blocks for one Unified user content part. Empty when the part is
+ * not sent (empty text, image without URL, file without data or URL, unknown
+ * type), so callers placing cache breakpoints can skip it.
+ */
+export declare function unifiedUserPartToAnthropic(part: any): any[];
 /**
  * Anthropic inbound tool_result.content → Unified tool content
  * (string or text/image_url/file parts).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caeliq/llms",
-  "version": "1.0.70",
+  "version": "1.0.72",
   "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.120.0",
-    "@caeliq/ccr-shared": "^2.1.12",
+    "@caeliq/ccr-shared": "^2.1.14",
     "@cursor/sdk": "^1.0.32",
     "@fastify/cors": "^11.3.0",
     "@fastify/rate-limit": "^11.2.0",