@caeliq/llms 1.0.68 → 1.0.69

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/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/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,27 @@ 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 rejects `none` / `minimal`; OpenAI's migration floor is `low`. */
+export declare function coerceGpt6ReasoningEffort(model: unknown, effort: ThinkLevel | undefined): ThinkLevel | undefined;
+/**
+ * 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.69",
   "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.10",
+    "@caeliq/ccr-shared": "^2.1.11",
     "@cursor/sdk": "^1.0.30",
     "@fastify/cors": "^11.3.0",
     "@fastify/rate-limit": "^11.2.0",