@jsonstudio/rcc 0.89.168 → 0.89.524

package/node_modules/@jsonstudio/llms/dist/servertool/registry.js

@@ -0,0 +1,27 @@
+const SERVER_TOOL_HANDLERS = Object.create(null);
+const AUTO_SERVER_TOOL_HANDLERS = [];
+export function registerServerToolHandler(name, handler, options) {
+    if (!name || typeof name !== 'string' || typeof handler !== 'function')
+        return;
+    const key = name.trim().toLowerCase();
+    if (!key)
+        return;
+    const trigger = options?.trigger ?? 'tool_call';
+    const entry = { name: key, trigger, handler };
+    if (trigger === 'auto') {
+        AUTO_SERVER_TOOL_HANDLERS.push(entry);
+        return;
+    }
+    SERVER_TOOL_HANDLERS[key] = entry;
+}
+export function getServerToolHandler(name) {
+    if (!name || typeof name !== 'string')
+        return undefined;
+    const key = name.trim().toLowerCase();
+    if (!key)
+        return undefined;
+    return SERVER_TOOL_HANDLERS[key];
+}
+export function listAutoServerToolHandlers() {
+    return [...AUTO_SERVER_TOOL_HANDLERS];
+}

package/node_modules/@jsonstudio/llms/dist/servertool/server-side-tools.d.ts

@@ -0,0 +1,8 @@
+import type { JsonObject } from '../conversion/hub/types/json.js';
+import type { ServerSideToolEngineOptions, ServerSideToolEngineResult, ToolCall } from './types.js';
+import './handlers/web-search.js';
+import './handlers/vision.js';
+export declare function runServerSideToolEngine(options: ServerSideToolEngineOptions): Promise<ServerSideToolEngineResult>;
+export declare function extractToolCalls(chatResponse: JsonObject): ToolCall[];
+export declare function cloneJson<T>(value: T): T;
+export declare function extractTextFromChatLike(payload: JsonObject): string;

package/node_modules/@jsonstudio/llms/dist/servertool/server-side-tools.js

