@jsonstudio/llms 0.6.1892 → 0.6.2172

package/dist/conversion/compat/actions/tool-text-request-guidance.js

@@ -0,0 +1,177 @@
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function readString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function collectToolNames(toolsRaw) {
+    const out = [];
+    if (!Array.isArray(toolsRaw)) {
+        return out;
+    }
+    for (const item of toolsRaw) {
+        if (!isRecord(item))
+            continue;
+        const fn = isRecord(item.function) ? item.function : item;
+        const name = readString(fn.name);
+        if (!name)
+            continue;
+        if (!out.includes(name)) {
+            out.push(name);
+        }
+    }
+    return out;
+}
+function isToolChoiceRequired(root) {
+    const toolChoice = root.tool_choice;
+    if (typeof toolChoice === 'string') {
+        const normalized = toolChoice.trim().toLowerCase();
+        if (normalized === 'required')
+            return true;
+        if (normalized === 'auto' || normalized === 'none')
+            return false;
+    }
+    if (isRecord(toolChoice)) {
+        return String(toolChoice.type || '').trim().toLowerCase() === 'function';
+    }
+    return false;
+}
+function buildDefaultInstruction(root, config) {
+    const toolNames = collectToolNames(root.tools);
+    const includeToolNames = config?.includeToolNames !== false;
+    const required = isToolChoiceRequired(root);
+    const marker = readString(config?.marker) || 'Tool-call output contract (STRICT)';
+    const lines = [
+        `${marker}:`,
+        '1) If calling tools, output exactly one JSON object: {"tool_calls":[{"name":"tool_name","input":{...}}]}',
+        '2) Use only keys: `tool_calls` + each call `name` and `input`.',
+        '3) Do not output markdown fences, prose, or tool transcripts around JSON.',
+        '4) Do NOT output pseudo tool results in text (forbidden examples: {"exec_command":...}, <function_results>...</function_results>).'
+    ];
+    if (includeToolNames && toolNames.length) {
+        lines.push(`5) Allowed tool names this turn: ${toolNames.join(', ')}`);
+    }
+    else {
+        lines.push('5) Tool name must match provided schema exactly.');
+    }
+    lines.push(required
+        ? '6) tool_choice is required for this turn: return at least one tool call.'
+        : '6) If no tool is needed, plain text is allowed.');
+    return lines.join('\n');
+}
+function ensureSystemMessage(messages) {
+    const first = messages[0];
+    if (isRecord(first) && readString(first.role).toLowerCase() === 'system') {
+        return first;
+    }
+    const created = { role: 'system', content: '' };
+    messages.unshift(created);
+    return created;
+}
+function contentToText(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const part of content) {
+            if (typeof part === 'string') {
+                parts.push(part);
+                continue;
+            }
+            if (!isRecord(part))
+                continue;
+            const text = readString(part.text) || readString(part.content);
+            if (text)
+                parts.push(text);
+        }
+        return parts.join('\n').trim();
+    }
+    if (isRecord(content)) {
+        const text = readString(content.text) || readString(content.content);
+        if (text) {
+            return text;
+        }
+        if (Array.isArray(content.content)) {
+            return contentToText(content.content);
+        }
+    }
+    return '';
+}
+function contentHasMarker(content, marker) {
+    if (!marker) {
+        return false;
+    }
+    const text = contentToText(content);
+    return text.includes(marker);
+}
+function appendInstructionToContent(content, instruction) {
+    if (typeof content === 'string') {
+        return content.trim() ? `${content}\n\n${instruction}` : instruction;
+    }
+    if (Array.isArray(content)) {
+        return [
+            ...content,
+            {
+                type: 'text',
+                text: content.length ? `\n\n${instruction}` : instruction
+            }
+        ];
+    }
+    if (isRecord(content)) {
+        if (typeof content.text === 'string') {
+            const previous = content.text;
+            return {
+                ...content,
+                text: previous.trim() ? `${previous}\n\n${instruction}` : instruction
+            };
+        }
+        if (typeof content.content === 'string') {
+            const previous = content.content;
+            return {
+                ...content,
+                content: previous.trim() ? `${previous}\n\n${instruction}` : instruction
+            };
+        }
+        if (Array.isArray(content.content)) {
+            return {
+                ...content,
+                content: appendInstructionToContent(content.content, instruction)
+            };
+        }
+        return [content, { type: 'text', text: instruction }];
+    }
+    return instruction;
+}
+export function applyToolTextRequestGuidance(payload, config) {
+    const enabled = config?.enabled !== false;
+    if (!enabled) {
+        return payload;
+    }
+    const root = structuredClone(payload);
+    const requireTools = config?.requireTools !== false;
+    if (requireTools) {
+        const tools = Array.isArray(root.tools) ? root.tools : [];
+        if (!tools.length) {
+            return root;
+        }
+    }
+    if (!Array.isArray(root.messages)) {
+        return root;
+    }
+    const messages = root.messages.filter((item) => isRecord(item));
+    if (!messages.length) {
+        return root;
+    }
+    const instruction = readString(config?.instruction) || buildDefaultInstruction(root, config);
+    if (!instruction) {
+        return root;
+    }
+    const marker = readString(config?.marker) || 'Tool-call output contract (STRICT)';
+    const system = ensureSystemMessage(messages);
+    if (contentHasMarker(system.content, marker)) {
+        root.messages = messages;
+        return root;
+    }
+    system.content = appendInstructionToContent(system.content, instruction);
+    root.messages = messages;
+    return root;
+}

