@jsonstudio/llms 0.6.3379 → 0.6.3405

package/dist/router/virtual-router/bootstrap/web-search-config.js

@@ -37,6 +37,27 @@ export function normalizeWebSearch(input, routingSource) {
         const resolvedProviderKey = resolveWebSearchEngineProviderKey(providerKey, webSearchRouteTargets) ?? providerKey;
         const description = typeof node.description === 'string' && node.description.trim() ? node.description.trim() : undefined;
         const isDefault = node.default === true || (typeof node.default === 'string' && node.default.trim().toLowerCase() === 'true');
+        const rawExecutionMode = typeof node.executionMode === 'string'
+            ? node.executionMode.trim().toLowerCase()
+            : typeof node.mode === 'string'
+                ? node.mode.trim().toLowerCase()
+                : '';
+        const executionMode = rawExecutionMode === 'direct' ? 'direct' : 'servertool';
+        const rawDirectActivation = typeof node.directActivation === 'string'
+            ? node.directActivation.trim().toLowerCase()
+            : typeof node.activation === 'string'
+                ? node.activation.trim().toLowerCase()
+                : '';
+        const directActivation = rawDirectActivation === 'builtin'
+            ? 'builtin'
+            : rawDirectActivation === 'route'
+                ? 'route'
+                : executionMode === 'direct'
+                    ? 'route'
+                    : undefined;
+        const modelId = typeof node.modelId === 'string' && node.modelId.trim() ? node.modelId.trim() : undefined;
+        const maxUsesRaw = typeof node.maxUses === 'number' ? node.maxUses : Number(node.maxUses);
+        const maxUses = Number.isFinite(maxUsesRaw) && maxUsesRaw > 0 ? Math.floor(maxUsesRaw) : undefined;
         const serverToolsDisabled = node.serverToolsDisabled === true ||
             (typeof node.serverToolsDisabled === 'string' &&
                 node.serverToolsDisabled.trim().toLowerCase() === 'true') ||
@@ -51,6 +72,10 @@ export function normalizeWebSearch(input, routingSource) {
             providerKey: resolvedProviderKey,
             description,
             default: isDefault,
+            executionMode,
+            ...(directActivation ? { directActivation } : {}),
+            ...(modelId ? { modelId } : {}),
+            ...(maxUses ? { maxUses } : {}),
             ...(serverToolsDisabled ? { serverToolsDisabled: true } : {})
         });
     }

package/dist/router/virtual-router/bootstrap.js

@@ -140,26 +140,31 @@ function buildProviderRuntimeEntries(providers) {
     }
     return { runtimeEntries, aliasIndex, modelIndex };
 }
