@caeliq/llms 1.0.56 → 1.0.58

package/dist/utils/router.d.ts

@@ -0,0 +1,42 @@
+import { ConfigService } from "../services/config";
+import { TokenizerService } from "../services/tokenizer";
+interface Tool {
+    name: string;
+    description?: string;
+    input_schema: object;
+}
+interface ContentBlockParam {
+    type: string;
+    [key: string]: any;
+}
+interface MessageParam {
+    role: string;
+    content: string | ContentBlockParam[];
+}
+/** Normalize `provider/model` or `provider,model` into our `provider,model` form. */
+export declare function normalizeModelSelector(value: string | undefined | null): string | undefined;
+/**
+ * Strip Claude Code's billing helper system block.
+ * Returns true when that block marks the request as a subagent.
+ */
+export declare function removeClaudeCodeBillingSystemHeader(body: any): boolean;
+/** Prefer system tag, then early user-message tag; strip whichever matched. */
+export declare function extractAndRemoveClaudeCodeSubagentModelTag(body: any): string | undefined;
+export declare const calculateTokenCount: (messages: MessageParam[], system: any, tools: Tool[]) => number;
+export interface RouterContext {
+    configService: ConfigService;
+    tokenizerService?: TokenizerService;
+    event?: any;
+}
+export type RouterScenarioType = 'default' | 'background' | 'think' | 'longContext' | 'webSearch' | 'subagent';
+export interface RouterFallbackConfig {
+    default?: string[];
+    background?: string[];
+    think?: string[];
+    longContext?: string[];
+    webSearch?: string[];
+    subagent?: string[];
+}
+export declare const router: (req: any, _res: any, context: RouterContext) => Promise<void>;
+export declare const searchProjectBySession: (sessionId: string, logger?: any) => Promise<string | null>;
+export {};

package/dist/utils/schema.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Recursively sanitizes a JSON schema by:
+ * 1. Stripping unknown fields (not in VALID_SCHEMA_FIELDS)
+ * 2. Removing enum from non-string types
+ * 3. Removing format from string types (except "enum" and "date-time")
+ * 4. Removing format: 'uri' from any type
+ * 5. Removing $schema field
+ *
+ * This is a superset of normalizeJsonSchema that also handles
+ * field whitelisting and enum/format cleanup needed by providers
+ * like Gemini and Mistral.
+ */
+export declare function sanitizeJsonSchema(schema: any, parentKey?: string): any;
+/**
+ * Collapse union subschemas that carry no `type` of their own.
+ *
+ * Antigravity serves Claude models by parsing our Gemini `generateContent` body
+ * into the Gemini Schema proto and re-emitting it as an Anthropic tool schema. A
+ * subschema with `anyOf` and no sibling `type` has no proto type to carry, and
+ * what comes out the far side fails Anthropic's draft 2020-12 validation:
+ *
+ *   tools.18.custom.input_schema: JSON schema is invalid.
+ *
+ * Adding a sibling `type` is not an option — Gemini rejects that outright with
+ * "type and anyOf cannot be both populated" — so the union is collapsed onto its
+ * first typed branch instead, and the alternatives are recorded in the
+ * description so the model still knows they exist. Lossy, but the alternative is
+ * that every request carrying such a tool fails.
+ *
+ * Gemini itself handles typeless unions fine, so this is only for backends
+ * reached through the Gemini wire format.
+ */
+export declare function collapseTypelessUnions(schema: any): any;
+/**
+ * Normalizes a JSON schema by removing fields that may cause API rejections:
+ * - format: 'uri' from string types
+ * - $schema field
+ *
+ * For full sanitization (field whitelist, enum/format cleanup), use sanitizeJsonSchema instead.
+ */
+export declare function normalizeJsonSchema(schema: any): any;
+/**
+ * Normalizes tool function parameters by removing problematic fields.
+ * Uses sanitizeJsonSchema for thorough cleanup.
+ */
+export declare function normalizeToolParameters(parameters: any): any;

package/dist/utils/sse/SSEParser.transform.d.ts

