@caeliq/llms 1.0.55 → 1.0.57

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/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.55",
+  "version": "1.0.57",
   "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.1",
+    "@caeliq/ccr-shared": "^2.0.3",
     "@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",