@jsonstudio/llms 0.4.2

package/dist/conversion/conversion-v3/nodes/process/response-process-node.js

@@ -0,0 +1,213 @@
+import { NodeStatus, NodeType } from '../../types/index.js';
+import { runChatResponseToolFilters } from '../../../shared/tool-filter-pipeline.js';
+import { finalizeOpenAIChatResponse } from '../../../shared/openai-finalizer.js';
+import { buildProcessedRequestFromChatResponse } from '../response/response-utils.js';
+function normalizeFlag(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string') {
+        const lowered = value.trim().toLowerCase();
+        if (['true', '1', 'yes', 'always'].includes(lowered))
+            return true;
+        if (['false', '0', 'no', 'never'].includes(lowered))
+            return false;
+    }
+    return undefined;
+}
+function metadataWantsStreaming(meta) {
+    if (!meta)
+        return false;
+    const inboundFlag = normalizeFlag(meta['inboundStream']);
+    if (inboundFlag)
+        return true;
+    const direct = normalizeFlag(meta['stream']);
+    if (direct)
+        return true;
+    const client = normalizeFlag(meta['clientStream']);
+    if (client)
+        return true;
+    const streamingMode = meta['streaming'];
+    if (typeof streamingMode === 'string') {
+        const lowered = streamingMode.toLowerCase();
+        if (lowered === 'always')
+            return true;
+        if (lowered === 'auto' && client)
+            return true;
+    }
+    return false;
+}
+export class ResponseProcessNode {
+    id;
+    config;
+    type = NodeType.PROCESS;
+    status = NodeStatus.IDLE;
+    name;
+    constructor(id, config) {
+        this.id = id;
+        this.config = config;
+        this.name = config.name || 'Response Process Node';
+    }
+    async execute(context) {
+        const start = Date.now();
+        this.status = NodeStatus.RUNNING;
+        try {
+            const { payload, responseContext } = this.extractPayload(context.data);
+            const wantsStream = this.detectStreamingIntent(context);
+            const toolCtx = this.buildToolContext(context, responseContext);
+            const governed = await runChatResponseToolFilters(payload, {
+                entryEndpoint: toolCtx.entryEndpoint,
+                requestId: context.request.id,
+                profile: 'openai-chat'
+            });
+            const finalized = await finalizeOpenAIChatResponse(governed, {
+                requestId: context.request.id,
+                endpoint: toolCtx.entryEndpoint,
+                processingMode: wantsStream ? 'streaming' : 'non-streaming',
+                stream: wantsStream
+            });
+            const processedRequest = buildProcessedRequestFromChatResponse(finalized, { stream: wantsStream });
+            this.status = NodeStatus.COMPLETED;
+            return {
+                success: true,
+                data: { processedRequest },
+                metadata: {
+                    node: this.id,
+                    executionTime: Date.now() - start,
+                    startTime: start,
+                    endTime: Date.now()
+                }
+            };
+        }
+        catch (error) {
+            this.status = NodeStatus.FAILED;
+            return {
+                success: false,
+                error: {
+                    code: 'RESPONSE_PROCESS_ERROR',
+                    message: error instanceof Error ? error.message : 'Failed to process provider response',
+                    cause: error instanceof Error ? error : undefined
+                },
+                metadata: {
+                    node: this.id,
+                    executionTime: Date.now() - start,
+                    startTime: start,
+                    endTime: Date.now()
+                }
+            };
+        }
+    }
+    validate() {
+        return { valid: true, errors: [], warnings: [] };
+    }
+    async cleanup() {
+        this.status = NodeStatus.IDLE;
+    }
+    extractPayload(data) {
+        if (!data || typeof data !== 'object') {
+            throw new Error('Response payload is required before processing');
+        }
+        const obj = data;
+        if (!obj.responsePayload || typeof obj.responsePayload !== 'object') {
+            throw new Error('responsePayload must be provided by response input node');
+        }
+        return { payload: obj.responsePayload, responseContext: obj.responseContext };
+    }
+    buildToolContext(context, responseContext) {
+        const pipelineCtx = context.request.context ?? {};
+        const metadata = pipelineCtx.metadata && typeof pipelineCtx.metadata === 'object'
+            ? pipelineCtx.metadata
+            : undefined;
+        const baseEntry = typeof pipelineCtx.entryEndpoint === 'string'
+            ? pipelineCtx.entryEndpoint
+            : context.request.endpoint;
+        const toolContext = responseContext?.toolContext && typeof responseContext.toolContext === 'object'
+            ? responseContext.toolContext
+            : {};
+        const resolvedEntry = typeof toolContext.entryEndpoint === 'string'
+            ? toolContext.entryEndpoint
+            : baseEntry;
+        const resolvedRequestId = typeof toolContext.requestId === 'string'
+            ? toolContext.requestId
+            : context.request.id;
+        // 构建基础工具上下文
+        const baseContext = {
+            originalRequest: toolContext.originalRequest ?? metadata?.originalRequest,
+            requestId: resolvedRequestId,
+            entryEndpoint: typeof resolvedEntry === 'string' && resolvedEntry.length
+                ? resolvedEntry
+                : context.request.endpoint
+        };
+        // 传递所有桥接回调，确保服务器工具自动循环和web_fetch执行路径正常
+        const bridgeCallbacks = {};
+        // 传递invokeSecondRound用于服务器工具自动循环
+        if (context.request.context && typeof context.request.context === 'object') {
+            const ctx = context.request.context;
+            if (typeof ctx.invokeSecondRound === 'function') {
+                bridgeCallbacks.invokeSecondRound = ctx.invokeSecondRound;
+            }
+            // 传递其他可能的桥接回调
+            const callbackKeys = ['webFetch', 'toolExecute', 'getCredentials'];
+            for (const key of callbackKeys) {
+                if (typeof ctx[key] === 'function') {
+                    bridgeCallbacks[key] = ctx[key];
+                }
+            }
+        }
+        return {
+            ...baseContext,
+            ...bridgeCallbacks
+        };
+    }
+    detectStreamingIntent(context) {
+        try {
+            const payload = context.request.payload;
+            if (payload && typeof payload === 'object') {
+                const payloadStream = payload['stream'];
+                if (normalizeFlag(payloadStream) === true) {
+                    return true;
+                }
+                const payloadMeta = payload['metadata'];
+                if (payloadMeta && typeof payloadMeta === 'object' && normalizeFlag(payloadMeta['stream']) === true) {
+                    return true;
+                }
+            }
+            const directMeta = this.extractDirectMetadata(context);
+            if (metadataWantsStreaming(directMeta)) {
+                return true;
+            }
+            const ctxMetadata = this.extractRequestMetadata(context);
+            if (metadataWantsStreaming(ctxMetadata)) {
+                return true;
+            }
+            if (ctxMetadata) {
+                const originalRequest = ctxMetadata.originalRequest;
+                if (originalRequest && typeof originalRequest === 'object' && normalizeFlag(originalRequest.stream) === true) {
+                    return true;
+                }
+            }
+            if (context.request.options?.streamingFormat === 'sse') {
+                return true;
+            }
+        }
+        catch {
+            // ignore detection errors
+        }
+        return false;
+    }
+    extractDirectMetadata(context) {
+        const container = context.request;
+        if (container && typeof container.metadata === 'object') {
+            return container.metadata;
+        }
+        return undefined;
+    }
+    extractRequestMetadata(context) {
+        if (context.request?.context && typeof context.request.context === 'object') {
+            const metadata = context.request.context.metadata;
+            if (metadata && typeof metadata === 'object') {
+                return metadata;
+            }
+        }
+        return undefined;
+    }
+}

