@caeliq/llms 1.0.68 → 1.0.70

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

@@ -0,0 +1,6 @@
+import type { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
+import type { Transformer } from "../types/transformer";
+/**
+ * Dedicated FIM pipeline — does not call prepareInboundRequest / chat Unified.
+ */
+export declare function handleFimEndpoint(req: FastifyRequest, reply: FastifyReply, fastify: FastifyInstance, _ownerTransformer: Transformer, routePath: string): Promise<undefined>;

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

@@ -4,7 +4,7 @@ import type { ResponsesCallIdMap } from "../utils/openai.responses.util";
 /**
  * Inbound client protocols supported by CCR's gateway lifecycle.
  */
-export type ClientProtocol = "anthropic_messages" | "openai_chat_completions" | "openai_responses";
+export type ClientProtocol = "anthropic_messages" | "openai_chat_completions" | "openai_responses" | "openai_fim_completions";
 export interface AnthropicSourceRequestFields {
     metadata?: Record<string, unknown>;
     thinking?: Record<string, unknown>;

package/dist/tests/fim.endpoint.d.ts

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

package/dist/tests/fim.transformers.d.ts

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

package/dist/tests/gpt6.astra-hardening.d.ts

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

package/dist/tests/opencode-gate-stubs.d.ts

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

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

@@ -48,7 +48,7 @@ export declare function modelIdForRequestedOneMillionBeta(modelId: string | unde
  * post-build Anthropic body (not the Unified request) because
  * `buildAnthropicBody` may synthesize `thinking`/`output_config` itself.
  */
-export declare function applyClaudeModelCapabilityAdjustments(anthropicBody: Record<string, any>, entry: ClaudeModelCatalogEntry | undefined): void;
+export declare function applyClaudeModelCapabilityAdjustments(anthropicBody: Record<string, any>, entry: ClaudeModelCatalogEntry | undefined, logger?: any): 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. */

package/dist/transformer/fim/fim.deepseek.transformer.d.ts

@@ -0,0 +1,15 @@
+import type { LLMProvider } from "../../types/llm";
+import type { Transformer, TransformerContext } from "../../types/transformer";
+import { type UnifiedFimRequest } from "../../utils/fim";
+/**
+ * DeepSeek beta completions FIM outbound.
+ * Same-kind (future deepseek inbound): auth + URL only.
+ * Cross-family from Codestral Unified: prompt+suffix + 4K clamp + non-thinking.
+ */
+export declare class FimDeepseekTransformer implements Transformer {
+    static TransformerName: string;
+    name: string;
+    logger?: any;
+    transformRequestIn(request: UnifiedFimRequest | any, provider: LLMProvider, context: TransformerContext): Promise<Record<string, any>>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/fim/fim.mistral.transformer.d.ts

@@ -0,0 +1,14 @@
+import type { LLMProvider } from "../../types/llm";
+import type { Transformer, TransformerContext } from "../../types/transformer";
+import { type UnifiedFimRequest } from "../../utils/fim";
+/**
+ * Codestral / Mistral native FIM outbound.
+ * Same-kind (mistral inbound): body passthrough — auth + URL only.
+ */
+export declare class FimMistralTransformer implements Transformer {
+    static TransformerName: string;
+    name: string;
+    logger?: any;
+    transformRequestIn(request: UnifiedFimRequest | any, provider: LLMProvider, context: TransformerContext): Promise<Record<string, any>>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/fim/fim.qwen.transformer.d.ts

@@ -0,0 +1,15 @@
+import type { LLMProvider } from "../../types/llm";
+import type { Transformer, TransformerContext } from "../../types/transformer";
+import { type UnifiedFimRequest } from "../../utils/fim";
+/**
+ * Qwen Completions FIM (LM Studio + DashScope).
+ * Same-kind (future qwen inbound): auth + URL only — do not re-template.
+ * Cross-family from Codestral Unified: HF tokens in prompt, no suffix field.
+ */
+export declare class FimQwenTransformer implements Transformer {
+    static TransformerName: string;
+    name: string;
+    logger?: any;
+    transformRequestIn(request: UnifiedFimRequest | any, provider: LLMProvider, context: TransformerContext): Promise<Record<string, any>>;
+    transformResponseOut(response: Response): Promise<Response>;
+}

package/dist/transformer/fim/fim.transformer.d.ts

@@ -0,0 +1,22 @@
+import type { LLMProvider } from "../../types/llm";
+import type { Transformer, TransformerContext } from "../../types/transformer";
+import { type UnifiedFimRequest } from "../../utils/fim";
+/**
+ * Protocol owner for POST /v1/fim/completions.
+ * Validates Codestral-shaped inbound → Unified FIM (v1).
+ * Client response framing: same-kind passthrough, else encode to inbound wire.
+ */
+export declare class FimTransformer implements Transformer {
+    static TransformerName: string;
+    name: string;
+    endPoint: string;
+    logger?: any;
+    transformRequestOut(request: any, context: TransformerContext): Promise<any>;
+    /**
+     * Owner does not perform provider outbound; fim.* transformers do.
+     * transformResponseIn is a no-op identity for pipeline compatibility.
+     */
+    transformResponseIn(response: Response): Promise<Response>;
+}
+/** Type helper — FIM provider transformers accept UnifiedFimRequest. */
+export type FimProviderTransformIn = (request: UnifiedFimRequest, provider: LLMProvider, context: TransformerContext) => Promise<Record<string, any>>;

package/dist/transformer/fim/index.d.ts

@@ -0,0 +1,4 @@
+export { FimTransformer } from "./fim.transformer";
+export { FimMistralTransformer } from "./fim.mistral.transformer";
+export { FimDeepseekTransformer } from "./fim.deepseek.transformer";
+export { FimQwenTransformer } from "./fim.qwen.transformer";

package/dist/transformer/index.d.ts

@@ -30,6 +30,7 @@ import { ClaudeAuthTransformer } from "./claude-auth.transformer";
 import { CursorSdkTransformer } from "./cursor-sdk.transformer";
 import { AntigravityAuthTransformer } from "./antigravity-auth.transformer";
 import { XaiAuthTransformer } from "./xai-auth.transformer";
+import { FimTransformer, FimMistralTransformer, FimDeepseekTransformer, FimQwenTransformer } from "./fim";
 declare const _default: {
     AnthropicTransformer: typeof AnthropicTransformer;
     GeminiTransformer: typeof GeminiTransformer;
@@ -63,5 +64,9 @@ declare const _default: {
     CursorSdkTransformer: typeof CursorSdkTransformer;
     AntigravityAuthTransformer: typeof AntigravityAuthTransformer;
     XaiAuthTransformer: typeof XaiAuthTransformer;
+    FimTransformer: typeof FimTransformer;
+    FimMistralTransformer: typeof FimMistralTransformer;
+    FimDeepseekTransformer: typeof FimDeepseekTransformer;
+    FimQwenTransformer: typeof FimQwenTransformer;
 };
 export default _default;

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

@@ -10,6 +10,8 @@ import { UnifiedChatRequest } from "../types/llm";
  *
  * ## Full request pipeline (for context)
  *
+ * Chat protocols share one lifecycle; the Anthropic inbound example:
+ *
  *     Client → POST /v1/messages
  *       → AnthropicTransformer.transformRequestOut()        // Anthropic → Unified (OpenAI)
  *       → provider.transformer.use[].transformRequestIn()   // provider middleware
@@ -24,6 +26,9 @@ import { UnifiedChatRequest } from "../types/llm";
  *       → OpenAITransformer.transformRequestOut()           // validate → Unified
  *       → provider.transformer.use[].transformRequestIn()
  *       → … → OpenAITransformer.transformResponseIn()       // reasoning_content; strip Unified thinking
+ *
+ * Responses and FIM use their own owners (`openai-responses`, `Fim`). FIM is a
+ * separate pipeline from chat Unified.
  */
 export declare class OpenAITransformer implements Transformer {
     name: string;

package/dist/transformer/opencode-headers.transformer.d.ts

@@ -5,23 +5,37 @@ export declare class OpencodeHeadersTransformer implements Transformer {
     requestPhase: "transport";
     private lastTimestamp;
     private counter;
+    private firstEventTimeoutMs;
+    private firstProgressTimeoutMs;
+    private streamIdleTimeoutMs;
+    private reasoningIdleTimeoutMs;
     transformRequestIn(request: any, provider: any, context: any): Promise<Record<string, any>>;
-    transformResponseOut(response: Response): Promise<Response>;
+    transformResponseOut(response: Response, context?: any): Promise<Response>;
+    /** Restore JSON for clients whose requests were streamed only to pass Zen's gate. */
+    private collectForcedStream;
     /**
-     * Own the full upstream call so a `No provider available` 401 can be retried
-     * with a fresh session in isolation. Any other non-ok response is re-thrown in
-     * the exact shape sendRequestToProvider would have produced, so genuine
-     * auth/rate/server errors keep flowing through the normal error + fallback
-     * path unchanged.
+     * Own the full upstream call so Zen routing failures can be recovered by
+     * re-rolling the session, and transient failures retried on the same one.
+     * Exhausted routing failures become 503 so the normal fallback path can try
+     * another model; ordinary 4xx errors retain their upstream status.
      */
     private sendWithSessionRetry;
+    /**
+     * Zen can send SSE headers and lifecycle events, then stall before any
+     * output. Hold the response until a complete event and real output progress
+     * arrive while a fallback is still possible, then bound later idle reads.
+     * An open reasoning item emits nothing until it finishes when no summary is
+     * streamed, so while one is open the looser reasoning bound applies instead.
+     */
+    private requireFirstZenEvent;
     private preserveZenStreamErrors;
     private static zenStreamFailure;
     private buildHeaders;
     private resolveParentSessionId;
     /**
-     * True only for the two Zen session-hash routing failures — a re-roll can
-     * recover these. Kept deliberately narrow (exact status + message) so genuine
+     * True only for the two Zen session-hash routing failures — retried on the
+     * SAME session (which must not change during a conversation), then passed
+     * to fallback. Kept deliberately narrow (exact status + message) so genuine
      * auth errors (401 invalid key) and request errors (400 validation) are never
      * mistaken for routing failures and pass straight through.
      */
@@ -32,8 +46,77 @@ export declare class OpencodeHeadersTransformer implements Transformer {
     private retryAfterHeaders;
     private ensurePromptCacheKey;
     private ensurePromptCacheRetention;
+    /**
+     * Free-tier gate scope: `-free` models on a zen (opencode.ai) endpoint.
+     * Paid Zen models and non-Zen providers sharing this transformer skip the
+     * stub/stream handling below entirely.
+     */
+    private static isFreeTierZenRequest;
+    /**
+     * The free-tier gate answers `stream: false` with 403 FreeTierError even
+     * when everything else is exact (curl A/B 2026-09-24). Force SSE on the
+     * wire; the normal response path does not de-stream SSE for JSON clients,
+     * so transformRequestIn records the forced shape and transformResponseOut
+     * restores JSON via collectForcedStream.
+     */
+    private ensureStreamedForFreeTier;
+    /**
+     * Free-tier thinking arrives almost entirely as opaque `encrypted_content`;
+     * the only readable part is the reasoning summary, and Zen emits ~nothing
+     * unless `reasoning.summary` is asked for (curl A/B 2026-09-24, same prompt:
+     * `"detailed"` → 68 summary chars, `"auto"` → 0). Stamp `detailed` when the
+     * client already reasons but states no summary preference. An explicit
+     * client value (including `"none"`) always wins; absent/disabled reasoning
+     * is left alone so non-reasoning calls never gain a reasoning block.
+     */
+    private ensureDetailedSummaryForFreeTier;
+    /**
+     * Zen aborts free-tier Responses runs (`response.incomplete`, no further
+     * events — a client-side stall) unless `prompt_cache_key` equals the
+     * `x-opencode-session` header (curl A/B 2026-09-24). CCR's generic cache
+     * key (`ccr_<sha256>`, stable per conversation but foreign to Zen) must be
+     * replaced after `ensurePromptCacheKey` runs. Scoped to free-tier Zen on the
+     * Responses wire; chat bodies and paid models keep existing behavior.
+     * Runs per attempt so header and key stay in lockstep.
+     */
+    private applyFreeTierCacheKey;
+    /**
+     * Inject the exact-name `read`/`shell` function stubs the free-tier gate
+     * requires (curl A/B 2026-09-24: lowercase exact match; `Read`/`Bash`
+     * fail, schemas are free-form, extras harmless). Client tools are never
+     * modified or reordered; stubs are appended. Each stub clones its client
+     * counterpart's description/parameters when present so a
+     * stub call maps back onto a schema the client already accepts; otherwise
+     * it carries a minimal empty-object schema. Returns the alias map
+     * (stub -> client name, or null without counterpart) for the response
+     * stage; no aliases when nothing was injected.
+     */
+    private ensureGateStubTools;
+    private static readonly GATE_STUB_COUNTERPARTS;
+    private static outgoingToolShape;
+    private static toolName;
+    private static toolDef;
+    private static buildStubTool;
+    private static gateAliasesFrom;
+    /**
+     * Map gate-stub calls back to the advertised client tool inside SSE events.
+     * Only `name` fields on
+     * Responses `function_call` objects and chat `tool_calls[].function` objects
+     * are touched; text payloads and unrelated events pass through byte-identical.
+     * Stubs without a client counterpart are left alone (the client errors on
+     * them exactly as it would on any unknown tool).
+     */
+    private rewriteGateStubCalls;
+    private static renameGateStubCalls;
     private fingerprintConversation;
-    private getOrCreateSessionId;
     private invalidateSession;
+    /**
+     * Conversation identity for the Zen session binding: an explicit client
+     * session id wherever the client supplies one (router-parsed, protocol
+     * context, or the shared header/body extractor used for cache keys), and
+     * the content fingerprint only for fully anonymous clients.
+     */
+    private resolveConversationId;
+    private getOrCreateSessionId;
     private generateId;
 }

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

@@ -9,7 +9,7 @@ export declare function extractFirstUserMessageText(messages: UnifiedMessage[] |
 export declare function computeVersionSuffix(text: string, version: string): string;
 /**
  * Current first-party Anthropic requests use the literal cch marker. Older
- * captures showed a random session value; the current 2.1.226 decompilation
+ * captures showed a random session value; the current 2.1.280 decompilation
  * gates this field to first-party/Vertex and emits `00000`.
  */
 export declare function sessionCch(): string;

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

@@ -1,6 +1,6 @@
 /**
  * Claude Code's bundled model capability catalog, revalidated against the
- * installed v2.1.226 CLI decompilation.
+ * installed v2.1.280 CLI decompilation.
  *
  * Every model-dependent decision in the claude-auth impersonation path (beta
  * flags, effort support, thinking shape, max_tokens ceiling) is driven by
@@ -21,6 +21,21 @@ export interface ClaudeModelCatalogEntry {
     };
     defaultEffort?: string;
     capabilities: string[];
+    /**
+     * CCR-owned Messages API request constraints. Not part of Claude Code's
+     * catalog (Claude Code simply never sends these shapes); sourced from
+     * Anthropic's per-model API documentation. Each flag names a request shape
+     * the model rejects with HTTP 400, so third-party emulation must normalize
+     * it away before sending.
+     */
+    apiConstraints?: {
+        /** `thinking: {type: "disabled"}` is rejected; thinking is always on. */
+        thinkingAlwaysOn?: boolean;
+        /** Forced `tool_choice` (`any` / `tool`) is rejected. */
+        noForcedToolChoice?: boolean;
+        /** `temperature` / `top_p` / `top_k` are rejected. */
+        noSamplingParams?: boolean;
+    };
 }
 export declare const CLAUDE_MODEL_CATALOG: Record<string, ClaudeModelCatalogEntry>;
 /** Strip the "[1m]" wire marker, reporting whether it was present. */

package/dist/utils/fim/encode.d.ts

@@ -0,0 +1,14 @@
+import type { UnifiedFimRequest } from "./types";
+declare const DEEPSEEK_FIM_MAX_TOKENS = 4096;
+/** Qwen / HF FIM markers for completions prompt. */
+export declare function buildQwenFimPrompt(prompt: string, suffix?: string): string;
+/** Sampling fields shared across FIM outbound bodies. */
+export declare function pickFimSamplingFields(unified: UnifiedFimRequest): Record<string, unknown>;
+/** Native prompt+suffix body (Mistral / DeepSeek field shape). */
+export declare function encodePromptSuffixBody(unified: UnifiedFimRequest, options?: {
+    clampMaxTokens?: number;
+    disableThinking?: boolean;
+}): Record<string, unknown>;
+export declare function encodeDeepseekFimBody(unified: UnifiedFimRequest): Record<string, unknown>;
+export declare function encodeQwenFimBody(unified: UnifiedFimRequest): Record<string, unknown>;
+export { DEEPSEEK_FIM_MAX_TOKENS };

package/dist/utils/fim/inbound.d.ts

@@ -0,0 +1,9 @@
+import type { FimInboundKind } from "./kinds";
+import type { UnifiedFimRequest } from "./types";
+/**
+ * Inbound → Unified FIM seam.
+ * v1: only Codestral/Mistral kind. Future: inboundKind selects an adapter.
+ */
+export declare function inboundToUnifiedFim(body: unknown, inboundKind?: FimInboundKind): UnifiedFimRequest;
+/** Clone client body for same-kind passthrough (preserve unknown fields). */
+export declare function cloneFimClientBody(body: unknown, modelName: string): Record<string, unknown>;

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

@@ -0,0 +1,7 @@
+export type { UnifiedFimRequest, UnifiedFimResponse, UnifiedFimChoice, } from "./types";
+export type { FimInboundKind, FimOutboundFamily } from "./kinds";
+export { V1_FIM_INBOUND_KIND, isFimProviderTransformerName, outboundFamilyFromTransformerName, shouldFimPassthrough, } from "./kinds";
+export { inboundToUnifiedFim, cloneFimClientBody, } from "./inbound";
+export { resolveFimMistralUrl, resolveFimDeepseekUrl, resolveFimQwenCompletionsUrl, bearerAuthHeaders, } from "./url";
+export { buildQwenFimPrompt, pickFimSamplingFields, encodePromptSuffixBody, encodeDeepseekFimBody, encodeQwenFimBody, DEEPSEEK_FIM_MAX_TOKENS, } from "./encode";
+export { encodeFimResponseForInbound, normalizeToFimClientJson, normalizeFimSseDataPayload, } from "./response";

package/dist/utils/fim/kinds.d.ts

@@ -0,0 +1,16 @@
+/**
+ * FIM inbound/outbound family kinds. v1 only implements mistral/codestral
+ * inbound; deepseek/qwen inbound adapters are reserved for later.
+ */
+export type FimInboundKind = "mistral" | "deepseek" | "qwen";
+export type FimOutboundFamily = "mistral" | "deepseek" | "qwen";
+/** v1 hard-wired inbound kind (Codestral/Mistral-shaped client wire). */
+export declare const V1_FIM_INBOUND_KIND: FimInboundKind;
+export declare function isFimProviderTransformerName(name: string | undefined): boolean;
+export declare function outboundFamilyFromTransformerName(name: string | undefined): FimOutboundFamily | null;
+/**
+ * Same-kind passthrough: no request or response shape translation —
+ * auth/URL only. Kept generic so future DeepSeek→DeepSeek / Qwen→Qwen
+ * inbound works the same.
+ */
+export declare function shouldFimPassthrough(inboundKind: FimInboundKind, outboundFamily: FimOutboundFamily): boolean;

package/dist/utils/fim/response.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Encode upstream FIM responses to the **inbound** client wire.
+ * Client response shape follows inbound kind (not outbound provider).
+ * v1 inbound is mistral/Codestral; deepseek/qwen inbound reserved for later.
+ */
+import type { FimInboundKind } from "./kinds";
+/**
+ * Normalize upstream JSON to the inbound client wire.
+ * @param inboundKind — must match the kind used for inboundToUnifiedFim
+ */
+export declare function encodeFimResponseForInbound(payload: any, inboundKind?: FimInboundKind): Record<string, any>;
+/** @deprecated Prefer encodeFimResponseForInbound(payload, inboundKind) */
+export declare function normalizeToFimClientJson(payload: any, inboundKind?: FimInboundKind): Record<string, any>;
+/**
+ * Map one SSE data payload to the inbound client wire.
+ */
+export declare function normalizeFimSseDataPayload(dataStr: string, inboundKind?: FimInboundKind): string;

package/dist/utils/fim/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Unified FIM intermediate (prompt + optional suffix + sampling).
+ * Types live next to FIM utils — not a separate types/fim package.
+ *
+ * Client response wire follows **inbound** kind (see encodeFimResponseForInbound).
+ * v1 inbound is mistral/Codestral chat.completion; other kinds reserved.
+ */
+export interface UnifiedFimRequest {
+    model: string;
+    prompt: string;
+    suffix?: string;
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stop?: string | string[];
+    stream?: boolean;
+    min_tokens?: number;
+    random_seed?: number;
+}
+/** Choice on mistral/Codestral inbound client wire. */
+export interface UnifiedFimChoice {
+    index: number;
+    message: {
+        role: string;
+        content: string;
+    };
+    finish_reason: string;
+}
+export interface UnifiedFimResponse {
+    id: string;
+    object: "chat.completion";
+    model: string;
+    created: number;
+    choices: UnifiedFimChoice[];
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    [key: string]: unknown;
+}

package/dist/utils/fim/url.d.ts

@@ -0,0 +1,13 @@
+/** Resolve Codestral/Mistral native FIM URL from provider base. */
+export declare function resolveFimMistralUrl(baseUrl: string): URL;
+/**
+ * DeepSeek hosted FIM uses beta completions.
+ * Prefer explicit …/beta/completions; otherwise derive from host.
+ */
+export declare function resolveFimDeepseekUrl(baseUrl: string): URL;
+/**
+ * Qwen / LM Studio / DashScope: OpenAI legacy completions.
+ * Trust api_base_url when it already ends with /completions.
+ */
+export declare function resolveFimQwenCompletionsUrl(baseUrl: string): URL;
+export declare function bearerAuthHeaders(apiKey: string | undefined): Record<string, string>;

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

@@ -32,4 +32,32 @@ export declare function canonicalReasoning(effortValue: unknown, enabledWhenEffo
 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;
+/**
+ * GPT-6 family slugs (`gpt-6`, `gpt-6-astra`, `openai/gpt-6-astra`,
+ * `codex,gpt-6-astra`). Anchored so `gpt-60` / `gpt-5.6` do not match.
+ */
+export declare function isGpt6FamilyModel(model: unknown): boolean;
+/** Astra/Sol reject `none` / `minimal`; OpenAI's migration floor is `low`. */
+export declare function coerceGpt6ReasoningEffort(model: unknown, effort: ThinkLevel | undefined): ThinkLevel | undefined;
+/**
+ * GPT-6 Luna slugs (`gpt-6-luna`, `openai/gpt-6-luna`, `codex,gpt-6-luna`).
+ * Anchored so `gpt-6-sol` / `gpt-6-astra` do not match.
+ */
+export declare function isGpt6LunaModel(model: unknown): boolean;
+/**
+ * Remap unsupported GPT-6 efforts on a Responses/Unified request in place.
+ * Covers convert (`openai-responses`) and same-protocol wire-keep (`codex`).
+ */
+export declare function applyGpt6ReasoningEffortCoercion(request: {
+    model?: unknown;
+    reasoning?: {
+        effort?: unknown;
+        enabled?: boolean;
+    } | null;
+}): void;
+/**
+ * GPT-6 Astra rejects temperature / top_p / logprobs on Responses. Strip in
+ * place when the model is in the gpt-6 family.
+ */
+export declare function stripGpt6UnsupportedSampling(request: Record<string, any>): void;
 export {};

package/dist/utils/router.d.ts

@@ -35,7 +35,7 @@ export interface RouterContext {
     tokenizerService?: TokenizerService;
     event?: any;
 }
-export type RouterScenarioType = 'default' | 'background' | 'think' | 'longContext' | 'webSearch' | 'subagent';
+export type RouterScenarioType = 'default' | 'background' | 'think' | 'longContext' | 'webSearch' | 'subagent' | 'fim';
 export interface RouterFallbackConfig {
     default?: string[];
     background?: string[];
@@ -43,6 +43,7 @@ export interface RouterFallbackConfig {
     longContext?: string[];
     webSearch?: string[];
     subagent?: string[];
+    fim?: string[];
 }
 export declare const router: (req: any, _res: any, context: RouterContext) => Promise<void>;
 export declare const searchProjectBySession: (sessionId: string, logger?: any) => Promise<string | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caeliq/llms",
-  "version": "1.0.68",
+  "version": "1.0.70",
   "description": "A universal LLM API transformation server",
   "main": "dist/cjs/server.cjs",
   "module": "dist/esm/server.mjs",
@@ -30,8 +30,8 @@
   ],
   "dependencies": {
     "@anthropic-ai/sdk": "^0.120.0",
-    "@caeliq/ccr-shared": "^2.1.10",
-    "@cursor/sdk": "^1.0.30",
+    "@caeliq/ccr-shared": "^2.1.12",
+    "@cursor/sdk": "^1.0.32",
     "@fastify/cors": "^11.3.0",
     "@fastify/rate-limit": "^11.2.0",
     "@google/genai": "^2.18.0",