package/dist/conversion/compat/antigravity-session-signature.d.ts

@@ -34,6 +34,12 @@ export declare function lookupAntigravityPinnedAliasForSessionId(sessionIdInput:
     hydrate?: boolean;
 }): string | undefined;
 export declare function unpinAntigravitySessionAliasForSessionId(sessionIdInput: string): void;
+export declare function clearAntigravitySessionAliasPins(options?: {
+    hydrate?: boolean;
+}): {
+    clearedBySession: number;
+    clearedByAlias: number;
+};
 export declare function getAntigravitySessionSignature(aliasKey: string, sessionId: string): string | undefined;
 export declare function getAntigravitySessionSignature(sessionId: string): string | undefined;
 export type AntigravityThoughtSignatureLookupSource = 'session_cache' | 'miss' | 'blocked_unknown_alias' | 'blocked_rewind' | 'expired';

package/dist/conversion/compat/antigravity-session-signature.js

@@ -881,6 +881,21 @@ export function unpinAntigravitySessionAliasForSessionId(sessionIdInput) {
     }
     schedulePersistenceFlush();
 }
+export function clearAntigravitySessionAliasPins(options) {
+    const allowHydrate = options?.hydrate !== false;
+    if (allowHydrate) {
+        hydrateSignaturesFromDiskIfNeeded(true);
+    }
+    const clearedBySession = pinnedAliasBySession.size;
+    const clearedByAlias = pinnedSessionByAlias.size;
+    if (clearedBySession === 0 && clearedByAlias === 0) {
+        return { clearedBySession: 0, clearedByAlias: 0 };
+    }
+    pinnedAliasBySession.clear();
+    pinnedSessionByAlias.clear();
+    schedulePersistenceFlush();
+    return { clearedBySession, clearedByAlias };
+}
 export function getAntigravitySessionSignature(a, b) {
     return getAntigravitySessionSignatureEntry(a, b)?.signature;
 }

package/dist/conversion/compat/profiles/chat-deepseek-web.json

