@jsonstudio/llms 0.6.1449 → 0.6.1643

package/dist/conversion/compat/profiles/anthropic-claude-code.json

@@ -0,0 +1,17 @@
+{
+  "id": "anthropic:claude-code",
+  "protocol": "anthropic-messages",
+  "request": {
+    "mappings": [
+      { "action": "snapshot", "phase": "compat-pre" },
+      {
+        "action": "anthropic_claude_code_system_prompt",
+        "config": { "preserveExistingSystemAsUserMessage": true }
+      },
+      { "action": "snapshot", "phase": "compat-post" }
+    ]
+  },
+  "response": {
+    "mappings": []
+  }
+}

package/dist/conversion/compat/profiles/chat-gemini-cli.json

@@ -5,6 +5,7 @@
     "mappings": [
       { "action": "snapshot", "phase": "compat-pre" },
       { "action": "claude_thinking_tool_schema" },
+      { "action": "antigravity_thought_signature_prepare" },
       { "action": "gemini_cli_request_wrap" },
       {
         "action": "shallow_pick",

package/dist/conversion/hub/operation-table/semantic-mappers/gemini-mapper.js

@@ -6,6 +6,7 @@ import { prepareGeminiToolsForBridge, buildGeminiToolsFromBridge } from '../../.
 import { ensureProtocolState, getProtocolState } from '../../../shared/protocol-state.js';
 import { sanitizeReasoningTaggedText } from '../../../shared/reasoning-utils.js';
 import { applyClaudeThinkingToolSchemaCompat } from '../../../compat/actions/claude-thinking-tools.js';
+import { extractAntigravityGeminiSessionId } from '../../../compat/antigravity-session-signature.js';
 const GENERATION_CONFIG_KEYS = [
     { source: 'temperature', target: 'temperature' },
     { source: 'topP', target: 'top_p' },
@@ -660,23 +661,25 @@ function buildGeminiRequestFromChat(chat, metadata) {
     const isAntigravityProvider = providerIdPrefix === 'antigravity';
     const isGeminiCliProvider = providerIdPrefix === 'gemini-cli';
     const requiresThoughtSignature = isAntigravityProvider || isGeminiCliProvider;
+    const parameters = chat.parameters && typeof chat.parameters === 'object' ? chat.parameters : {};
     const isAntigravityClaudeThinking = providerIdPrefix === 'antigravity' &&
-        typeof chat.parameters?.model === 'string' &&
-        chat.parameters.model.includes('claude-sonnet-4-5-thinking');
-    const keepReasoning = Boolean(chat.parameters.keep_thinking) ||
-        Boolean(chat.parameters.keep_reasoning);
+        typeof parameters.model === 'string' &&
+        String(parameters.model).includes('claude-sonnet-4-5-thinking');
+    const keepReasoning = Boolean(parameters.keep_thinking) ||
+        Boolean(parameters.keep_reasoning);
     const stripReasoningTags = isAntigravityProvider &&
-        typeof chat.parameters?.model === 'string' &&
-        chat.parameters.model.startsWith('claude-') &&
+        typeof parameters.model === 'string' &&
+        String(parameters.model).startsWith('claude-') &&
         !keepReasoning;
     // Cloud Code / Antigravity requires stable tool call IDs in context (maps to tool_use.id),
     // while standard Gemini endpoints do not require (and may reject) extra id fields.
     const includeToolCallIds = providerIdPrefix === 'antigravity';
     // Function calling protocol:
-    // - For gemini-cli.* we keep a conservative path (text-only tool transcripts).
+    // - For gemini-cli.* we allow structured tool loops when tools are present (Codex/agent clients),
+    //   otherwise keep a conservative path (text-only tool transcripts).
     // - For antigravity.* and other Gemini backends, send tool schemas and emit functionCall/functionResponse parts
     //   so tool loops remain structured and recoverable.
-    const allowFunctionCallingProtocol = providerIdPrefix !== 'gemini-cli';
+    const allowFunctionCallingProtocol = providerIdPrefix !== 'gemini-cli' || (Array.isArray(chat.tools) && chat.tools.length > 0);
     const omitFunctionCallPartsForCli = !allowFunctionCallingProtocol;
     const semanticsNode = readGeminiSemantics(chat);
     const systemTextBlocksFromSemantics = readSystemTextBlocksFromSemantics(chat);
@@ -959,12 +962,27 @@ function buildGeminiRequestFromChat(chat, metadata) {
         }
         deepCleanUndefined(requestPayload);
         const mappedLower = String(requestPayload.model || '').toLowerCase();
+        const isFlashModel = mappedLower.includes('flash');
         const isImageModel = config.requestType === 'image_gen' || mappedLower.includes('image');
         const isThinkingModel = !isImageModel && (mappedLower.includes('think') || mappedLower.includes('pro'));
         if (isThinkingModel && (!requestPayload.generationConfig || !isJsonObject(requestPayload.generationConfig))) {
             requestPayload.generationConfig = {};
         }
         const generationConfig = requestPayload.generationConfig;
+        if (isFlashModel && isJsonObject(generationConfig)) {
+            // Antigravity-Manager alignment: Gemini Flash models reject overly-large thinking budgets.
+            // Clamp proactively to avoid 400 Bad Request when clients set an aggressive budget.
+            const MAX_FLASH_THINKING_BUDGET = 24576;
+            const gc = generationConfig;
+            const thinkingConfigRaw = gc.thinkingConfig;
+            const thinkingConfig = isJsonObject(thinkingConfigRaw) ? thinkingConfigRaw : undefined;
+            const budgetRaw = thinkingConfig && thinkingConfig.thinkingBudget;
+            const budget = typeof budgetRaw === 'number' && Number.isFinite(budgetRaw) ? budgetRaw : undefined;
+            if (thinkingConfig && budget !== undefined && budget > MAX_FLASH_THINKING_BUDGET) {
+                thinkingConfig.thinkingBudget = MAX_FLASH_THINKING_BUDGET;
+                gc.thinkingConfig = thinkingConfig;
+            }
+        }
         if (isThinkingModel && isJsonObject(generationConfig)) {
             const gc = generationConfig;
             const thinkingConfig = isJsonObject(gc.thinkingConfig)
@@ -1061,6 +1079,13 @@ function buildGeminiRequestFromChat(chat, metadata) {
             request.metadata[key] = value;
         }
     }
+    if (isAntigravityProvider) {
+        request.metadata = request.metadata ?? {};
+        const existing = request.metadata.antigravitySessionId;
+        if (typeof existing !== 'string' || !existing.trim()) {
+            request.metadata.antigravitySessionId = extractAntigravityGeminiSessionId(request);
+        }
+    }
     // Apply claude-thinking compat at Gemini mapping time to ensure it is always active
     // for Claude models, regardless of compatibilityProfile wiring. Provider层负责进一步的
     // 传输层收紧（如 session_id / generationConfig），这里不做非标裁剪。

package/dist/conversion/hub/pipeline/compat/compat-pipeline-executor.js

@@ -28,6 +28,9 @@ export function runRequestCompatPipeline(profileId, payload, options) {
     if (!profile) {
         return { payload };
     }
+    if (!isProtocolCompatible(profile, options?.adapterContext)) {
+        return { payload };
+    }
     const stage = pickStageConfig(profile, 'request');
     if (!stage) {
         return { payload };
@@ -49,6 +52,9 @@ export function runResponseCompatPipeline(profileId, payload, options) {
     if (!profile) {
         return { payload };
     }
+    if (!isProtocolCompatible(profile, options?.adapterContext)) {
+        return { payload };
+    }
     const stage = pickStageConfig(profile, 'response');
     if (!stage) {
         return { payload };
@@ -95,6 +101,16 @@ function pickStageConfig(profile, stage) {
     }
     return null;
 }
+function isProtocolCompatible(profile, adapterContext) {
+    const required = typeof profile.protocol === 'string' ? profile.protocol.trim().toLowerCase() : '';
+    if (!required) {
+        return true;
+    }
+    const actual = typeof adapterContext?.providerProtocol === 'string' && adapterContext.providerProtocol.trim()
+        ? adapterContext.providerProtocol.trim().toLowerCase()
+        : '';
+    return Boolean(actual) && actual === required;
+}
 function applyMapping(root, mapping, state) {
     switch (mapping.action) {
         case 'remove':
@@ -221,7 +237,7 @@ function applyMapping(root, mapping, state) {
             break;
         case 'anthropic_claude_code_system_prompt':
             if (state.direction === 'request') {
-                replaceRoot(root, applyAnthropicClaudeCodeSystemPromptCompat(root, mapping.config));
+                replaceRoot(root, applyAnthropicClaudeCodeSystemPromptCompat(root, mapping.config, state.adapterContext));
             }
             break;
         case 'glm_image_content':

package/dist/conversion/hub/pipeline/compat/compat-profile-store.js

@@ -16,10 +16,18 @@ function normalizeProfiles(profiles) {
         if (!id) {
             continue;
         }
-        map.set(id, {
+        const normalized = {
             ...profile,
             id
-        });
+        };
+        // Treat profile IDs as case-insensitive for lookup purposes.
+        // Many configs are hand-authored and may use different casing (e.g. "Chat:Claude-Code"),
+        // while built-in profiles are lower-case.
+        map.set(id, normalized);
+        const lower = id.toLowerCase();
+        if (lower !== id) {
+            map.set(lower, normalized);
+        }
     }
     return map;
 }
@@ -72,5 +80,6 @@ export function getCompatProfile(profileId) {
     if (!profileMap) {
         profileMap = buildProfileMap();
     }
-    return profileMap.get(profileId.trim()) ?? null;
+    const key = profileId.trim();
+    return profileMap.get(key) ?? profileMap.get(key.toLowerCase()) ?? null;
 }

package/dist/conversion/hub/pipeline/hub-pipeline.d.ts

@@ -76,6 +76,7 @@ export declare class HubPipeline {
     private readonly routerEngine;
     private config;
     private unsubscribeProviderErrors?;
+    private unsubscribeProviderSuccess?;
     constructor(config: HubPipelineConfig);
     updateRuntimeDeps(deps: {
         healthStore?: HubPipelineConfig['healthStore'] | null;

package/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -2,6 +2,7 @@ import { Readable } from 'node:stream';
 import { isJsonObject, jsonClone } from '../types/json.js';
 import { VirtualRouterEngine } from '../../../router/virtual-router/engine.js';
 import { providerErrorCenter } from '../../../router/virtual-router/error-center.js';
+import { providerSuccessCenter } from '../../../router/virtual-router/success-center.js';
 import { defaultSseCodecRegistry } from '../../../sse/index.js';
 import { ResponsesFormatAdapter } from '../format-adapters/responses-format-adapter.js';
 import { ResponsesSemanticMapper } from '../semantic-mappers/responses-mapper.js';
@@ -111,6 +112,7 @@ export class HubPipeline {
     routerEngine;
     config;
     unsubscribeProviderErrors;
+    unsubscribeProviderSuccess;
     constructor(config) {
         this.config = config;
         this.routerEngine = new VirtualRouterEngine({
@@ -133,6 +135,19 @@ export class HubPipeline {
         catch {
             this.unsubscribeProviderErrors = undefined;
         }
+        try {
+            this.unsubscribeProviderSuccess = providerSuccessCenter.subscribe((event) => {
+                try {
+                    this.routerEngine.handleProviderSuccess(event);
+                }
+                catch {
+                    // ignore subscriber errors
+                }
+            });
+        }
+        catch {
+            this.unsubscribeProviderSuccess = undefined;
+        }
     }
     updateRuntimeDeps(deps) {
         if (!deps || typeof deps !== 'object') {
@@ -175,6 +190,15 @@ export class HubPipeline {
             }
             this.unsubscribeProviderErrors = undefined;
         }
+        if (this.unsubscribeProviderSuccess) {
+            try {
+                this.unsubscribeProviderSuccess();
+            }
+            catch {
+                // ignore dispose failures
+            }
+            this.unsubscribeProviderSuccess = undefined;
+        }
     }
     async executeRequestStagePipeline(normalized, hooks) {
         const formatAdapter = hooks.createFormatAdapter();

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/index.js

@@ -1,5 +1,6 @@
 import { chatEnvelopeToStandardized } from '../../../../standardized-bridge.js';
 import { validateChatEnvelope } from '../../../../../shared/chat-envelope-validator.js';
+import { buildAnthropicToolAliasMap } from '../../../../../shared/anthropic-message-utils.js';
 import { applyHubOperationTableInbound } from '../../../../operation-table/operation-table-runner.js';
 import { recordStage } from '../../../stages/utils.js';
 import { isJsonObject, jsonClone } from '../../../../types/json.js';
@@ -27,6 +28,25 @@ export async function runReqInboundStage2SemanticMap(options) {
         if (rawTools.length && toolsNode.clientToolsRaw === undefined) {
             toolsNode.clientToolsRaw = jsonClone(rawTools);
         }
+        // /v1/messages tool names are case-sensitive to the client (e.g. Bash/Glob/Read).
+        // Capture an alias map here (from the *raw* client tools) so later response remap
+        // can convert canonical tool calls (e.g. shell_command/glob/read) back to the
+        // original client tool names.
+        try {
+            const protocol = String(options.formatEnvelope?.protocol || '').toLowerCase();
+            const endpoint = String(options.adapterContext?.entryEndpoint || '').toLowerCase();
+            const shouldCapture = protocol === 'anthropic-messages' || endpoint.includes('/v1/messages');
+            const hasAliasMap = isJsonObject(toolsNode.toolNameAliasMap) || isJsonObject(toolsNode.toolAliasMap);
+            if (shouldCapture && !hasAliasMap && rawTools.length) {
+                const aliasMap = buildAnthropicToolAliasMap(rawTools);
+                if (aliasMap) {
+                    toolsNode.toolNameAliasMap = jsonClone(aliasMap);
+                }
+            }
+        }
+        catch {
+            // best-effort: never block request handling due to alias map propagation failures
+        }
         if (options.responsesResume && isJsonObject(options.responsesResume)) {
             if (!semantics.responses || !isJsonObject(semantics.responses)) {
                 semantics.responses = {};

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js

@@ -1,5 +1,7 @@
+import { isJsonObject, jsonClone } from '../../../../types/json.js';
 import { buildAnthropicResponseFromChat } from '../../../../response/response-runtime.js';
 import { buildResponsesPayloadFromChat } from '../../../../../responses/responses-openai-bridge.js';
+import { buildAnthropicToolAliasMap } from '../../../../../shared/anthropic-message-utils.js';
 import { recordStage } from '../../../stages/utils.js';
 export function runRespOutboundStage1ClientRemap(options) {
     let clientPayload;
@@ -18,6 +20,16 @@ export function runRespOutboundStage1ClientRemap(options) {
             ...(toolsRaw ? { toolsRaw } : {})
         });
     }
+    // Preserve upstream error envelope when present (used by host status mapping + servertool auto flows).
+    try {
+        const err = options.payload.error;
+        if (isJsonObject(err)) {
+            clientPayload.error = jsonClone(err);
+        }
+    }
+    catch {
+        // best-effort
+    }
     recordStage(options.stageRecorder, 'chat_process.resp.stage9.client_remap', clientPayload);
     return clientPayload;
 }
@@ -29,7 +41,20 @@ function resolveAliasMapFromSemantics(semantics) {
     if (!toolsNode || typeof toolsNode !== 'object' || Array.isArray(toolsNode)) {
         return undefined;
     }
-    const candidate = toolsNode.toolNameAliasMap;
+    const toolsRecord = toolsNode;
+    // Prefer explicit alias map.
+    const candidate = toolsRecord.toolNameAliasMap;
+    const fromCandidate = normalizeAliasMap(candidate);
+    if (fromCandidate) {
+        return fromCandidate;
+    }
+    // Fallback: derive from captured raw client tools if present.
+    // This covers callers that captured `clientToolsRaw` but did not persist `toolNameAliasMap`.
+    const rawTools = toolsRecord.clientToolsRaw;
+    const derived = buildAnthropicToolAliasMap(rawTools);
+    return normalizeAliasMap(derived);
+}
+function normalizeAliasMap(candidate) {
     if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
         return undefined;
     }