@@ -0,0 +1,208 @@
+import { getServerToolHandler, listAutoServerToolHandlers } from './registry.js';
+import './handlers/web-search.js';
+import './handlers/vision.js';
+export async function runServerSideToolEngine(options) {
+    const base = asObject(options.chatResponse);
+    if (!base) {
+        return { mode: 'passthrough', finalChatResponse: options.chatResponse };
+    }
+    const toolCalls = extractToolCalls(base);
+    const contextBase = {
+        base,
+        toolCalls,
+        adapterContext: options.adapterContext,
+        options
+    };
+    for (const toolCall of toolCalls) {
+        const entry = getServerToolHandler(toolCall.name);
+        if (!entry || entry.trigger !== 'tool_call')
+            continue;
+        const ctx = { ...contextBase, toolCall };
+        const result = await runHandler(entry.handler, ctx);
+        if (result) {
+            return {
+                mode: 'tool_flow',
+                finalChatResponse: result.chatResponse,
+                execution: result.execution
+            };
+        }
+    }
+    for (const entry of listAutoServerToolHandlers()) {
+        const result = await runHandler(entry.handler, contextBase);
+        if (result) {
+            return {
+                mode: 'tool_flow',
+                finalChatResponse: result.chatResponse,
+                execution: result.execution
+            };
+        }
+    }
+    return { mode: 'passthrough', finalChatResponse: base };
+}
+async function runHandler(handler, ctx) {
+    try {
+        return await handler(ctx);
+    }
+    catch (error) {
+        try {
+            // eslint-disable-next-line no-console
+            console.error('[servertool] handler failed', error);
+        }
+        catch {
+            /* logging best-effort */
+        }
+        return null;
+    }
+}
+export function extractToolCalls(chatResponse) {
+    const choices = getArray(chatResponse.choices);
+    const calls = [];
+    for (const choice of choices) {
+        const choiceObj = asObject(choice);
+        if (!choiceObj)
+            continue;
+        const message = asObject(choiceObj.message);
+        if (!message)
+            continue;
+        const toolCalls = getArray(message.tool_calls);
+        for (const raw of toolCalls) {
+            const tc = asObject(raw);
+            if (!tc)
+                continue;
+            const id = typeof tc.id === 'string' && tc.id.trim() ? tc.id.trim() : '';
+            const fn = asObject(tc.function);
+            const name = fn && typeof fn.name === 'string' && fn.name.trim() ? fn.name.trim() : '';
+            const args = fn && typeof fn.arguments === 'string' ? fn.arguments : '';
+            if (!id || !name)
+                continue;
+            calls.push({ id, name, arguments: args });
+        }
+    }
+    return calls;
+}
+function asObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function getArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+export function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+export function extractTextFromChatLike(payload) {
+    let current = payload;
+    const visited = new Set();
+    while (current && typeof current === 'object' && !Array.isArray(current) && !visited.has(current)) {
+        visited.add(current);
+        if (Array.isArray(current.choices) || Array.isArray(current.output)) {
+            break;
+        }
+        const data = current.data;
+        if (data && typeof data === 'object' && !Array.isArray(data)) {
+            current = data;
+            continue;
+        }
+        const response = current.response;
+        if (response && typeof response === 'object' && !Array.isArray(response)) {
+            current = response;
+            continue;
+        }
+        break;
+    }
+    const choices = getArray(current.choices);
+    if (!choices.length)
+        return '';
+    const first = asObject(choices[0]);
+    if (!first)
+        return '';
+    const message = asObject(first.message);
+    if (!message)
+        return '';
+    const content = message.content;
+    if (typeof content === 'string')
+        return content.trim();
+    const parts = getArray(content);
+    const texts = [];
+    for (const part of parts) {
+        if (typeof part === 'string') {
+            texts.push(part);
+        }
+        else if (part && typeof part === 'object') {
+            const record = part;
+            if (typeof record.text === 'string') {
+                texts.push(record.text);
+            }
+            else if (typeof record.content === 'string') {
+                texts.push(record.content);
+            }
+        }
+    }
+    const joinedFromChoices = texts.join('\n').trim();
+    if (joinedFromChoices) {
+        return joinedFromChoices;
+    }
+    const output = current.output;
+    if (Array.isArray(output)) {
+        const altTexts = [];
+        for (const entry of output) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const blocks = entry.content;
+            const blockArray = Array.isArray(blocks) ? blocks : [];
+            for (const block of blockArray) {
+                if (!block || typeof block !== 'object')
+                    continue;
+                const record = block;
+                if (typeof record.text === 'string') {
+                    altTexts.push(record.text);
+                }
+                else if (typeof record.output_text === 'string') {
+                    altTexts.push(record.output_text);
+                }
+                else if (typeof record.content === 'string') {
+                    altTexts.push(record.content);
+                }
+            }
+        }
+        const joined = altTexts.join('\n').trim();
+        if (joined) {
+            return joined;
+        }
+    }
+    const webSearchRaw = current.web_search ??
+        payload.web_search;
+    if (Array.isArray(webSearchRaw) && webSearchRaw.length > 0) {
+        const items = webSearchRaw
+            .filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry))
+            .slice(0, 5);
+        const lines = [];
+        items.forEach((item, index) => {
+            const idx = (typeof item.refer === 'string' && item.refer.trim()) || String(index + 1);
+            const title = typeof item.title === 'string' && item.title.trim() ? item.title.trim() : '';
+            const media = typeof item.media === 'string' && item.media.trim() ? item.media.trim() : '';
+            const date = typeof item.publish_date === 'string' && item.publish_date.trim() ? item.publish_date.trim() : '';
+            const contentText = typeof item.content === 'string' && item.content.trim() ? item.content.trim() : '';
+            const link = typeof item.link === 'string' && item.link.trim() ? item.link.trim() : '';
+            const headerParts = [];
+            if (title)
+                headerParts.push(title);
+            if (media)
+                headerParts.push(media);
+            if (date)
+                headerParts.push(date);
+            const header = headerParts.length ? headerParts.join(' · ') : undefined;
+            const segments = [];
+            segments.push(`【${idx}】${header ?? '搜索结果'}`);
+            if (contentText)
+                segments.push(contentText);
+            if (link)
+                segments.push(link);
+            lines.push(segments.join('\n'));
+        });
+        const combined = lines.join('\n\n').trim();
+        if (combined) {
+            return combined;
+        }
+    }
+    return '';
+}