-function collectProviderModels(providerRaw, normalizedProvider) {
+function collectProviderModels(providerRaw, _normalizedProvider) {
     const rawModelsNode = providerRaw.models;
     const modelsDeclared = rawModelsNode !== undefined;
     const modelsNode = asRecord(rawModelsNode);
-    const baseModels = Object.keys(modelsNode).filter(Boolean);
-    if (normalizedProvider.compatibilityProfile !== 'chat:deepseek-web') {
-        return { declared: modelsDeclared, models: baseModels };
-    }
-    const withAliases = new Set(baseModels);
-    const hasChatBase = withAliases.has('deepseek-chat') || withAliases.has('deepseek-v3');
-    const hasReasonerBase = withAliases.has('deepseek-reasoner') || withAliases.has('deepseek-r1');
-    if (hasChatBase) {
-        withAliases.add('deepseek-chat-search');
-        withAliases.add('deepseek-v3-search');
-    }
-    if (hasReasonerBase) {
-        withAliases.add('deepseek-reasoner-search');
-        withAliases.add('deepseek-r1-search');
+    const collected = new Set();
+    for (const [modelName, modelConfigRaw] of Object.entries(modelsNode)) {
+        const normalizedModelName = typeof modelName === 'string' ? modelName.trim() : '';
+        if (normalizedModelName) {
+            collected.add(normalizedModelName);
+        }
+        const modelConfig = asRecord(modelConfigRaw);
+        const aliasesNode = Array.isArray(modelConfig.aliases)
+            ? modelConfig.aliases
+            : [];
+        for (const alias of aliasesNode) {
+            if (typeof alias !== 'string') {
+                continue;
+            }
+            const normalizedAlias = alias.trim();
+            if (normalizedAlias) {
+                collected.add(normalizedAlias);
+            }
+        }
     }
-    return { declared: modelsDeclared, models: Array.from(withAliases) };
+    return { declared: modelsDeclared, models: Array.from(collected) };
 }
 function normalizeClassifier(input) {
     const normalized = asRecord(input);

package/dist/router/virtual-router/engine-selection/native-compat-action-semantics.d.ts

@@ -0,0 +1,6 @@
+export declare function normalizeResponsePayloadWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>): Record<string, unknown>;
+export declare function validateResponsePayloadWithNative(payload: Record<string, unknown>): void;
+export declare function applyRequestRulesWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>): Record<string, unknown>;
+export declare function applyResponseBlacklistWithNative(payload: Record<string, unknown>, config?: Record<string, unknown>): Record<string, unknown>;
+export declare function normalizeToolCallIdsWithNative(payload: Record<string, unknown>): Record<string, unknown>;
+export declare function enforceLmstudioResponsesFcToolCallIdsWithNative(payload: Record<string, unknown>): Record<string, unknown>;

package/dist/router/virtual-router/engine-selection/native-compat-action-semantics.js

@@ -0,0 +1,171 @@
+import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function readNativeFunction(name) {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[name];
+    return typeof fn === 'function' ? fn : null;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseRecord(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeResponsePayloadWithNative(payload, config) {
+    const capability = 'normalizeResponsePayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload);
+    const configJson = config ? safeStringify(config) : '{}';
+    if (!payloadJson || !configJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson, configJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function validateResponsePayloadWithNative(payload) {
+    const capability = 'validateResponsePayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        fn(payloadJson);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        throw new Error(reason);
+    }
+}
+export function applyRequestRulesWithNative(payload, config) {
+    const capability = 'applyRequestRulesJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv())
+        return fail('native disabled');
+    const fn = readNativeFunction(capability);
+    if (!fn)
+        return fail();
+    const payloadJson = safeStringify(payload);
+    const configJson = config ? safeStringify(config) : '{}';
+    if (!payloadJson || !configJson)
+        return fail('json stringify failed');
+    try {
+        const raw = fn(payloadJson, configJson);
+        if (typeof raw !== 'string' || !raw)
+            return fail('empty result');
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function applyResponseBlacklistWithNative(payload, config) {
+    const capability = 'applyResponseBlacklistJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv())
+        return fail('native disabled');
+    const fn = readNativeFunction(capability);
+    if (!fn)
+        return fail();
+    const payloadJson = safeStringify(payload);
+    const configJson = config ? safeStringify(config) : '{}';
+    if (!payloadJson || !configJson)
+        return fail('json stringify failed');
+    try {
+        const raw = fn(payloadJson, configJson);
+        if (typeof raw !== 'string' || !raw)
+            return fail('empty result');
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function normalizeToolCallIdsWithNative(payload) {
+    const capability = 'normalizeToolCallIdsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv())
+        return fail('native disabled');
+    const fn = readNativeFunction(capability);
+    if (!fn)
+        return fail();
+    const payloadJson = safeStringify(payload);
+    if (!payloadJson)
+        return fail('json stringify failed');
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw)
+            return fail('empty result');
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function enforceLmstudioResponsesFcToolCallIdsWithNative(payload) {
+    const capability = 'enforceLmstudioResponsesFcToolCallIdsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv())
+        return fail('native disabled');
+    const fn = readNativeFunction(capability);
+    if (!fn)
+        return fail();
+    const payloadJson = safeStringify(payload);
+    if (!payloadJson)
+        return fail('json stringify failed');
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw)
+            return fail('empty result');
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine-selection/native-router-hotpath-loader.js

@@ -98,6 +98,8 @@ const REQUIRED_NATIVE_EXPORTS = [
     'chatToolToBridgeDefinitionJson',
     'mapBridgeToolsToChatWithOptionsJson',
     'mapChatToolsToBridgeWithOptionsJson',
+    'collectToolCallsFromResponsesJson',
+    'resolveFinishReasonJson',
     'captureReqInboundResponsesContextSnapshotJson',
     'computeQuotaBucketsJson',
     'extractReasoningSegmentsJson',
@@ -167,6 +169,15 @@ const REQUIRED_NATIVE_EXPORTS = [
     'normalizeChatResponseReasoningToolsJson',
     'normalizeBridgeToolCallIdsJson',
     'normalizeChatMessageContentJson',
+    'validateResponsePayloadJson',
+    'normalizeResponsePayloadJson',
+    'applyResponseBlacklistJson',
+    'normalizeToolCallIdsJson',
+    'normalizeResponsesToolCallIdsJson',
+    'resolveToolCallIdStyleJson',
+    'stripInternalToolingMetadataJson',
+    'enforceLmstudioResponsesFcToolCallIdsJson',
+    'applyRequestRulesJson',
     'normalizeArgsBySchemaJson',
     'normalizeToolsJson',
     'normalizeFunctionCallIdJson',

package/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics.d.ts

@@ -26,6 +26,8 @@ export declare function mapBridgeToolsToChatWithNative(rawTools: unknown, option
 export declare function mapChatToolsToBridgeWithNative(rawTools: unknown, options?: {
     sanitizeMode?: string;
 }): Array<Record<string, unknown>>;
+export declare function collectToolCallsFromResponsesWithNative(response: Record<string, unknown>): Array<Record<string, unknown>>;
+export declare function resolveFinishReasonWithNative(response: Record<string, unknown>, toolCalls: Array<Record<string, unknown>>): string;
 export declare function hasValidThoughtSignatureWithNative(block: unknown, options?: Record<string, unknown>): boolean;
 export declare function sanitizeThinkingBlockWithNative(block: unknown): Record<string, unknown>;
 export declare function filterInvalidThinkingBlocksWithNative(messages: unknown, options?: Record<string, unknown>): unknown[];
@@ -49,6 +51,9 @@ export declare function enforceToolCallIdStyleWithNative(messages: unknown[], st
     messages: unknown[];
     state: Record<string, unknown>;
 };
+export declare function normalizeResponsesToolCallIdsWithNative(payload: unknown): Record<string, unknown> | null;
+export declare function resolveToolCallIdStyleWithNative(metadata: unknown): string;
+export declare function stripInternalToolingMetadataWithNative(metadata: unknown): Record<string, unknown> | null;
 export declare function buildProviderProtocolErrorWithNative(input: {
     message: string;
     code: string;

package/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics.js

@@ -123,6 +123,10 @@ function parseToolDefinitionArray(raw) {
     }
     return output;
 }
+function parseString(raw) {
+    const parsed = parseJson(raw);
+    return typeof parsed === 'string' ? parsed : null;
+}
 function parseStringArray(raw) {
     const parsed = parseArray(raw);
     if (!parsed)
@@ -510,6 +514,60 @@ export function mapChatToolsToBridgeWithNative(rawTools, options) {
         return fail(reason);
     }
 }
+export function collectToolCallsFromResponsesWithNative(response) {
+    const capability = 'collectToolCallsFromResponsesJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(response ?? {});
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseToolDefinitionArray(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function resolveFinishReasonWithNative(response, toolCalls) {
+    const capability = 'resolveFinishReasonJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const responseJson = safeStringify(response ?? {});
+    const toolCallsJson = safeStringify(Array.isArray(toolCalls) ? toolCalls : []);
+    if (!responseJson || !toolCallsJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(responseJson, toolCallsJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        return parseString(raw) ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function hasValidThoughtSignatureWithNative(block, options) {
     const capability = 'hasValidThoughtSignatureJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -973,6 +1031,85 @@ export function enforceToolCallIdStyleWithNative(messages, state) {
         return fail(reason);
     }
 }
+export function normalizeResponsesToolCallIdsWithNative(payload) {
+    const capability = 'normalizeResponsesToolCallIdsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload ?? null);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        return parseRecord(raw) ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function resolveToolCallIdStyleWithNative(metadata) {
+    const capability = 'resolveToolCallIdStyleJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const metadataJson = safeStringify(metadata ?? null);
+    if (!metadataJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(metadataJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseJson(raw);
+        return typeof parsed === 'string' ? parsed : fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function stripInternalToolingMetadataWithNative(metadata) {
+    const capability = 'stripInternalToolingMetadataJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const metadataJson = safeStringify(metadata ?? null);
+    if (!metadataJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(metadataJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        return parseRecord(raw) ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function buildProviderProtocolErrorWithNative(input) {
     const capability = 'buildProviderProtocolErrorJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/dist/router/virtual-router/types.d.ts

@@ -215,11 +215,34 @@ export interface ProviderHealthConfig {
     cooldownMs: number;
     fatalCooldownMs?: number;
 }
+export type VirtualRouterWebSearchExecutionMode = 'servertool' | 'direct';
+export type VirtualRouterWebSearchDirectActivation = 'route' | 'builtin';
 export interface VirtualRouterWebSearchEngineConfig {
     id: string;
     providerKey: string;
     description?: string;
     default?: boolean;
+    /**
+     * Search execution mode:
+     * - servertool: expose canonical web_search tool and execute through servertool engine.
+     * - direct: route to a search-capable model/provider directly; servertool injection must skip it.
+     */
+    executionMode?: VirtualRouterWebSearchExecutionMode;
+    /**
+     * When executionMode=direct, controls how the upstream search capability is activated.
+     * - route: route selection itself enables native search behavior (e.g. deepseek-web search route).
+     * - builtin: upstream requires a provider-native builtin search tool/schema.
+     */
+    directActivation?: VirtualRouterWebSearchDirectActivation;
+    /**
+     * Optional target model id for direct-mode matching when request/compat layers need to detect
+     * which routed provider payload should receive native web search activation.
+     */
+    modelId?: string;
+    /**
+     * Optional builtin max-uses hint for providers that support builtin web search tools.
+     */
+    maxUses?: number;
     /**
      * When true, this engine will never be used by server-side tools
      * (e.g. web_search). It will also be omitted from injected tool

package/dist/servertool/handlers/web-search.js

@@ -118,6 +118,27 @@ function getWebSearchConfig(ctx) {
             : undefined;
         if (!id || !providerKey)
             continue;
+        const rawExecutionMode = typeof obj.executionMode === 'string'
+            ? obj.executionMode.trim().toLowerCase()
+            : typeof obj.mode === 'string'
+                ? obj.mode.trim().toLowerCase()
+                : '';
+        const executionMode = rawExecutionMode === 'direct' ? 'direct' : 'servertool';
+        const rawDirectActivation = typeof obj.directActivation === 'string'
+            ? obj.directActivation.trim().toLowerCase()
+            : typeof obj.activation === 'string'
+                ? obj.activation.trim().toLowerCase()
+                : '';
+        const directActivation = rawDirectActivation === 'builtin'
+            ? 'builtin'
+            : rawDirectActivation === 'route'
+                ? 'route'
+                : executionMode === 'direct'
+                    ? 'route'
+                    : undefined;
+        const modelId = typeof obj.modelId === 'string' && obj.modelId.trim() ? obj.modelId.trim() : undefined;
+        const rawMaxUses = typeof obj.maxUses === 'number' ? obj.maxUses : Number(obj.maxUses);
+        const maxUses = Number.isFinite(rawMaxUses) && rawMaxUses > 0 ? Math.floor(rawMaxUses) : undefined;
         const serverToolsDisabled = obj.serverToolsDisabled === true ||
             (typeof obj.serverToolsDisabled === 'string' &&
                 obj.serverToolsDisabled.trim().toLowerCase() === 'true') ||
@@ -142,6 +163,10 @@ function getWebSearchConfig(ctx) {
             providerKey,
             description: typeof obj.description === 'string' && obj.description.trim() ? obj.description.trim() : undefined,
             default: obj.default === true,
+            executionMode,
+            ...(directActivation ? { directActivation } : {}),
+            ...(modelId ? { modelId } : {}),
+            ...(maxUses ? { maxUses } : {}),
             ...(serverToolsDisabled ? { serverToolsDisabled: true } : {}),
             ...(searchEngineList ? { searchEngineList } : {})
         });
@@ -181,7 +206,7 @@ function resolveWebSearchEngine(config, engineId) {
     return undefined;
 }
 function buildEnginePriorityList(config, engineId) {
-    const engines = (Array.isArray(config.engines) ? config.engines : []).filter((engine) => !engine.serverToolsDisabled);
+    const engines = (Array.isArray(config.engines) ? config.engines : []).filter((engine) => !engine.serverToolsDisabled && (engine.executionMode ?? 'servertool') === 'servertool');
     if (!engines.length) {
         return [];
     }

package/dist/servertool/server-side-tools.js

@@ -100,7 +100,7 @@ function normalizeFilterTokenSet(values) {
     return normalized.size > 0 ? normalized : null;
 }
 function isNameIncluded(name, includeSet, excludeSet) {
-    const normalized = name.trim().toLowerCase();
+    const normalized = normalizeServerToolCallName(name);
     if (includeSet && !includeSet.has(normalized)) {
         return false;
     }
@@ -109,6 +109,13 @@ function isNameIncluded(name, includeSet, excludeSet) {
     }
     return true;
 }
+function normalizeServerToolCallName(name) {
+    const normalized = name.trim().toLowerCase();
+    if (normalized === 'websearch' || normalized === 'web-search') {
+        return 'web_search';
+    }
+    return normalized;
+}
 function extractToolCallsFromMessage(message) {
     const toolCalls = getArray(message.tool_calls);
     const out = [];
@@ -120,7 +127,9 @@ function extractToolCallsFromMessage(message) {
         const fn = asObject(tc.function) ??
             asObject(tc.functionCall) ??
             asObject(tc.function_call);
-        const name = fn && typeof fn.name === 'string' && String(fn.name).trim() ? String(fn.name).trim() : '';
+        const name = fn && typeof fn.name === 'string' && String(fn.name).trim()
+            ? normalizeServerToolCallName(String(fn.name))
+            : '';
         const rawArgs = (fn ? fn.arguments : undefined) ??
             (fn ? fn.args : undefined) ??
             (fn ? fn.input : undefined) ??

package/dist/servertool/types.d.ts

@@ -137,6 +137,10 @@ export type ServerToolBackendPlan = {
         providerKey: string;
         description?: string;
         default?: boolean;
+        executionMode?: 'servertool' | 'direct';
+        directActivation?: 'route' | 'builtin';
+        modelId?: string;
+        maxUses?: number;
         serverToolsDisabled?: boolean;
         searchEngineList?: string[];
     }[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.3379",
+  "version": "0.6.3405",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",