@jsonstudio/llms 0.4.3 → 0.4.5

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

@@ -1,213 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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 sanitizeToolIdentifier;
-    private ensureUniqueToolCallId;
-    private generateToolCallId;
-    private resolveToolCallId;
-    private normalizeResponse;
-}

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

@@ -1,360 +0,0 @@
-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 = [];
-        const toolIdRegistry = new Set();
-        const toolIdAliasMap = new Map();
-        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++, toolIdRegistry, toolIdAliasMap))
-                    .filter(Boolean);
-                if (next.tool_calls.length) {
-                    lastToolCallId = next.tool_calls[next.tool_calls.length - 1].id;
-                }
-            }
-            if (next.role === 'tool') {
-                if (!lastToolCallId) {
-                    lastToolCallId = this.generateToolCallId(undefined, this.buildToolCallId(callCounter++), toolIdRegistry, toolIdAliasMap);
-                }
-                const resolvedId = this.resolveToolCallId(next.tool_call_id, lastToolCallId, toolIdRegistry, toolIdAliasMap);
-                next.tool_call_id = resolvedId;
-                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, registry, aliasMap) {
-        if (!call || typeof call !== 'object')
-            return null;
-        const id = this.generateToolCallId(call.id, this.buildToolCallId(counter), registry, aliasMap);
-        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()}`;
-    }
-    sanitizeToolIdentifier(value) {
-        if (!value)
-            return '';
-        const trimmed = value.trim();
-        if (!trimmed)
-            return '';
-        const sanitized = trimmed.replace(/[^A-Za-z0-9_-]/g, '_');
-        return sanitized || '';
-    }
-    ensureUniqueToolCallId(base, registry) {
-        if (!registry.has(base)) {
-            return base;
-        }
-        let suffix = 1;
-        let candidate = `${base}_${suffix}`;
-        while (registry.has(candidate)) {
-            suffix += 1;
-            candidate = `${base}_${suffix}`;
-        }
-        return candidate;
-    }
-    generateToolCallId(rawCandidate, fallbackBase, registry, aliasMap) {
-        const candidate = typeof rawCandidate === 'string' ? rawCandidate.trim() : '';
-        const sanitizedCandidate = this.sanitizeToolIdentifier(candidate);
-        const sanitizedFallback = this.sanitizeToolIdentifier(fallbackBase) || this.buildToolCallId(Date.now());
-        const base = sanitizedCandidate || sanitizedFallback;
-        const unique = this.ensureUniqueToolCallId(base, registry);
-        registry.add(unique);
-        if (candidate)
-            aliasMap.set(candidate, unique);
-        aliasMap.set(unique, unique);
-        if (sanitizedCandidate && sanitizedCandidate !== candidate) {
-            aliasMap.set(sanitizedCandidate, unique);
-        }
-        return unique;
-    }
-    resolveToolCallId(rawCandidate, fallbackId, registry, aliasMap) {
-        const candidate = typeof rawCandidate === 'string' ? rawCandidate.trim() : '';
-        if (candidate) {
-            const cached = aliasMap.get(candidate);
-            if (cached) {
-                return cached;
-            }
-            const sanitized = this.sanitizeToolIdentifier(candidate);
-            if (sanitized) {
-                const cachedSanitized = aliasMap.get(sanitized);
-                if (cachedSanitized) {
-                    aliasMap.set(candidate, cachedSanitized);
-                    return cachedSanitized;
-                }
-                const unique = this.ensureUniqueToolCallId(sanitized, registry);
-                registry.add(unique);
-                aliasMap.set(candidate, unique);
-                aliasMap.set(sanitized, unique);
-                aliasMap.set(unique, unique);
-                return unique;
-            }
-        }
-        return fallbackId;
-    }
-    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

@@ -1,40 +0,0 @@
-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;
-}