package/node_modules/@jsonstudio/llms/dist/servertool/types.d.ts

@@ -0,0 +1,88 @@
+import type { AdapterContext } from '../conversion/hub/types/chat-envelope.js';
+import type { JsonObject } from '../conversion/hub/types/json.js';
+/**
+ * ProviderInvoker 由 Host 注入，用于在 llmswitch-core 内部发起二次 provider 请求。
+ * 该接口对 ServerTool 框架是抽象的，不关心 HTTP 细节。
+ */
+export type ProviderInvoker = (options: {
+    providerKey: string;
+    providerType?: string;
+    modelId?: string;
+    providerProtocol: string;
+    payload: JsonObject;
+    entryEndpoint: string;
+    requestId: string;
+    /**
+     * 可选的路由提示，用于在 Host 侧强制通过虚拟路由命中特定 route
+     *（例如 web_search），保持所有二次请求仍然走标准 HubPipeline。
+     */
+    routeHint?: string;
+}) => Promise<{
+    providerResponse: JsonObject;
+}>;
+/**
+ * ToolCall：对齐 OpenAI style 的工具调用表示。
+ */
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+/**
+ * ServerSideToolEngineOptions：ServerTool 引擎入参（ChatCompletion 视角）。
+ */
+export interface ServerSideToolEngineOptions {
+    chatResponse: JsonObject;
+    adapterContext: AdapterContext;
+    entryEndpoint: string;
+    requestId: string;
+    providerProtocol: string;
+    providerInvoker?: ProviderInvoker;
+    reenterPipeline?: (options: {
+        entryEndpoint: string;
+        requestId: string;
+        body: JsonObject;
+        metadata?: JsonObject;
+    }) => Promise<{
+        body?: JsonObject;
+        __sse_responses?: unknown;
+        format?: string;
+    }>;
+}
+export interface ServerToolFollowupPlan {
+    requestIdSuffix: string;
+    payload: JsonObject;
+    metadata?: JsonObject;
+}
+export interface ServerToolExecution {
+    flowId: string;
+    followup?: ServerToolFollowupPlan;
+}
+/**
+ * ServerSideToolEngineResult：ServerTool 引擎出参。
+ */
+export interface ServerSideToolEngineResult {
+    mode: 'passthrough' | 'tool_flow';
+    finalChatResponse: JsonObject;
+    execution?: ServerToolExecution;
+}
+/**
+ * ServerToolHandlerContext：单个工具 handler 的上下文入参。
+ */
+export interface ServerToolHandlerContext {
+    base: JsonObject;
+    toolCall?: ToolCall;
+    toolCalls: ToolCall[];
+    adapterContext: AdapterContext;
+    options: ServerSideToolEngineOptions;
+}
+export interface ServerToolHandlerResult {
+    chatResponse: JsonObject;
+    execution: ServerToolExecution;
+}
+/**
+ * ServerToolHandler：统一的 ServerTool handler 接口。
+ * 后续 web_search / vision / 其它工具都会以 handler 形式挂载到注册表。
+ */
+export type ServerToolHandler = (ctx: ServerToolHandlerContext) => Promise<ServerToolHandlerResult | null>;
+export type { JsonObject, JsonValue } from '../conversion/hub/types/json.js';

package/node_modules/@jsonstudio/llms/dist/servertool/types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@jsonstudio/llms/dist/servertool/vision-tool.d.ts

@@ -0,0 +1,2 @@
+import type { ServerToolFlow } from './flow-types.js';
+export declare const visionToolFlow: ServerToolFlow;