package/dist/conversion/conversion-v3/nodes/process/tool-process-node.d.ts

@@ -0,0 +1,26 @@
+import { BasePipelineNode } from '../../standards/pipeline-node.js';
+import type { PipelineContext } from '../../standards/pipeline-context.js';
+/**
+ * 标准 PipelineNode - ToolProcessNode
+ *
+ * 负责集中化的工具治理：
+ * 1. 规范 tools 定义（去重、名称标准化、参数补全）
+ * 2. 规范 messages 中的 tool_calls（生成ID、序列化 arguments）
+ * 3. tool 角色消息补全 tool_call_id，并将 content 序列化为字符串
+ * 4. 对响应侧做一次工具 canonicalization，避免 finish_reason/tool_calls 失配
+ */
+export declare class ToolProcessNode extends BasePipelineNode {
+    constructor(id: string, options?: Record<string, unknown>);
+    protected executeLogic(ctx: PipelineContext): Promise<PipelineContext>;
+    private canonicalizeTools;
+    private normalizeSingleTool;
+    private convertCustomTool;
+    private normalizeToolParameters;
+    private harvestMessages;
+    private enforceToolResponseOrdering;
+    private normalizeToolCall;
+    private ensureArgumentsString;
+    private ensureToolChoiceIntegrity;
+    private buildToolCallId;
+    private normalizeResponse;
+}