@@ -4,6 +4,14 @@
   "request": {
     "mappings": [
       { "action": "snapshot", "phase": "compat-pre" },
+      {
+        "action": "tool_text_request_guidance",
+        "config": {
+          "marker": "Tool-call output contract (STRICT)",
+          "includeToolNames": true,
+          "requireTools": true
+        }
+      },
       { "action": "deepseek_web_request" },
       { "action": "snapshot", "phase": "compat-post" }
     ]
@@ -11,7 +19,50 @@
   "response": {
     "mappings": [
       { "action": "snapshot", "phase": "compat-pre" },
-      { "action": "deepseek_web_response" },
+      {
+        "action": "deepseek_web_response",
+        "config": {
+          "textNormalizer": {
+            "jsonToolRepair": {
+              "toolNameAliases": {
+                "shell_command": "exec_command",
+                "shell": "exec_command",
+                "bash": "exec_command",
+                "terminal": "exec_command"
+              },
+              "argumentAliases": {
+                "exec_command": {
+                  "cmd": ["cmd", "command", "input.command", "script"],
+                  "command": ["cmd", "command", "input.command", "script"],
+                  "workdir": ["workdir", "cwd", "input.cwd"]
+                }
+              }
+            }
+          }
+        }
+      },
+      {
+        "action": "harvest_tool_calls_from_text",
+        "config": {
+          "normalizer": {
+            "jsonToolRepair": {
+              "toolNameAliases": {
+                "shell_command": "exec_command",
+                "shell": "exec_command",
+                "bash": "exec_command",
+                "terminal": "exec_command"
+              },
+              "argumentAliases": {
+                "exec_command": {
+                  "cmd": ["cmd", "command", "input.command", "script"],
+                  "command": ["cmd", "command", "input.command", "script"],
+                  "workdir": ["workdir", "cwd", "input.cwd"]
+                }
+              }
+            }
+          }
+        }
+      },
       { "action": "snapshot", "phase": "compat-post" }
     ]
   }

package/dist/conversion/compat/profiles/chat-glm.json

@@ -196,6 +196,28 @@
       { "action": "tool_schema_sanitize", "mode": "glm_shell" },
       { "action": "response_normalize" },
       { "action": "extract_glm_tool_markup" },
+      {
+        "action": "harvest_tool_calls_from_text",
+        "config": {
+          "normalizer": {
+            "jsonToolRepair": {
+              "toolNameAliases": {
+                "shell_command": "exec_command",
+                "shell": "exec_command",
+                "bash": "exec_command",
+                "terminal": "exec_command"
+              },
+              "argumentAliases": {
+                "exec_command": {
+                  "cmd": ["cmd", "command", "input.command", "script"],
+                  "command": ["cmd", "command", "input.command", "script"],
+                  "workdir": ["workdir", "cwd", "input.cwd"]
+                }
+              }
+            }
+          }
+        }
+      },
       { "action": "response_validate" },
       { "action": "snapshot", "phase": "compat-post" },
       { "action": "dto_rewrap" }

package/dist/conversion/compat/profiles/chat-iflow.json

@@ -106,6 +106,10 @@
         ]
       },
       { "action": "tool_schema_sanitize", "mode": "glm_shell" },
+      {
+        "action": "iflow_tool_text_fallback",
+        "models": ["minimax-m2.5"]
+      },
       {
         "action": "iflow_web_search_request"
       },

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

@@ -50,7 +50,9 @@ const ANTIGRAVITY_DEFAULT_SAFETY_SETTINGS = [
 const ANTIGRAVITY_NETWORK_TOOL_NAMES = new Set([
     'google_search',
     'google_search_retrieval',
-    'web_search'
+    'web_search',
+    'web_search_20250305',
+    'websearch'
 ]);
 function stripTierSuffix(model) {
     return model.replace(/-(minimal|low|medium|high)$/i, '');
@@ -71,7 +73,11 @@ function normalizePreviewAlias(model) {
     }
 }
 function isNetworkingToolName(name) {
-    return ANTIGRAVITY_NETWORK_TOOL_NAMES.has(name);
+    const normalized = typeof name === 'string' ? name.trim().toLowerCase() : '';
+    if (!normalized) {
+        return false;
+    }
+    return ANTIGRAVITY_NETWORK_TOOL_NAMES.has(normalized);
 }
 function detectsNetworkingTool(tools) {
     if (!Array.isArray(tools))
@@ -118,25 +124,6 @@ function hasFunctionDeclarations(tools) {
         return Array.isArray(record.functionDeclarations) && record.functionDeclarations.length > 0;
     });
 }