package/node_modules/@jsonstudio/llms/dist/servertool/vision-tool.js

@@ -0,0 +1,185 @@
+import { extractTextFromChatLike } from './server-side-tools.js';
+const VISION_FLOW_ID = 'vision_flow';
+export const visionToolFlow = {
+    id: VISION_FLOW_ID,
+    shouldRun(context) {
+        if (!context.options.reenterPipeline) {
+            return false;
+        }
+        return shouldRunVisionFlow(context);
+    },
+    async run(context, helpers) {
+        const captured = context.capturedChatRequest;
+        if (!captured) {
+            return null;
+        }
+        const visionPayload = buildVisionAnalysisPayload(captured);
+        if (!visionPayload) {
+            return null;
+        }
+        const visionResponse = await helpers.callReenterHop({
+            requestIdSuffix: ':vision',
+            body: visionPayload,
+            metadata: {
+                routeHint: 'vision'
+            }
+        });
+        const visionBody = asObject(visionResponse?.body);
+        if (!visionBody) {
+            return null;
+        }
+        const visionSummary = extractTextFromChatLike(visionBody);
+        if (!visionSummary) {
+            return null;
+        }
+        const followupPayload = buildVisionFollowupPayload(captured, visionSummary);
+        if (!followupPayload) {
+            return null;
+        }
+        const followupRouteHint = helpers.getRouteHintForFollowup('vision');
+        const followup = await helpers.callReenterHop({
+            requestIdSuffix: ':vision_followup',
+            body: followupPayload,
+            metadata: followupRouteHint ? { routeHint: followupRouteHint } : undefined
+        });
+        const followupBody = asObject(followup?.body);
+        if (followupBody) {
+            return {
+                chat: followupBody,
+                executed: true,
+                flowId: VISION_FLOW_ID
+            };
+        }
+        return null;
+    }
+};
+function shouldRunVisionFlow(context) {
+    const adapterCtx = context.options.adapterContext;
+    const followupFlag = adapterCtx.serverToolFollowup === true || adapterCtx.serverToolFollowup === 'true';
+    if (followupFlag) {
+        return false;
+    }
+    return adapterCtx.hasImageAttachment === true || adapterCtx.hasImageAttachment === 'true';
+}
+function asObject(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    if (Array.isArray(value))
+        return undefined;
+    return value;
+}
+function buildVisionAnalysisPayload(source) {
+    if (!source || typeof source !== 'object') {
+        return null;
+    }
+    const payload = {};
+    if (typeof source.model === 'string' && source.model.trim()) {
+        payload.model = source.model.trim();
+    }
+    if (Array.isArray(source.messages)) {
+        payload.messages = cloneJson(source.messages);
+    }
+    else {
+        return null;
+    }
+    if (Array.isArray(source.tools) && source.tools.length) {
+        payload.tools = cloneJson(source.tools);
+    }
+    const parameters = source.parameters;
+    if (parameters && typeof parameters === 'object' && !Array.isArray(parameters)) {
+        const params = cloneJson(parameters);
+        Object.assign(payload, params);
+    }
+    return payload;
+}
+function buildVisionFollowupPayload(source, summary) {
+    if (!source || typeof source !== 'object') {
+        return null;
+    }
+    const payload = {};
+    if (typeof source.model === 'string' && source.model.trim()) {
+        payload.model = source.model.trim();
+    }
+    payload.messages = injectVisionSummary(source.messages, summary);
+    if (Array.isArray(source.tools) && source.tools.length) {
+        payload.tools = cloneJson(source.tools);
+    }
+    const parameters = source.parameters;
+    if (parameters && typeof parameters === 'object' && !Array.isArray(parameters)) {
+        const params = cloneJson(parameters);
+        Object.assign(payload, params);
+    }
+    return payload;
+}
+function injectVisionSummary(source, summary) {
+    const messages = Array.isArray(source) ? cloneJson(source) : [];
+    let injected = false;
+    for (const message of messages) {
+        if (!message || typeof message !== 'object')
+            continue;
+        const content = message.content;
+        if (!Array.isArray(content))
+            continue;
+        const nextParts = [];
+        let removed = false;
+        for (const part of content) {
+            if (part && typeof part === 'object') {
+                const typeValue = typeof part.type === 'string'
+                    ? part.type.toLowerCase()
+                    : '';
+                if (typeValue.includes('image')) {
+                    removed = true;
+                    continue;
+                }
+            }
+            nextParts.push(part);
+        }
+        if (removed) {
+            nextParts.push({
+                type: 'text',
+                text: `[Vision] ${summary}`
+            });
+            message.content = nextParts;
+            injected = true;
+        }
+    }
+    if (!injected) {
+        for (let i = messages.length - 1; i >= 0; i -= 1) {
+            const msg = messages[i];
+            if (!msg || typeof msg !== 'object')
+                continue;
+            const role = typeof msg.role === 'string'
+                ? msg.role.toLowerCase()
+                : '';
+            if (role !== 'user')
+                continue;
+            const content = msg.content;
+            if (Array.isArray(content)) {
+                content.push({
+                    type: 'text',
+                    text: `[Vision] ${summary}`
+                });
+                injected = true;
+                break;
+            }
+            if (typeof content === 'string' && content.length) {
+                msg.content = `${content}\n[Vision] ${summary}`;
+            }
+            else {
+                msg.content = `[Vision] ${summary}`;
+            }
+            injected = true;
+            break;
+        }
+    }
+    if (!injected) {
+        messages.push({
+            role: 'system',
+            content: `[Vision] ${summary}`
+        });
+    }
+    return messages;
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}

