@jsonstudio/llms 0.6.215 → 0.6.230

package/dist/conversion/codecs/gemini-openai-codec.js

@@ -183,16 +183,20 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
     const textParts = [];
     const reasoningParts = [];
     const toolCalls = [];
+    const toolResultTexts = [];
+    const toolOutputs = [];
     for (const part of parts) {
         if (!part || typeof part !== 'object')
             continue;
         const pObj = part;
+        // 1. Text part
         if (typeof pObj.text === 'string') {
             const t = pObj.text;
             if (t && t.trim().length)
                 textParts.push(t);
             continue;
         }
+        // 2. Content array (nested structure)
         if (Array.isArray(pObj.content)) {
             for (const inner of pObj.content) {
                 if (typeof inner === 'string') {
@@ -204,10 +208,20 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
             }
             continue;
         }
+        // 3. Reasoning part (channel mode)
         if (typeof pObj.reasoning === 'string') {
             reasoningParts.push(pObj.reasoning);
             continue;
         }
+        // 4. Thought part (thinking/extended thinking)
+        if (typeof pObj.thought === 'string') {
+            const thoughtText = pObj.thought.trim();
+            if (thoughtText.length) {
+                reasoningParts.push(thoughtText);
+            }
+            continue;
+        }
+        // 5. Function call (tool call)
         if (pObj.functionCall && typeof pObj.functionCall === 'object') {
             const fc = pObj.functionCall;
             const name = typeof fc.name === 'string' ? String(fc.name) : undefined;
@@ -239,8 +253,68 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
             toolCalls.push(toolCall);
             continue;
         }
+        // 6. Function response (tool result)
+        if (pObj.functionResponse && typeof pObj.functionResponse === 'object') {
+            const fr = pObj.functionResponse;
+            const callId = typeof fr.id === 'string' && fr.id.trim().length ? String(fr.id) : undefined;
+            const name = typeof fr.name === 'string' && fr.name.trim().length ? String(fr.name) : undefined;
+            const resp = fr.response;
+            let contentStr = '';
+            if (typeof resp === 'string') {
+                contentStr = resp;
+            }
+            else if (resp != null) {
+                try {
+                    contentStr = JSON.stringify(resp);
+                }
+                catch {
+                    contentStr = String(resp);
+                }
+            }
+            if (contentStr && contentStr.trim().length) {
+                toolResultTexts.push(contentStr);
+                if (callId || name) {
+                    const entry = {
+                        tool_call_id: callId ?? undefined,
+                        id: callId ?? undefined,
+                        content: contentStr
+                    };
+                    if (name) {
+                        entry.name = name;
+                    }
+                    toolOutputs.push(entry);
+                }
+            }
+            continue;
+        }
+        // 7. Executable code (code_interpreter)
+        if (pObj.executableCode && typeof pObj.executableCode === 'object') {
+            const code = pObj.executableCode;
+            const language = typeof code.language === 'string' ? code.language : 'python';
+            const codeText = typeof code.code === 'string' ? code.code : '';
+            if (codeText.trim().length) {
+                // Append as text with code block formatting
+                textParts.push(`\`\`\`${language}\n${codeText}\n\`\`\``);
+            }
+            continue;
+        }
+        // 8. Code execution result
+        if (pObj.codeExecutionResult && typeof pObj.codeExecutionResult === 'object') {
+            const result = pObj.codeExecutionResult;
+            const outcome = typeof result.outcome === 'string' ? result.outcome : '';
+            const output = typeof result.output === 'string' ? result.output : '';
+            if (output.trim().length) {
+                textParts.push(`[Code Output${outcome ? ` (${outcome})` : ''}]:\n${output}`);
+            }
+            continue;
+        }
     }
+    const hasToolCalls = toolCalls.length > 0;
     const finish_reason = (() => {
+        // If the model is emitting tool calls, treat this turn as a tool_calls
+        // completion so downstream tool governance can continue the loop.
+        if (hasToolCalls)
+            return 'tool_calls';
         const fr = String(primary?.finishReason || '').toUpperCase();
         if (fr === 'MAX_TOKENS')
             return 'length';
@@ -265,9 +339,14 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
         usage.total_tokens = totalTokens;
     const combinedText = textParts.join('\n');
     const normalized = combinedText.length ? normalizeChatMessageContent(combinedText) : { contentText: undefined, reasoningText: undefined };
+    const baseContent = normalized.contentText ?? combinedText ?? '';
+    const toolResultBlock = toolResultTexts.length ? toolResultTexts.join('\n') : '';
+    const finalContent = toolResultBlock && baseContent
+        ? `${baseContent}\n${toolResultBlock}`
+        : baseContent || toolResultBlock;
     const chatMsg = {
         role,
-        content: normalized.contentText ?? combinedText ?? ''
+        content: finalContent
     };
     if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
         reasoningParts.push(normalized.reasoningText.trim());
@@ -314,6 +393,9 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
     if (Object.keys(usage).length > 0) {
         chatResp.usage = usage;
     }
+    if (toolOutputs.length > 0) {
+        chatResp.tool_outputs = toolOutputs;
+    }
     const preservedReasoning = consumeResponsesReasoning(chatResp.id);
     if (preservedReasoning && preservedReasoning.length) {
         chatResp.__responses_reasoning = preservedReasoning;

package/dist/conversion/compat/actions/glm-web-search.d.ts

@@ -0,0 +1,2 @@
+import type { JsonObject } from '../../hub/types/json.js';
+export declare function applyGlmWebSearchRequestTransform(payload: JsonObject): JsonObject;

package/dist/conversion/compat/actions/glm-web-search.js

@@ -0,0 +1,66 @@
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+export function applyGlmWebSearchRequestTransform(payload) {
+    const root = structuredClone(payload);
+    const webSearchRaw = root.web_search;
+    if (!isRecord(webSearchRaw)) {
+        return root;
+    }
+    const webSearch = webSearchRaw;
+    const queryValue = webSearch.query;
+    const recencyValue = webSearch.recency;
+    const countValue = webSearch.count;
+    const query = typeof queryValue === 'string' ? queryValue.trim() : '';
+    const recency = typeof recencyValue === 'string' ? recencyValue.trim() : undefined;
+    let count;
+    if (typeof countValue === 'number' && Number.isFinite(countValue)) {
+        const normalized = Math.floor(countValue);
+        if (normalized >= 1 && normalized <= 50) {
+            count = normalized;
+        }
+    }
+    if (!query) {
+        // No meaningful search query, drop the helper object and passthrough.
+        delete root.web_search;
+        return root;
+    }
+    const toolsValue = root.tools;
+    const tools = Array.isArray(toolsValue) ? [...toolsValue] : [];
+    let existingIndex = -1;
+    for (let i = 0; i < tools.length; i += 1) {
+        const tool = tools[i];
+        if (isRecord(tool) && typeof tool.type === 'string' && tool.type === 'web_search') {
+            existingIndex = i;
+            break;
+        }
+    }
+    const webSearchConfig = {
+        enable: true,
+        search_query: query
+    };
+    if (recency) {
+        webSearchConfig.search_recency_filter = recency;
+    }
+    if (typeof count === 'number') {
+        webSearchConfig.count = count;
+    }
+    const baseTool = existingIndex >= 0 && isRecord(tools[existingIndex])
+        ? { ...tools[existingIndex] }
+        : {};
+    baseTool.type = 'web_search';
+    const existingWebSearch = isRecord(baseTool.web_search)
+        ? baseTool.web_search
+        : {};
+    baseTool.web_search = {
+        ...existingWebSearch,
+        ...webSearchConfig
+    };
+    if (existingIndex >= 0) {
+        tools[existingIndex] = baseTool;
+    }
+    else {
+        tools.push(baseTool);
+    }
+    root.tools = tools;
+    delete root.web_search;
+    return root;
+}

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

@@ -21,7 +21,7 @@
                     "request": {
                         "allowTopLevel": [
                             "model", "messages", "stream", "thinking", "do_sample", "temperature", "top_p",
-                            "max_tokens", "tools", "tool_choice", "stop", "response_format"
+                            "max_tokens", "tools", "tool_choice", "stop", "response_format", "web_search"
                         ],
                         "messages": {
                             "allowedRoles": ["system", "user", "assistant", "tool"],
@@ -157,6 +157,9 @@
                     }
                 }
             },
+            {
+                "action": "glm_web_search_request"
+            },
             {
                 "action": "field_map",
                 "direction": "outgoing",

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

@@ -10,6 +10,7 @@ import { validateResponsePayload } from '../../../compat/actions/response-valida
 import { writeCompatSnapshot } from '../../../compat/actions/snapshot.js';
 import { applyQwenRequestTransform, applyQwenResponseTransform } from '../../../compat/actions/qwen-transform.js';
 import { extractGlmToolMarkup } from '../../../compat/actions/glm-tool-extraction.js';
+import { applyGlmWebSearchRequestTransform } from '../../../compat/actions/glm-web-search.js';
 const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
 const INTERNAL_STATE = Symbol('compat.internal_state');
 export function runRequestCompatPipeline(profileId, payload, options) {
@@ -157,6 +158,11 @@ function applyMapping(root, mapping, state) {
         case 'qwen_response_transform':
             replaceRoot(root, applyQwenResponseTransform(root));
             break;
+        case 'glm_web_search_request':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyGlmWebSearchRequestTransform(root));
+            }
+            break;
         default:
             break;
     }

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

@@ -98,6 +98,8 @@ export type MappingInstruction = {
     action: 'qwen_request_transform';
 } | {
     action: 'qwen_response_transform';
+} | {
+    action: 'glm_web_search_request';
 };
 export type FilterInstruction = {
     action: 'rate_limit_text';

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

@@ -94,10 +94,18 @@ export class HubPipeline {
         });
         let processedRequest;
         if (normalized.processMode !== 'passthrough') {
+            const processMetadata = {
+                ...(normalized.metadata ?? {})
+            };
+            const webSearchConfig = this.config.virtualRouter?.webSearch;
+            if (webSearchConfig) {
+                processMetadata.webSearch = webSearchConfig;
+            }
+            normalized.metadata = processMetadata;
             const processResult = await runReqProcessStage1ToolGovernance({
                 request: standardizedRequest,
                 rawPayload: rawRequest,
-                metadata: normalized.metadata,
+                metadata: processMetadata,
                 entryEndpoint: normalized.entryEndpoint,
                 requestId: normalized.id,
                 stageRecorder: inboundRecorder

package/dist/conversion/hub/process/chat-process.js

@@ -51,7 +51,7 @@ async function applyRequestToolGovernance(request, context) {
     });
     const governed = normalizeRecord(governedPayload);
     const providerStreamIntent = typeof governed.stream === 'boolean' ? governed.stream : undefined;
-    const merged = {
+    let merged = {
         ...request,
         messages: Array.isArray(governed.messages)
             ? governed.messages
@@ -92,6 +92,8 @@ async function applyRequestToolGovernance(request, context) {
     if (typeof governed.model === 'string' && governed.model.trim()) {
         merged.model = governed.model.trim();
     }
+    // Server-side web_search tool injection (config-driven, best-effort).
+    merged = maybeInjectWebSearchTool(merged, metadata);
     const { request: sanitized, summary } = toolGovernanceEngine.governRequest(merged, providerProtocol);
     if (summary.applied) {
         sanitized.metadata = {
@@ -274,3 +276,131 @@ function readToolChoice(value) {
 function isRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
+function maybeInjectWebSearchTool(request, metadata) {
+    const rawConfig = metadata.webSearch;
+    if (!rawConfig || !Array.isArray(rawConfig.engines) || rawConfig.engines.length === 0) {
+        return request;
+    }
+    const injectPolicy = (rawConfig.injectPolicy === 'always' || rawConfig.injectPolicy === 'selective')
+        ? rawConfig.injectPolicy
+        : 'selective';
+    if (injectPolicy === 'selective' && !detectWebSearchIntent(request)) {
+        return request;
+    }
+    const existingTools = Array.isArray(request.tools) ? request.tools : [];
+    const hasWebSearch = existingTools.some((tool) => {
+        if (!tool || typeof tool !== 'object')
+            return false;
+        const fn = tool.function;
+        return typeof fn?.name === 'string' && fn.name.trim() === 'web_search';
+    });
+    if (hasWebSearch) {
+        return request;
+    }
+    const engines = rawConfig.engines.filter((engine) => typeof engine?.id === 'string' && !!engine.id.trim());
+    if (!engines.length) {
+        return request;
+    }
+    const engineIds = engines.map((engine) => engine.id.trim());
+    const engineDescriptions = engines
+        .map((engine) => {
+        const id = engine.id.trim();
+        const desc = typeof engine.description === 'string' && engine.description.trim()
+            ? engine.description.trim()
+            : '';
+        return desc ? `${id}: ${desc}` : id;
+    })
+        .join('; ');
+    const hasMultipleEngines = engineIds.length > 1;
+    const parameters = {
+        type: 'object',
+        properties: {
+            ...(hasMultipleEngines
+                ? {
+                    engine: {
+                        type: 'string',
+                        enum: engineIds,
+                        description: engineDescriptions
+                    }
+                }
+                : {}),
+            query: {
+                type: 'string',
+                description: 'Search query or user question.'
+            },
+            recency: {
+                type: 'string',
+                enum: ['oneDay', 'oneWeek', 'oneMonth', 'oneYear', 'noLimit'],
+                description: 'Optional recency filter for web search results.'
+            },
+            count: {
+                type: 'integer',
+                minimum: 1,
+                maximum: 50,
+                description: 'Number of results to retrieve.'
+            }
+        },
+        required: ['query'],
+        additionalProperties: false
+    };
+    const webSearchTool = {
+        type: 'function',
+        function: {
+            name: 'web_search',
+            description: 'Perform web search using configured search engines. Use this when the user asks for up-to-date information or news.',
+            parameters,
+            strict: true
+        }
+    };
+    const nextMetadata = {
+        ...(request.metadata ?? {}),
+        webSearchEnabled: true
+    };
+    return {
+        ...request,
+        metadata: nextMetadata,
+        tools: [...existingTools, webSearchTool]
+    };
+}
+function detectWebSearchIntent(request) {
+    const messages = Array.isArray(request.messages) ? request.messages : [];
+    if (!messages.length) {
+        return false;
+    }
+    const last = messages[messages.length - 1];
+    if (!last || last.role !== 'user') {
+        return false;
+    }
+    const content = typeof last.content === 'string' ? last.content : '';
+    if (!content) {
+        return false;
+    }
+    const text = content.toLowerCase();
+    const keywords = [
+        // English
+        'web search',
+        'web_search',
+        'websearch',
+        'internet search',
+        'search the web',
+        'online search',
+        'search online',
+        'search on the internet',
+        'search the internet',
+        'web-search',
+        'online-search',
+        'internet-search',
+        // Chinese
+        '联网搜索',
+        '网络搜索',
+        '上网搜索',
+        '网上搜索',
+        '网上查',
+        '网上查找',
+        '上网查',
+        '上网搜',
+        // Command-style
+        '/search'
+    ];
+    return keywords.some((keyword) => text.includes(keyword.toLowerCase()));
+}

package/dist/conversion/hub/response/provider-response.d.ts

@@ -0,0 +1,22 @@
+import { Readable } from 'node:stream';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { JsonObject } from '../types/json.js';
+import type { StageRecorder } from '../format-adapters/index.js';
+import type { ProviderInvoker } from './server-side-tools.js';
+type ProviderProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages' | 'gemini-chat';
+export interface ProviderResponseConversionOptions {
+    providerProtocol: ProviderProtocol;
+    providerResponse: JsonObject;
+    context: AdapterContext;
+    entryEndpoint: string;
+    wantsStream: boolean;
+    stageRecorder?: StageRecorder;
+    providerInvoker?: ProviderInvoker;
+}
+export interface ProviderResponseConversionResult {
+    body?: JsonObject;
+    __sse_responses?: Readable;
+    format?: string;
+}
+export declare function convertProviderResponse(options: ProviderResponseConversionOptions): Promise<ProviderResponseConversionResult>;
+export {};

package/dist/conversion/hub/response/provider-response.js

@@ -12,6 +12,7 @@ import { runRespProcessStage2Finalize } from '../pipeline/stages/resp_process/re
 import { runRespOutboundStage1ClientRemap } from '../pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js';
 import { runRespOutboundStage2SseStream } from '../pipeline/stages/resp_outbound/resp_outbound_stage2_sse_stream/index.js';
 import { recordResponsesResponse } from '../../shared/responses-conversation-store.js';
+import { runServerSideToolEngine } from './server-side-tools.js';
 function resolveChatReasoningMode(entryEndpoint) {
     const envRaw = (process.env.ROUTECODEX_CHAT_REASONING_MODE || process.env.RCC_CHAT_REASONING_MODE || '').trim().toLowerCase();
     const map = {
@@ -137,8 +138,18 @@ export async function convertProviderResponse(options) {
         mapper,
         stageRecorder: options.stageRecorder
     });
+    // Server-side tool orchestration hook (web_search, etc.).
+    const serverSideResult = await runServerSideToolEngine({
+        chatResponse,
+        adapterContext: options.context,
+        entryEndpoint: options.entryEndpoint,
+        requestId: options.context.requestId,
+        providerProtocol: options.providerProtocol,
+        providerInvoker: options.providerInvoker
+    });
+    const chatForGovernance = serverSideResult.finalChatResponse;
     const governanceResult = await runRespProcessStage1ToolGovernance({
-        payload: chatResponse,
+        payload: chatForGovernance,
         entryEndpoint: options.entryEndpoint,
         requestId: options.context.requestId,
         clientProtocol,

package/dist/conversion/hub/response/server-side-tools.d.ts

@@ -0,0 +1,26 @@
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { JsonObject } from '../types/json.js';
+export type ProviderInvoker = (options: {
+    providerKey: string;
+    providerType?: string;
+    modelId?: string;
+    providerProtocol: string;
+    payload: JsonObject;
+    entryEndpoint: string;
+    requestId: string;
+}) => Promise<{
+    providerResponse: JsonObject;
+}>;
+export interface ServerSideToolEngineOptions {
+    chatResponse: JsonObject;
+    adapterContext: AdapterContext;
+    entryEndpoint: string;
+    requestId: string;
+    providerProtocol: string;
+    providerInvoker?: ProviderInvoker;
+}
+export interface ServerSideToolEngineResult {
+    mode: 'passthrough' | 'web_search_flow';
+    finalChatResponse: JsonObject;
+}
+export declare function runServerSideToolEngine(options: ServerSideToolEngineOptions): Promise<ServerSideToolEngineResult>;