package/dist/conversion/conversion-v3/nodes/process/tool-process-node.js

@@ -0,0 +1,299 @@
+import { BasePipelineNode } from '../../standards/pipeline-node.js';
+import { PREDEFINED_CAPABILITIES } from '../../standards/node-capabilities.js';
+import { ToolGovernanceEnforcer } from '../../validations/tool-governance-enforcer.js';
+import { canonicalizeChatResponseTools } from '../../../shared/tool-canonicalizer.js';
+const TOOL_CALL_ID_PREFIX = 'tool_call';
+/**
+ * 标准 PipelineNode - ToolProcessNode
+ *
+ * 负责集中化的工具治理：
+ * 1. 规范 tools 定义（去重、名称标准化、参数补全）
+ * 2. 规范 messages 中的 tool_calls（生成ID、序列化 arguments）
+ * 3. tool 角色消息补全 tool_call_id，并将 content 序列化为字符串
+ * 4. 对响应侧做一次工具 canonicalization，避免 finish_reason/tool_calls 失配
+ */
+export class ToolProcessNode extends BasePipelineNode {
+    constructor(id, options = {}) {
+        super(id, 'process', 'tool-governance', options, PREDEFINED_CAPABILITIES.TOOL_GOVERNANCE, 'Tool Governance Node');
+    }
+    async executeLogic(ctx) {
+        ToolGovernanceEnforcer.validateNodeExecution(this.id, this.kind, this.capabilities, ctx);
+        if (!ctx.request) {
+            return ctx;
+        }
+        const normalizedTools = this.canonicalizeTools(ctx.request.tools);
+        if (normalizedTools) {
+            ctx.request.tools = normalizedTools;
+        }
+        const normalizedMessages = this.harvestMessages(ctx.request.messages);
+        if (normalizedMessages) {
+            ctx.request.messages = normalizedMessages;
+        }
+        this.ensureToolChoiceIntegrity(ctx);
+        if (ctx.response) {
+            ctx.response = canonicalizeChatResponseTools(ctx.response);
+            this.normalizeResponse(ctx.response);
+        }
+        ToolGovernanceEnforcer.markToolGovernanceApplied(ctx);
+        this.debugLog('tool-governance', {
+            tools: ctx.request.tools?.length ?? 0,
+            messages: ctx.request.messages?.length ?? 0
+        }, ctx);
+        return ctx;
+    }
+    canonicalizeTools(tools) {
+        if (!Array.isArray(tools)) {
+            return undefined;
+        }
+        const seen = new Set();
+        const normalized = [];
+        for (const raw of tools) {
+            const coerced = this.normalizeSingleTool(raw);
+            if (!coerced)
+                continue;
+            const fn = coerced.function;
+            const name = fn.name.trim();
+            if (!name || seen.has(name))
+                continue;
+            const parameters = this.normalizeToolParameters(fn.parameters);
+            normalized.push({
+                type: 'function',
+                function: {
+                    name,
+                    description: typeof fn.description === 'string' ? fn.description : undefined,
+                    parameters
+                }
+            });
+            seen.add(name);
+        }
+        return normalized;
+    }
+    normalizeSingleTool(tool) {
+        if (!tool || typeof tool !== 'object') {
+            return null;
+        }
+        const raw = tool;
+        const type = typeof raw.type === 'string' ? raw.type.toLowerCase() : 'function';
+        if (type === 'function' && raw.function && typeof raw.function === 'object') {
+            const fnObj = raw.function;
+            const name = typeof fnObj.name === 'string' ? fnObj.name : '';
+            if (!name.trim())
+                return null;
+            return {
+                type: 'function',
+                function: {
+                    name: name.trim(),
+                    description: typeof fnObj.description === 'string' ? fnObj.description : undefined,
+                    parameters: fnObj.parameters,
+                    strict: fnObj.strict === true || raw.strict === true ? true : undefined
+                }
+            };
+        }
+        if (type === 'custom') {
+            return this.convertCustomTool(raw);
+        }
+        return null;
+    }
+    convertCustomTool(tool) {
+        const name = typeof tool.name === 'string' ? tool.name.trim() : '';
+        if (!name)
+            return null;
+        if (name !== 'apply_patch')
+            return null;
+        const description = typeof tool.description === 'string' ? tool.description.trim() : undefined;
+        const format = tool.format && typeof tool.format === 'object' ? tool.format : undefined;
+        const grammarDefinition = format && typeof format.definition === 'string' ? format.definition.trim() : undefined;
+        const grammarSyntax = format && typeof format.syntax === 'string' ? format.syntax.trim() : undefined;
+        const combinedDescription = [description, grammarSyntax && grammarDefinition
+                ? `Grammar (${grammarSyntax}):\n${grammarDefinition}`
+                : grammarDefinition
+                    ? `Grammar:\n${grammarDefinition}`
+                    : undefined]
+            .filter(Boolean)
+            .join('\n\n');
+        return {
+            type: 'function',
+            function: {
+                name: 'apply_patch',
+                description: combinedDescription || description,
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        patch: {
+                            type: 'string',
+                            description: 'Unified diff patch body (FREEFORM string)'
+                        }
+                    },
+                    required: ['patch'],
+                    additionalProperties: false
+                },
+                strict: true
+            }
+        };
+    }
+    normalizeToolParameters(parameters) {
+        if (parameters && typeof parameters === 'object') {
+            const paramObj = parameters;
+            const type = typeof paramObj.type === 'string' ? paramObj.type : 'object';
+            const properties = (paramObj.properties && typeof paramObj.properties === 'object')
+                ? paramObj.properties
+                : {};
+            const required = Array.isArray(paramObj.required) ? paramObj.required : undefined;
+            const additionalProperties = typeof paramObj.additionalProperties === 'boolean'
+                ? paramObj.additionalProperties
+                : true;
+            return {
+                type: type,
+                properties: properties,
+                required,
+                additionalProperties
+            };
+        }
+        return {
+            type: 'object',
+            properties: {},
+            additionalProperties: true
+        };
+    }
+    harvestMessages(messages) {
+        if (!Array.isArray(messages)) {
+            return undefined;
+        }
+        const normalized = [];
+        let lastToolCallId = null;
+        let callCounter = 0;
+        for (const msg of messages) {
+            if (!msg || typeof msg !== 'object')
+                continue;
+            const next = { ...msg };
+            if (Array.isArray(next.tool_calls) && next.tool_calls.length > 0) {
+                next.content = null;
+                next.tool_calls = next.tool_calls
+                    .map(call => this.normalizeToolCall(call, callCounter++))
+                    .filter(Boolean);
+                if (next.tool_calls.length) {
+                    lastToolCallId = next.tool_calls[next.tool_calls.length - 1].id;
+                }
+            }
+            if (next.role === 'tool') {
+                const toolCallId = typeof next.tool_call_id === 'string' && next.tool_call_id.trim()
+                    ? next.tool_call_id.trim()
+                    : lastToolCallId ?? this.buildToolCallId(callCounter++);
+                next.tool_call_id = toolCallId;
+                if (next.content !== null && typeof next.content !== 'string') {
+                    try {
+                        next.content = JSON.stringify(next.content);
+                    }
+                    catch {
+                        next.content = String(next.content);
+                    }
+                }
+            }
+            normalized.push(next);
+        }
+        return this.enforceToolResponseOrdering(normalized);
+    }
+    enforceToolResponseOrdering(messages) {
+        if (!messages.length) {
+            return messages;
+        }
+        const ordered = [];
+        const assistantMap = new Map();
+        const appendMessage = (message) => {
+            ordered.push(message);
+        };
+        for (const message of messages) {
+            if (message.role === 'assistant' && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
+                appendMessage(message);
+                for (const toolCall of message.tool_calls) {
+                    if (toolCall?.id) {
+                        assistantMap.set(toolCall.id, { message, inserted: 0 });
+                    }
+                }
+                continue;
+            }
+            if (message.role === 'tool' && typeof message.tool_call_id === 'string' && message.tool_call_id.trim()) {
+                const meta = assistantMap.get(message.tool_call_id.trim());
+                if (meta) {
+                    const baseIndex = ordered.indexOf(meta.message);
+                    if (baseIndex >= 0) {
+                        const insertPos = baseIndex + 1 + meta.inserted;
+                        ordered.splice(insertPos, 0, message);
+                        meta.inserted += 1;
+                        continue;
+                    }
+                }
+            }
+            appendMessage(message);
+        }
+        return ordered;
+    }
+    normalizeToolCall(call, counter) {
+        if (!call || typeof call !== 'object')
+            return null;
+        const id = typeof call.id === 'string' && call.id.trim()
+            ? call.id.trim()
+            : this.buildToolCallId(counter);
+        const fn = call.function || { name: '', arguments: '' };
+        const name = typeof fn.name === 'string' ? fn.name.trim() : '';
+        const args = this.ensureArgumentsString(fn.arguments);
+        if (!name)
+            return null;
+        return {
+            id,
+            type: call.type ?? 'function',
+            function: {
+                name,
+                arguments: args
+            }
+        };
+    }
+    ensureArgumentsString(args) {
+        if (typeof args === 'string') {
+            return args;
+        }
+        try {
+            return JSON.stringify(args ?? {});
+        }
+        catch {
+            return String(args ?? '');
+        }
+    }
+    ensureToolChoiceIntegrity(ctx) {
+        if (!ctx.request?.parameters?.tool_choice)
+            return;
+        const choice = ctx.request.parameters.tool_choice;
+        if (typeof choice === 'string') {
+            if (choice === 'none' && ctx.request.tools && ctx.request.tools.length === 0) {
+                return;
+            }
+            return;
+        }
+        if (choice && typeof choice === 'object' && 'function' in choice) {
+            const fnChoice = choice.function;
+            if (typeof fnChoice.name === 'string' && ctx.request.tools?.length) {
+                const target = ctx.request.tools.find(tool => tool.function.name === fnChoice.name);
+                if (!target) {
+                    // 如果工具列表中不存在该工具，则降级为 auto。
+                    ctx.request.parameters.tool_choice = 'auto';
+                }
+            }
+        }
+    }
+    buildToolCallId(counter) {
+        return `${TOOL_CALL_ID_PREFIX}_${counter}_${Date.now()}`;
+    }
+    normalizeResponse(response) {
+        if (!response?.message)
+            return;
+        const toolCalls = response.message.tool_calls;
+        if (Array.isArray(toolCalls)) {
+            for (const call of toolCalls) {
+                const fn = call?.function;
+                if (fn) {
+                    fn.arguments = this.ensureArgumentsString(fn.arguments);
+                }
+            }
+        }
+    }
+}