package/node_modules/@jsonstudio/llms/dist/sse/json-to-sse/event-generators/responses.js

@@ -8,11 +8,22 @@ function cloneRegex(source) {
     return new RegExp(source.source, source.flags);
 }
 function getChunkSize(config) {
-    return Math.max(1, config.chunkSize || DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG.chunkSize);
+    const size = typeof config.chunkSize === 'number'
+        ? config.chunkSize
+        : DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG.chunkSize;
+    if (size !== undefined && size <= 0) {
+        return null;
+    }
+    return Math.max(1, size || 1);
 }
 function chunkText(text, config) {
+    const size = getChunkSize(config);
+    if (size === null) {
+        // chunking explicitly disabled
+        return [text];
+    }
     try {
-        return StringUtils.chunkString(text, getChunkSize(config), cloneRegex(TEXT_CHUNK_BOUNDARY));
+        return StringUtils.chunkString(text, size, cloneRegex(TEXT_CHUNK_BOUNDARY));
     }
     catch {
         return [text];
@@ -84,7 +95,8 @@ function normalizeUsage(usage) {
 }
 // 默认配置
 export const DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG = {
-    chunkSize: 12,
+    // 默认关闭文本切片，让上游模型的分块行为原样透传
+    chunkSize: 0,
     chunkDelayMs: 8,
     enableIdGeneration: true,
     enableTimestampGeneration: true,

package/node_modules/@jsonstudio/llms/dist/sse/sse-to-json/builders/response-builder.js

@@ -215,9 +215,10 @@ export class ResponsesResponseBuilder {
         let normalizedType = typeof rawType === 'string'
             ? rawType.replace(/^response\./, '')
             : 'message';
-        // 将自定义工具调用规整为标准 function_call，便于后续统一转换为 Chat 工具调用
-        if (normalizedType === 'custom_tool_call')
+        // 将 web_search_call 视为标准 function_call，便于统一作为 Chat 工具调用暴露给上层。
+        if (normalizedType === 'web_search_call') {
             normalizedType = 'function_call';
+        }
         return {
             ...event,
             type: 'output_item.start',
@@ -719,7 +720,9 @@ export class ResponsesResponseBuilder {
                 default:
                     throw new Error(`Unknown output item type: ${state.type}`);
             }
-            outputItems.push(outputItem);
+            if (outputItem) {
+                outputItems.push(outputItem);
+            }
         }
         const hasMessage = outputItems.some(item => item.type === 'message');
         const hasReasoning = outputItems.some(item => item.type === 'reasoning');

package/node_modules/@jsonstudio/llms/dist/sse/sse-to-json/gemini-sse-to-json-converter.js

@@ -70,9 +70,35 @@ export class GeminiSseToJsonConverter {
         if (!accumulator.has(candidateIndex)) {
             accumulator.set(candidateIndex, { role, parts: [] });
         }
+        const candidate = accumulator.get(candidateIndex);
         const normalizedParts = this.normalizeReasoningPart(part, context);
         for (const normalizedPart of normalizedParts) {
-            accumulator.get(candidateIndex).parts.push(normalizedPart);
+            // For text parts, accumulate into the last text part instead of creating new ones
+            if ('text' in normalizedPart && typeof normalizedPart.text === 'string') {
+                const lastPart = candidate.parts[candidate.parts.length - 1];
+                if (lastPart && 'text' in lastPart && typeof lastPart.text === 'string') {
+                    // Append to existing text part
+                    lastPart.text += normalizedPart.text;
+                }
+                else {
+                    // Create new text part
+                    candidate.parts.push(normalizedPart);
+                }
+            }
+            else if ('reasoning' in normalizedPart && typeof normalizedPart.reasoning === 'string') {
+                // For reasoning parts, also accumulate
+                const lastPart = candidate.parts[candidate.parts.length - 1];
+                if (lastPart && 'reasoning' in lastPart && typeof lastPart.reasoning === 'string') {
+                    lastPart.reasoning += normalizedPart.reasoning;
+                }
+                else {
+                    candidate.parts.push(normalizedPart);
+                }
+            }
+            else {
+                // For other part types (functionCall, functionResponse, etc.), add as separate parts
+                candidate.parts.push(normalizedPart);
+            }
         }
     }
     buildResponse(accumulator, donePayload) {

package/node_modules/@jsonstudio/llms/dist/sse/types/gemini-types.d.ts

@@ -7,12 +7,14 @@ export interface GeminiContentFunctionCallPart {
     functionCall: {
         name: string;
         args?: Record<string, unknown>;
+        id?: string;
         [key: string]: unknown;
     };
 }
 export interface GeminiContentFunctionResponsePart {
     functionResponse: {
         name?: string;
+        id?: string;
         response?: unknown;
         [key: string]: unknown;
     };
@@ -23,7 +25,24 @@ export interface GeminiContentInlineDataPart {
         data: string;
     };
 }
-export type GeminiContentPart = GeminiContentTextPart | GeminiContentFunctionCallPart | GeminiContentFunctionResponsePart | GeminiContentInlineDataPart | Record<string, unknown>;
+export interface GeminiContentThoughtPart {
+    thought: string;
+}
+export interface GeminiContentExecutableCodePart {
+    executableCode: {
+        language?: string;
+        code?: string;
+        [key: string]: unknown;
+    };
+}
+export interface GeminiContentCodeExecutionResultPart {
+    codeExecutionResult: {
+        outcome?: string;
+        output?: string;
+        [key: string]: unknown;
+    };
+}
+export type GeminiContentPart = GeminiContentTextPart | GeminiContentFunctionCallPart | GeminiContentFunctionResponsePart | GeminiContentInlineDataPart | GeminiContentThoughtPart | GeminiContentExecutableCodePart | GeminiContentCodeExecutionResultPart | Record<string, unknown>;
 export interface GeminiCandidate {
     content?: {
         role?: string;

package/node_modules/@jsonstudio/llms/dist/sse/types/responses-types.js

@@ -23,7 +23,7 @@ export const DEFAULT_RESPONSES_CONVERSION_CONFIG = {
     defaultChunkSize: 12,
     defaultDelayMs: 8,
     reasoningChunkSize: 24,
-    textChunkSize: 12,
+    textChunkSize: 128,
     functionCallChunkSize: 24,
     enableEventValidation: true,
     enableSequenceValidation: true,