@@ -0,0 +1,6 @@
+export declare class SSEParserTransform extends TransformStream<string, any> {
+    private buffer;
+    private currentEvent;
+    constructor();
+    private processLine;
+}

package/dist/utils/sse/SSESerializer.transform.d.ts

@@ -0,0 +1,3 @@
+export declare class SSESerializerTransform extends TransformStream<any, string> {
+    constructor();
+}

package/dist/utils/sse/index.d.ts

@@ -0,0 +1,3 @@
+export { SSEParserTransform } from './SSEParser.transform';
+export { SSESerializerTransform } from './SSESerializer.transform';
+export { rewriteStream } from './rewriteStream';

package/dist/utils/sse/rewriteStream.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Rewrite stream utility
+ * Reads source readablestream and returns a new readablestream,
+ * processor processes source data and pushes returned new value to new stream,
+ * no push if no return value
+ * @param stream
+ * @param processor
+ */
+export declare const rewriteStream: (stream: ReadableStream, processor: (data: any, controller: ReadableStreamController<any>) => Promise<any>) => ReadableStream;

package/dist/utils/stream.d.ts

@@ -0,0 +1,11 @@
+export interface StreamContext {
+    controller: ReadableStreamDefaultController;
+    encoder: TextEncoder;
+}
+export declare function createSSEStreamReader(response: Response, processLine: (line: string, context: StreamContext) => void, options?: {
+    bufferSize?: number;
+    onComplete?: (context: StreamContext) => void;
+    logger?: any;
+}): Response;
+export declare function encodeSSEData(data: string, encoder: TextEncoder): Uint8Array;
+export declare function encodeSSELine(line: string, encoder: TextEncoder): Uint8Array;

package/dist/utils/thinking.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Accumulator for streaming reasoning/thinking content.
+ * Used to buffer reasoning chunks across SSE events and emit
+ * a final thinking block with signature when reasoning completes.
+ */
+export interface ReasoningAccumulator {
+    content: string;
+    isComplete: boolean;
+    hasContent: boolean;
+}
+export declare function createReasoningAccumulator(): ReasoningAccumulator;
+export declare function accumulateReasoning(accumulator: ReasoningAccumulator, text: string): void;
+export declare function finalizeReasoning(accumulator: ReasoningAccumulator): {
+    content: string;
+    signature: string;
+};
+/**
+ * Build a chat.completion.chunk with a thinking delta.
+ * Used when emitting accumulated reasoning content as a thinking block.
+ */
+export declare function buildThinkingChunk(baseData: any, thinking: {
+    content?: string;
+    signature?: string;
+}): any;
+/**
+ * Extract reasoning text from various provider-specific delta fields.
+ * Supports: delta.reasoning_content (DeepSeek/Mistral), delta.reasoning (OpenRouter)
+ */
+export declare function extractReasoningText(delta: any): string | null;
+/**
+ * Remove reasoning-specific fields from a delta after extraction.
+ */
+export declare function cleanReasoningFields(delta: any): void;

package/dist/utils/thought-signature-cache.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Thought signatures for tool calls, carried across turns on behalf of clients
+ * that cannot round-trip them.
+ *
+ * Gemini 3 / Antigravity sign the reasoning behind every `functionCall` and
+ * expect that signature back when the call is replayed. Anthropic's `tool_use`
+ * block has no field to carry it — and must not grow one, since Claude Code's
+ * wire format is fixed — so the signature is lost the moment a turn reaches the
+ * client. The documented `skip_thought_signature_validator` sentinel stops the
+ * request from 400ing, but Google is explicit that it is a last resort that
+ * "will negatively impact model performance": the model is handed back its own
+ * earlier tool calls stripped of the signed reasoning that produced them.
+ *
+ * Observed consequence in a long Claude Code session: upstream signatures shrank
+ * from ~1.2 KB to a 56-byte stub over six replayed tool calls, then the model
+ * emitted an empty `functionCall` and the turn died with
+ * `MALFORMED_FUNCTION_CALL` ("Function call is empty - no input to parse").
+ *
+ * So CCR keeps the signatures here instead of discarding them, keyed by the one
+ * identifier that does survive the round trip:
+ *
+ *   upstream functionCall.id → Anthropic tool_use.id
+ *     → tool_result.tool_use_id → Unified tool_calls[].id
+ *
+ * Entries are scoped per provider: a signature minted by one upstream is not
+ * valid at another, so a conversation re-routed mid-session misses the cache and
+ * falls back to the sentinel rather than replaying a foreign signature.
+ */
+export declare function rememberThoughtSignature(scope: string | undefined, id: string | undefined, signature: string | undefined): void;
+export declare function recallThoughtSignature(scope: string | undefined, id: string | undefined): string | undefined;
+/** Test hook. */
+export declare function clearThoughtSignatureCache(): void;
+/** Test hook. */
+export declare function thoughtSignatureCacheSize(): number;