package/dist/conversion/conversion-v3/nodes/process/virtual-router-process-node.d.ts

@@ -0,0 +1,40 @@
+import { type VirtualRouterConfig } from '../../../../router/virtual-router/types.js';
+import type { NodeConfig, NodeContext, NodeResult, PipelineNode, ValidationResult } from '../../types/index.js';
+import { NodeStatus, NodeType } from '../../types/index.js';
+export declare class VirtualRouterProcessNode implements PipelineNode {
+    readonly id: string;
+    readonly type = NodeType.PROCESS;
+    readonly name: string;
+    status: NodeStatus;
+    config: NodeConfig;
+    private readonly engine;
+    private unsubscribeFromErrors;
+    private watchedProviders;
+    constructor(nodeId: string, config: NodeConfig);
+    execute(context: NodeContext): Promise<NodeResult>;
+    validate(data: Record<string, unknown>): ValidationResult;
+    cleanup(): Promise<void>;
+    updateConfig(newConfig: VirtualRouterConfig): void;
+    getStatus(): {
+        routes: Record<string, {
+            providers: string[];
+            hits: number;
+            lastUsedProvider?: string;
+        }>;
+        health: import("../../../../index.js").ProviderHealthState[];
+        node: string;
+        status: NodeStatus;
+    };
+    private initialize;
+    private extractRouterConfig;
+    private registerProviderFailureListener;
+    private handleProviderErrorEvent;
+    private extractStandardizedRequest;
+    private extractRoutingSubject;
+    private ensureRequestMetadata;
+    private buildRouterMetadata;
+    private applyTargetToMetadata;
+    private applyTargetToSubject;
+    private attachDiagnostics;
+    private isProcessedRequest;
+}