@wengine-ai/llms 2.3.2403 → 2.3.2405

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

@@ -0,0 +1,39 @@
+import { UnifiedChatRequest } from "../types/llm";
+import { Transformer, TransformerOptions } from "../types/transformer";
+export type DefaultThinkingLevel = "none" | "low" | "medium" | "high";
+type EndpointKind = "anthropic" | "responses" | "chat";
+/**
+ * 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 level is converted to whatever parameter the provider's endpoint
+ * speaks:
+ * - Anthropic /v1/messages: unified `reasoning` (converted to the Anthropic
+ *   `thinking` block by convertToAnthropic)
+ * - OpenAI /v1/responses: unified `reasoning` (mapped to `reasoning.effort`
+ *   by OpenAIResponsesTransformer)
+ * - OpenAI-compatible /v1/chat/completions: `reasoning_effort`
+ *
+ * Client intent always wins: any defined `request.reasoning` — including an
+ * explicit disabled — skips injection entirely. `level: "none"` (or an
+ * unknown 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/transformer/opencode.transformer.d.ts

@@ -25,12 +25,27 @@ import { Transformer, TransformerOptions } from "../types/transformer";
  *   thinking format expected by Claude Code.
  * - Replaces purely-numeric tool_call IDs with UUID-based IDs to avoid
  *   downstream parsing issues.
+ * - Sends a stable x-opencode-session header. OpenCode Go rejects requests
+ *   without it (400 MissingSessionID) and uses the value for routing and
+ *   prompt caching, so it must stay constant for the whole conversation —
+ *   reusing the coding agent's own session id is the intended usage.
  */
 export declare class OpenCodeTransformer implements Transformer {
     private readonly options?;
     static TransformerName: string;
     endPoint: string;
     constructor(options?: TransformerOptions | undefined);
-    transformRequestIn(request: UnifiedChatRequest): Promise<UnifiedChatRequest>;
+    /**
+     * Resolve a stable per-conversation session id for x-opencode-session.
+     *
+     * Priority: the client's own x-opencode-session header (opencode CLI native),
+     * the session id CCR's client adapter already extracted (Claude Code encodes
+     * it in metadata.user_id), the same value mirrored onto req.sessionId, a
+     * direct extraction from the body's metadata.user_id, and finally the Codex
+     * native session_id header. A per-request UUID is the last resort: it keeps
+     * Go endpoints from 400ing but forfeits their cross-request cache affinity.
+     */
+    private resolveSessionId;
+    transformRequestIn(request: UnifiedChatRequest, provider?: any, context?: Record<string, any>): Promise<Record<string, any>>;
     transformResponseOut(response: Response): Promise<Response>;
 }

package/dist/utils/thinking.d.ts

@@ -1,2 +1,3 @@
 import { ThinkLevel } from "../types/llm";
 export declare const getThinkLevel: (thinking_budget: number) => ThinkLevel;
+export declare const getThinkBudget: (level: ThinkLevel) => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wengine-ai/llms",
-  "version": "2.3.2403",
+  "version": "2.3.2405",
   "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.2403",
+    "@wengine-ai/claude-code-router-shared": "^2.3.2405",
     "adm-zip": "^0.5.16",
     "better-sqlite3": "^12.10.0",
     "rotating-file-stream": "^3.2.7"