@wengine-ai/llms 2.3.2404 → 2.3.2406

package/dist/transformer/defaultthinking.transformer.d.ts

@@ -0,0 +1,65 @@
+import { UnifiedChatRequest, ThinkLevel } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export type DefaultThinkingLevel = "none" | "low" | "medium" | "high" | "max";
+type EndpointKind = "anthropic" | "responses" | "chat";
+/**
+ * Extra spellings of the standard levels, kept so configs written before the
+ * ladder grew a "max" tier (and provider docs that name their tiers
+ * differently) still resolve: GLM publishes minimal|light|low → low and
+ * xhigh|max|ultra → max.
+ */
+export declare const ALIAS_LEVELS: Record<string, ThinkLevel>;
+/**
+ * Parse the configured level. Accepted forms:
+ * - "none" | "low" | "medium" | "high" | "max" — the standard enum
+ * - a positive integer (or its decimal string form) — custom token budget
+ * - any other non-empty string — provider-specific level passed through
+ *   verbatim (e.g. "off"); only meaningful on OpenAI-style endpoints, which
+ *   accept free-form effort values
+ * Empty/unparsable input parses as undefined (no injection).
+ */
+export declare function parseThinkingLevel(raw: unknown): DefaultThinkingLevel | number | string | undefined;
+/**
+ * Resolve the provider's upstream endpoint kind from its base URL so the
+ * default thinking level can be expressed in the endpoint's native parameter.
+ * Defaults to OpenAI-compatible chat completions, the most common shape.
+ */
+export declare function sniffEndpointKind(baseUrl?: string): EndpointKind;
+/**
+ * DefaultThinkingTransformer
+ *
+ * Applies a provider-configured default thinking level when the client did
+ * not express any thinking intent. Configured via the provider field
+ * `default_thinking_level` (wired into the chain by ProviderService) or
+ * directly as `["defaultthinking", { "level": "high" }]` in a transformer
+ * `use` list.
+ *
+ * The value is one of "low" | "medium" | "high" | "max", a custom token budget
+ * (number or numeric string), or a provider-specific effort string passed
+ * through verbatim. Conversion per endpoint kind:
+ * - Anthropic /v1/messages: unified `reasoning` — levels ride the effort enum
+ *   (`output_config.effort`, which is what current Anthropic models and
+ *   Anthropic-compatible providers such as GLM actually read) with a matching
+ *   thinking budget; a custom budget flows into `reasoning.max_tokens` (kept
+ *   as the exact budget by convertToAnthropic, raised to Anthropic's 1024
+ *   minimum); known aliases (min|minimal|light→low, xhigh|maximum|ultra→max)
+ *   resolve to their level; any other string is skipped (no string form
+ *   exists).
+ * - OpenAI /v1/responses: unified `reasoning` mapped to `reasoning.effort` —
+ *   custom budgets collapse to the closest effort enum, free-form strings
+ *   pass through.
+ * - OpenAI-compatible /v1/chat/completions: `reasoning_effort` — same enum
+ *   mapping for budgets, verbatim passthrough for free-form strings.
+ *
+ * Client intent always wins: any defined `request.reasoning` — including an
+ * explicit disabled — skips injection entirely. "none" (or an unparsable
+ * value) is a no-op, so the field can stay set in config while effectively
+ * off.
+ */
+export declare class DefaultThinkingTransformer implements Transformer {
+    private readonly options?;
+    static TransformerName: string;
+    constructor(options?: TransformerOptions | undefined);
+    transformRequestIn(request: UnifiedChatRequest, provider?: any): Promise<Record<string, any>>;
+}
+export {};

package/dist/transformer/index.d.ts

@@ -21,6 +21,7 @@ import { OpenAIResponsesTransformer } from "./openai.responses.transformer";
 import { ForceReasoningTransformer } from "./forcereasoning.transformer";
 import { KimiTransformer } from "./kimi.transformer";
 import { OpenCodeTransformer } from "./opencode.transformer";
+import { DefaultThinkingTransformer } from "./defaultthinking.transformer";
 declare const _default: {
     AnthropicTransformer: typeof AnthropicTransformer;
     GeminiTransformer: typeof GeminiTransformer;
@@ -45,5 +46,6 @@ declare const _default: {
     ForceReasoningTransformer: typeof ForceReasoningTransformer;
     KimiTransformer: typeof KimiTransformer;
     OpenCodeTransformer: typeof OpenCodeTransformer;
+    DefaultThinkingTransformer: typeof DefaultThinkingTransformer;
 };
 export default _default;

package/dist/types/llm.d.ts

@@ -66,7 +66,7 @@ export interface UnifiedTool {
         };
     };
 }
-export type ThinkLevel = "none" | "low" | "medium" | "high";
+export type ThinkLevel = "none" | "low" | "medium" | "high" | "max";
 export interface UnifiedChatRequest {
     messages: UnifiedMessage[];
     model: string;

package/dist/utils/thinking.d.ts

@@ -1,2 +1,25 @@
 import { ThinkLevel } from "../types/llm";
 export declare const getThinkLevel: (thinking_budget: number) => ThinkLevel;
+export declare const getThinkBudget: (level: ThinkLevel) => number;
+/**
+ * Effort values safe to send as an explicit Anthropic `output_config.effort`.
+ *
+ * "max" is deliberately absent: upstream it is model-gated (only the newest
+ * Opus exposes it), while the providers that do accept it — GLM and other
+ * Anthropic-compatible endpoints — already resolve a bare enabled thinking
+ * block to their own max tier. Sending it would risk a 400 without buying
+ * anything, so max rides on the thinking budget instead.
+ */
+export declare const ANTHROPIC_EFFORT_LEVELS: ThinkLevel[];
+/**
+ * Alias table for effort values seen in the wild, normalized onto the unified
+ * ladder. Mirrors what Anthropic-compatible providers publish (GLM documents
+ * minimal|light|low → low, medium|high → high, xhigh|max|ultra → max).
+ */
+export declare const EFFORT_ALIASES: Record<string, ThinkLevel>;
+/**
+ * Normalize a client- or config-supplied effort value onto the unified ladder.
+ * Unknown strings return undefined so callers can keep them verbatim on
+ * endpoints that accept free-form values (OpenAI-style `reasoning_effort`).
+ */
+export declare const normalizeEffort: (raw: unknown) => ThinkLevel | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wengine-ai/llms",
-  "version": "2.3.2404",
+  "version": "2.3.2406",
   "description": "A universal LLM API transformation server",
   "main": "dist/cjs/server.cjs",
   "module": "dist/esm/server.mjs",
@@ -52,7 +52,7 @@
     "uuid": "^11.1.0",
     "@fastify/multipart": "^9.0.0",
     "@fastify/static": "^8.2.0",
-    "@wengine-ai/claude-code-router-shared": "^2.3.2404",
+    "@wengine-ai/claude-code-router-shared": "^2.3.2406",
     "adm-zip": "^0.5.16",
     "better-sqlite3": "^12.10.0",
     "rotating-file-stream": "^3.2.7"