-function hasNonNetworkingFunctionDeclarations(tools) {
-    if (!Array.isArray(tools))
-        return false;
-    for (const tool of tools) {
-        if (!tool || typeof tool !== 'object')
-            continue;
-        const record = tool;
-        const decls = Array.isArray(record.functionDeclarations)
-            ? record.functionDeclarations
-            : [];
-        for (const decl of decls) {
-            const name = typeof decl?.name === 'string' ? String(decl.name) : '';
-            if (name && !isNetworkingToolName(name)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
 function injectGoogleSearchTool(request) {
     const toolsRaw = request.tools;
     if (!Array.isArray(toolsRaw)) {
@@ -285,13 +272,12 @@ function resolveAntigravityRequestConfig(options) {
             imageConfig: parsed.imageConfig
         };
     }
-    // Gemini v1internal constraint (Antigravity manager alignment):
-    // - "web_search" requests must NOT mix googleSearch with functionDeclarations.
-    // - If the request includes any non-networking function declarations (e.g. MCP/local tools),
-    //   we must disable networking and keep the request as "agent" to avoid upstream schema errors.
+    // Antigravity-Manager alignment:
+    // - networking intent is decided only by explicit signals (-online suffix or networking tools).
+    // - googleSearch injection is handled later by injectGoogleSearchTool(), which will skip injection
+    //   when functionDeclarations exist to avoid mixed-tool schema conflicts.
     const wantsNetworking = original.endsWith('-online') || detectsNetworkingTool(options.tools);
-    const hasLocalFunctions = hasNonNetworkingFunctionDeclarations(options.tools);
-    const enableNetworking = wantsNetworking && !hasLocalFunctions;
+    const enableNetworking = wantsNetworking;
     let finalModel = stripOnlineSuffix(mapped);
     finalModel = normalizePreviewAlias(finalModel);
     // Only gemini-2.5-flash reliably supports googleSearch in v1internal; downgrade for networking.

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

@@ -509,7 +509,7 @@ export class ResponsesSemanticMapper {
         // causes providers like FAI to reject the request (HTTP 400). Any actual
         // submit_tool_outputs call should be issued via the dedicated endpoint
         // upstream, not through this mapper.
-        return {
+        const result = {
             protocol: 'openai-responses',
             direction: 'response',
             payload: responses,
@@ -517,5 +517,14 @@ export class ResponsesSemanticMapper {
                 context: ctx
             }
         };
+        // Some responses providers (e.g. TAB) reject sampling knobs with HTTP 400.
+        // Filter these at mapper outbound so they never reach openai-responses providers.
+        const unsupportedParams = ['temperature', 'top_p', 'seed', 'logit_bias'];
+        for (const key of unsupportedParams) {
+            if (key in result.payload) {
+                delete result.payload[key];
+            }
+        }
+        return result;
     }
 }

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

@@ -28,10 +28,11 @@ import { prepareAntigravityThoughtSignatureForGeminiRequest } from '../../../com
 import { cacheAntigravityThoughtSignatureFromGeminiResponse } from '../../../compat/actions/antigravity-thought-signature-cache.js';
 import { applyAnthropicClaudeCodeSystemPromptCompat } from '../../../compat/actions/anthropic-claude-code-system-prompt.js';
 import { normalizeToolCallIdsInPlace } from '../../../compat/actions/normalize-tool-call-ids.js';
-import { harvestToolCallsFromText } from '../../../compat/actions/harvest-tool-calls-from-text.js';
+import { harvestToolCallsFromTextWithConfig } from '../../../compat/actions/harvest-tool-calls-from-text.js';
 import { stripOrphanFunctionCallsTag } from '../../../compat/actions/strip-orphan-function-calls-tag.js';
 import { stringifyLmstudioResponsesInput } from '../../../compat/actions/lmstudio-responses-input-stringify.js';
 import { enforceLmstudioResponsesFcToolCallIds } from '../../../compat/actions/lmstudio-responses-fc-ids.js';
+import { applyToolTextRequestGuidance } from '../../../compat/actions/tool-text-request-guidance.js';
 const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
 const INTERNAL_STATE = Symbol('compat.internal_state');
 export function runRequestCompatPipeline(profileId, payload, options) {
@@ -180,7 +181,12 @@ function applyMapping(root, mapping, state) {
             break;
         case 'harvest_tool_calls_from_text':
             if (state.direction === 'response') {
-                replaceRoot(root, harvestToolCallsFromText(root));
+                replaceRoot(root, harvestToolCallsFromTextWithConfig(root, mapping.config));
+            }
+            break;
+        case 'tool_text_request_guidance':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyToolTextRequestGuidance(root, mapping.config));
             }
             break;
         case 'strip_orphan_function_calls_tag':
@@ -261,7 +267,10 @@ function applyMapping(root, mapping, state) {
             break;
         case 'iflow_tool_text_fallback':
             if (state.direction === 'request') {
-                replaceRoot(root, applyIflowToolTextFallback(root, { models: mapping.models }));
+                replaceRoot(root, applyIflowToolTextFallback(root, {
+                    models: mapping.models,
+                    routeId: typeof state.adapterContext?.routeId === 'string' ? state.adapterContext.routeId : undefined
+                }));
             }
             break;
         case 'iflow_response_body_unwrap':
@@ -276,7 +285,7 @@ function applyMapping(root, mapping, state) {
             break;
         case 'deepseek_web_response':
             if (state.direction === 'response') {
-                replaceRoot(root, applyDeepSeekWebResponseTransform(root, state.adapterContext));
+                replaceRoot(root, applyDeepSeekWebResponseTransform(root, state.adapterContext, mapping.config));
             }
             break;
         case 'claude_thinking_tool_schema':

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

@@ -1,10 +1,3 @@
-const PROFILE_BY_PROVIDER_FAMILY = {
-    iflow: 'chat:iflow',
-    lmstudio: 'chat:lmstudio',
-    deepseek: 'chat:deepseek-web',
-    antigravity: 'chat:gemini-cli',
-    'gemini-cli': 'chat:gemini-cli'
-};
 function readNonEmptyString(value) {
     if (typeof value !== 'string') {
         return undefined;
@@ -12,53 +5,8 @@ function readNonEmptyString(value) {
     const trimmed = value.trim();
     return trimmed.length ? trimmed : undefined;
 }
-function normalizeProviderFamily(value) {
-    const normalized = readNonEmptyString(value)?.toLowerCase();
-    if (!normalized) {
-        return undefined;
-    }
-    if (normalized in PROFILE_BY_PROVIDER_FAMILY) {
-        return normalized;
-    }
-    if (normalized.includes('.')) {
-        const firstToken = normalized.split('.')[0]?.trim();
-        if (firstToken && firstToken in PROFILE_BY_PROVIDER_FAMILY) {
-            return firstToken;
-        }
-    }
-    if (normalized.includes(':')) {
-        const firstToken = normalized.split(':')[0]?.trim();
-        if (firstToken && firstToken in PROFILE_BY_PROVIDER_FAMILY) {
-            return firstToken;
-        }
-    }
-    if (normalized.includes('/')) {
-        const firstToken = normalized.split('/')[0]?.trim();
-        if (firstToken && firstToken in PROFILE_BY_PROVIDER_FAMILY) {
-            return firstToken;
-        }
-    }
-    return undefined;
-}
-function resolveDefaultProfileFromFamily(adapterContext) {
-    const context = adapterContext;
-    const providerFamily = normalizeProviderFamily(context.providerFamily);
-    if (providerFamily) {
-        return PROFILE_BY_PROVIDER_FAMILY[providerFamily];
-    }
-    for (const key of ['providerId', 'providerKey', 'runtimeKey', 'profileId', 'providerType']) {
-        const family = normalizeProviderFamily(context[key]);
-        if (family) {
-            return PROFILE_BY_PROVIDER_FAMILY[family];
-        }
-    }
-    return undefined;
-}
 export function resolveCompatProfileForContext(adapterContext) {
     const context = adapterContext;
     const explicit = readNonEmptyString(context.compatibilityProfile);
-    if (explicit) {
-        return explicit;
-    }
-    return resolveDefaultProfileFromFamily(adapterContext);
+    return explicit;
 }

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

@@ -6,6 +6,9 @@ import type { RequestRulesConfig } from '../../../compat/actions/request-rules.j
 import type { AutoThinkingConfig } from '../../../compat/actions/auto-thinking.js';
 import type { ResponseNormalizeConfig } from '../../../compat/actions/response-normalize.js';
 import type { ResponseValidateConfig } from '../../../compat/actions/response-validate.js';
+import type { HarvestToolCallsFromTextConfig } from '../../../compat/actions/harvest-tool-calls-from-text.js';
+import type { ToolTextRequestGuidanceConfig } from '../../../compat/actions/tool-text-request-guidance.js';
+import type { DeepSeekWebResponseConfig } from '../../../compat/actions/deepseek-web-response.js';
 export type CompatDirection = 'request' | 'response';
 export interface CompatProfileConfig {
     id: string;
@@ -77,6 +80,10 @@ export type MappingInstruction = {
     action: 'extract_glm_tool_markup';
 } | {
     action: 'harvest_tool_calls_from_text';
+    config?: HarvestToolCallsFromTextConfig;
+} | {
+    action: 'tool_text_request_guidance';
+    config?: ToolTextRequestGuidanceConfig;
 } | {
     action: 'strip_orphan_function_calls_tag';
 } | {
@@ -136,6 +143,7 @@ export type MappingInstruction = {
     action: 'deepseek_web_request';
 } | {
     action: 'deepseek_web_response';
+    config?: DeepSeekWebResponseConfig;
 } | {
     action: 'claude_thinking_tool_schema';
 } | {

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

@@ -1250,11 +1250,15 @@ export class HubPipeline {
         const providerId = (target?.providerKey || metadata.providerKey);
         const routeId = metadata.routeName;
         const profileId = (target?.providerKey || metadata.pipelineId);
-        const compatibilityProfile = typeof target?.compatibilityProfile === 'string' && target.compatibilityProfile.trim()
+        const targetCompatProfile = typeof target?.compatibilityProfile === 'string' && target.compatibilityProfile.trim()
             ? target.compatibilityProfile.trim()
-            : typeof metadata.compatibilityProfile === 'string'
-                ? String(metadata.compatibilityProfile).trim()
-                : undefined;
+            : undefined;
+        const metadataCompatProfile = typeof metadata.compatibilityProfile === 'string'
+            ? String(metadata.compatibilityProfile).trim()
+            : undefined;
+        // When routing has already selected a target runtime, compat must be target-scoped only.
+        // Never inherit stale top-level metadata.compatibilityProfile from a previous hop.
+        const compatibilityProfile = target ? targetCompatProfile : metadataCompatProfile;
         const streamingHint = normalized.stream === true ? 'force' : normalized.stream === false ? 'disable' : 'auto';
         const toolCallIdStyle = normalizeToolCallIdStyleCandidate(metadata.toolCallIdStyle);
         const adapterContext = {