package/dist/utils/toolArgumentsParser.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parse tool call arguments function
+ * First try standard JSON parsing, then JSON5 parsing, finally use jsonrepair for safe repair
+ *
+ * @param argsString - Parameter string to parse
+ * @returns Parsed parameter object or safe empty object
+ */
+export declare function parseToolArguments(argsString: string, logger?: any): string;

package/dist/utils/toolCallId.d.ts

@@ -0,0 +1,15 @@
+export declare function isValidAnthropicToolCallId(id: unknown): id is string;
+/**
+ * Coerce an id into Anthropic's allowed alphabet.
+ *
+ * Runs of invalid characters collapse to a single `_` rather than being
+ * deleted: deletion can merge two distinct ids into one (`a\nb` and `ab` both
+ * become `ab`), and a duplicate `tool_use.id` is a worse failure than a long
+ * one — it silently mispairs tool results.
+ *
+ * Must be deterministic and idempotent. The same id arrives from two
+ * independent directions — emitted on the response and echoed back by the
+ * client on the next request — and both must map to the same value or the
+ * `tool_use` / `tool_result` pair stops matching.
+ */
+export declare function sanitizeToolCallId(id: unknown): string | undefined;

package/dist/utils/vertex-claude.util.d.ts

@@ -0,0 +1,47 @@
+import { UnifiedChatRequest } from "../types/llm";
+interface ClaudeMessage {
+    role: "user" | "assistant";
+    content: Array<{
+        type: "text" | "image" | "tool_use" | "tool_result";
+        text?: string;
+        source?: {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+        id?: string;
+        name?: string;
+        input?: Record<string, any>;
+        tool_use_id?: string;
+        content?: string | Array<any>;
+    }>;
+}
+interface ClaudeTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: Record<string, any>;
+        required?: string[];
+        additionalProperties?: boolean;
+        $schema?: string;
+    };
+}
+interface VertexClaudeRequest {
+    anthropic_version: "vertex-2023-10-16";
+    messages: ClaudeMessage[];
+    max_tokens: number;
+    stream?: boolean;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    tools?: ClaudeTool[];
+    tool_choice?: "auto" | "none" | {
+        type: "tool";
+        name: string;
+    };
+}
+export declare function buildRequestBody(request: UnifiedChatRequest): VertexClaudeRequest;
+export declare function transformRequestOut(request: Record<string, any>): UnifiedChatRequest;
+export declare function transformResponseOut(response: Response, providerName: string, logger?: any): Promise<Response>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caeliq/llms",
-  "version": "1.0.56",
+  "version": "1.0.58",
   "description": "A universal LLM API transformation server",
   "main": "dist/cjs/server.cjs",
   "module": "dist/esm/server.mjs",
@@ -30,10 +30,10 @@
   ],
   "dependencies": {
     "@anthropic-ai/sdk": "^0.54.0",
-    "@caeliq/ccr-shared": "^2.0.2",
+    "@caeliq/ccr-shared": "^2.1.0",
     "@cursor/sdk": "^1.0.23",
     "@fastify/cors": "^11.0.1",
-    "@google/genai": "^1.7.0",
+    "@google/genai": "^2.13.0",
     "@huggingface/tokenizers": "^0.0.6",
     "dotenv": "^16.5.0",
     "fastify": "^5.4.0",