@jsonstudio/llms 0.4.2 → 0.4.4

package/README.md

@@ -1,4 +1,6 @@
-# rcc-llmswitch-core（RouteCodex LLM Switch 核心）
+# @jsonstudio/llms（RouteCodex LLM Switch 核心）
+
+> 自 0.4.3 起，原 `rcc-llmswitch-core` npm 包已迁移并更名为 `@jsonstudio/llms`。开发 / 发布流程保持不变，仅需更新 package 依赖与文档引用。
 
 本包是 RouteCodex V2 的“工具治理唯一入口 + 协议转换核心”，实现严格的“前半段/后半段”双向流水线，并通过 `defaultSseCodecRegistry` 统一治理所有 SSE ↔ JSON 转换。核心事实：
 

package/dist/bridge/routecodex-adapter.js

@@ -19,12 +19,15 @@ function normalizeEndpoint(candidate) {
 }
 function inferProviderType(protocol) {
     const value = (protocol ?? '').toLowerCase();
-    if (value.includes('anthropic'))
+    if (value.includes('anthropic')) {
         return 'anthropic';
-    if (value.includes('responses'))
+    }
+    if (value.includes('responses')) {
         return 'responses';
-    if (value.includes('gemini'))
+    }
+    if (value.includes('gemini')) {
         return 'gemini';
+    }
     return 'openai';
 }
 function buildContext(input) {

package/dist/config-unified/enhanced-path-resolver.js

@@ -10,28 +10,36 @@ export function resolveHostPaths() {
     try {
         const cwd = process.cwd();
         const cfg = path.join(cwd, 'config');
-        if (fs.existsSync(cfg))
+        if (fs.existsSync(cfg)) {
             return { hostRoot: cwd, configDir: cfg };
+        }
+    }
+    catch {
+        /* ignore */
     }
-    catch { /* ignore */ }
     // Attempt 2: scan upward from this file
     try {
         let cur = path.dirname(new URL(import.meta.url).pathname);
         const visited = new Set();
         for (let i = 0; i < 10; i++) {
-            if (visited.has(cur))
+            if (visited.has(cur)) {
                 break;
+            }
             visited.add(cur);
             const cfg = path.join(cur, 'config');
-            if (fs.existsSync(cfg))
+            if (fs.existsSync(cfg)) {
                 return { hostRoot: cur, configDir: cfg };
+            }
             const parent = path.dirname(cur);
-            if (parent === cur)
+            if (parent === cur) {
                 break;
+            }
             cur = parent;
         }
     }
-    catch { /* ignore */ }
+    catch {
+        /* ignore */
+    }
     // Fallback to relative 'config'
     const fallbackRoot = process.cwd();
     return { hostRoot: fallbackRoot, configDir: path.join(fallbackRoot, 'config') };

package/dist/config-unified/unified-config.js

@@ -2,20 +2,22 @@
 import fs from 'fs';
 import path from 'path';
 import { resolveHostPaths } from './enhanced-path-resolver.js';
-const isObj = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
-function readJsonSync(file) {
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const hasProviders = (value) => isRecord(value) && typeof value.providers === 'object' && value.providers !== null;
+const readJsonSync = (file) => {
     try {
         return JSON.parse(fs.readFileSync(file, 'utf-8'));
     }
     catch {
         return null;
     }
-}
-function listMergedConfigs(configDir) {
+};
+const listMergedConfigs = (configDir) => {
     try {
-        const files = fs.readdirSync(configDir)
-            .filter(n => /merged-config.*\.json$/i.test(n))
-            .map(n => path.join(configDir, n));
+        const files = fs
+            .readdirSync(configDir)
+            .filter((name) => /merged-config.*\.json$/i.test(name))
+            .map((name) => path.join(configDir, name));
         files.sort((a, b) => {
             try {
                 const sa = fs.statSync(a);
@@ -31,39 +33,70 @@ function listMergedConfigs(configDir) {
     catch {
         return [];
     }
-}
+};
+const toNumber = (value) => {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+};
+const extractProviders = (cfg) => {
+    if (!isRecord(cfg.virtualrouter) || !hasProviders(cfg.virtualrouter)) {
+        return null;
+    }
+    return cfg.virtualrouter.providers ?? null;
+};
+const extractModulesConfig = (modulesRoot) => {
+    if (!isRecord(modulesRoot.modules)) {
+        return null;
+    }
+    const virtualRouterModule = modulesRoot.modules.virtualrouter;
+    if (!isRecord(virtualRouterModule)) {
+        return null;
+    }
+    const config = virtualRouterModule.config;
+    return isRecord(config) ? config : null;
+};
+const readContextBudgetNode = (configNode) => {
+    if (!configNode) {
+        return { defaultBytes: null, safetyRatio: null };
+    }
+    const contextBudgetNode = configNode.contextBudget;
+    if (!isRecord(contextBudgetNode)) {
+        return { defaultBytes: null, safetyRatio: null };
+    }
+    const defaultBytes = toNumber(contextBudgetNode.defaultMaxContextBytes ?? contextBudgetNode.defaultMaxContext);
+    const safetyRatio = toNumber(contextBudgetNode.safetyRatio);
+    return { defaultBytes, safetyRatio };
+};
 function findMaxContextInConfig(cfg, modelId) {
-    try {
-        const vr = cfg.virtualrouter;
-        if (!isObj(vr))
-            return null;
-        const providers = vr.providers;
-        if (!isObj(providers))
-            return null;
-        for (const p of Object.keys(providers)) {
-            const prov = providers[p];
-            if (!isObj(prov))
-                continue;
-            const models = prov.models;
-            if (!isObj(models))
-                continue;
-            if (Object.prototype.hasOwnProperty.call(models, modelId)) {
-                const item = models[modelId];
-                const v = isObj(item) ? item.maxContext : undefined;
-                const n = Number(v);
-                if (Number.isFinite(n) && n > 0)
-                    return n;
-            }
+    const providers = extractProviders(cfg);
+    if (!providers) {
+        return null;
+    }
+    for (const provider of Object.values(providers)) {
+        if (!isRecord(provider.models)) {
+            continue;
+        }
+        const models = provider.models;
+        if (!Object.prototype.hasOwnProperty.call(models, modelId)) {
+            continue;
+        }
+        const target = models[modelId];
+        if (!target) {
+            continue;
+        }
+        const maxContext = toNumber(target.maxContext);
+        if (maxContext && maxContext > 0) {
+            return maxContext;
         }
     }
-    catch { /* ignore */ }
     return null;
 }
 export class UnifiedConfigFacade {
     static _instance = null;
     static getInstance() {
-        if (!this._instance)
+        if (!this._instance) {
             this._instance = new UnifiedConfigFacade();
+        }
         return this._instance;
     }
     watchers = [];
@@ -83,16 +116,14 @@ export class UnifiedConfigFacade {
         let modulesSafety = null;
         try {
             const modules = readJsonSync(path.join(configDir, 'modules.json'));
-            if (modules && isObj(modules.modules) && isObj(modules.modules.virtualrouter) && isObj(modules.modules.virtualrouter.config)) {
-                const vr = modules.modules.virtualrouter.config;
-                if (isObj(vr.contextBudget)) {
-                    const ctx = vr.contextBudget;
-                    const d = Number(ctx.defaultMaxContextBytes);
-                    if (Number.isFinite(d) && d > 0)
-                        modulesDefault = d;
-                    const s = Number(ctx.safetyRatio);
-                    if (Number.isFinite(s) && s >= 0 && s < 1)
-                        modulesSafety = s;
+            if (modules) {
+                const modulesConfig = extractModulesConfig(modules);
+                const { defaultBytes, safetyRatio } = readContextBudgetNode(modulesConfig);
+                if (defaultBytes && defaultBytes > 0) {
+                    modulesDefault = defaultBytes;
+                }
+                if (typeof safetyRatio === 'number' && safetyRatio >= 0 && safetyRatio < 1) {
+                    modulesSafety = safetyRatio;
                 }
             }
         }
@@ -102,8 +133,9 @@ export class UnifiedConfigFacade {
             const merged = listMergedConfigs(configDir);
             for (const f of merged) {
                 const cfg = readJsonSync(f);
-                if (!cfg)
+                if (!cfg) {
                     continue;
+                }
                 const v = findMaxContextInConfig(cfg, modelId);
                 if (v && v > 0) {
                     const safety = Number.isFinite(safetyFromEnv) ? safetyFromEnv : (modulesSafety ?? 0.1);
@@ -111,7 +143,9 @@ export class UnifiedConfigFacade {
                 }
             }
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         // config.json
         try {
             const cfg = readJsonSync(path.join(configDir, 'config.json'));
@@ -135,51 +169,61 @@ export class UnifiedConfigFacade {
         try {
             const { configDir } = resolveHostPaths();
             const modules = readJsonSync(path.join(configDir, 'modules.json'));
-            if (modules && isObj(modules.modules) && isObj(modules.modules.virtualrouter) && isObj(modules.modules.virtualrouter.config)) {
-                const vr = modules.modules.virtualrouter.config;
-                if (isObj(vr.contextBudget)) {
-                    const ctx = vr.contextBudget;
-                    const d = Number(ctx.defaultMaxContextBytes);
-                    const s = Number(ctx.safetyRatio);
-                    if (!(Number.isFinite(d) && d > 0))
+            if (modules) {
+                const modulesConfig = extractModulesConfig(modules);
+                if (modulesConfig && isRecord(modulesConfig.contextBudget)) {
+                    const contextBudget = modulesConfig.contextBudget;
+                    const defaultBytes = toNumber(contextBudget.defaultMaxContextBytes ?? contextBudget.defaultMaxContext);
+                    const safetyRatio = toNumber(contextBudget.safetyRatio);
+                    if (!(defaultBytes && defaultBytes > 0)) {
                         issues.push('contextBudget.defaultMaxContextBytes must be positive number');
-                    if (!(Number.isFinite(s) && s >= 0 && s < 1))
+                    }
+                    if (!(typeof safetyRatio === 'number' && safetyRatio >= 0 && safetyRatio < 1)) {
                         issues.push('contextBudget.safetyRatio must be in [0,1)');
+                    }
                 }
             }
         }
-        catch (e) {
-            issues.push(`validateConfig error: ${e?.message || String(e)}`);
+        catch (error) {
+            const err = error;
+            issues.push(`validateConfig error: ${err?.message ?? String(error)}`);
         }
         return { ok: issues.length === 0, issues };
     }
     watchConfig(cb) {
         this.watchers.push(cb);
-        if (this.fsWatcher)
+        if (this.fsWatcher) {
             return;
+        }
         try {
             const { configDir } = resolveHostPaths();
             this.fsWatcher = fs.watch(configDir, { persistent: false }, (event, file) => {
                 try {
-                    this.watchers.forEach(fn => fn({ file: file || '', event }));
+                    this.watchers.forEach((fn) => fn({ file: file || '', event }));
+                }
+                catch {
+                    /* ignore */
                 }
-                catch { /* ignore */ }
             });
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
     unwatchConfig(cb) {
         if (!cb) {
             this.watchers = [];
         }
         else {
-            this.watchers = this.watchers.filter(fn => fn !== cb);
+            this.watchers = this.watchers.filter((fn) => fn !== cb);
         }
         if (this.watchers.length === 0 && this.fsWatcher) {
             try {
                 this.fsWatcher.close();
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
             this.fsWatcher = null;
         }
     }

package/dist/conversion/codec-registry.js

@@ -6,11 +6,13 @@ export class CodecRegistry {
         this.factories.set(id, factory);
     }
     async resolve(id) {
-        if (this.instances.has(id))
+        if (this.instances.has(id)) {
             return this.instances.get(id);
+        }
         const factory = this.factories.get(id);
-        if (!factory)
+        if (!factory) {
             throw new Error(`Unknown conversion codec: ${id}`);
+        }
         const instance = await factory();
         await instance.initialize();
         this.instances.set(id, instance);

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

@@ -85,7 +85,7 @@ export class HubPipeline {
         });
         return {
             processedRequest: processResult.processedRequest,
-            nodeResult: this.convertV3NodeResult('hub-chat-process', processResult.nodeResult)
+            nodeResult: this.convertProcessNodeResult('hub-chat-process', processResult.nodeResult)
         };
     }
     routeRequest(request, normalized) {
@@ -299,17 +299,16 @@ export class HubPipeline {
             error: result.error
         };
     }
-    convertV3NodeResult(id, result) {
+    convertProcessNodeResult(id, result) {
         return {
             id,
             success: result.success,
             metadata: result.metadata,
             error: result.error
                 ? {
-                    code: result.error.code,
+                    code: result.error.code ?? 'hub_chat_process_error',
                     message: result.error.message,
-                    details: result.error.details,
-                    cause: result.error.cause
+                    details: result.error.details
                 }
                 : undefined
         };

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

@@ -1,50 +1,267 @@
-import { ChatProcessNode } from '../../conversion-v3/nodes/process/chat-process-node.js';
-import { NodeType } from '../../conversion-v3/types/index.js';
-const CHAT_PROCESS_CONFIG = {
-    id: 'hub-chat-process',
-    type: NodeType.PROCESS,
-    name: 'Hub Chat Process Node',
-    inputFormat: 'standardized-request',
-    outputFormat: 'processed-request',
-    rules: [],
-    validation: {
-        strict: false,
-        required: [],
-        optional: []
-    },
-    timeout: 30_000,
-    options: {}
-};
-const chatProcessNode = new ChatProcessNode(CHAT_PROCESS_CONFIG);
+import { runChatRequestToolFilters } from '../../shared/tool-filter-pipeline.js';
+import { ToolGovernanceEngine } from '../tool-governance/index.js';
+const toolGovernanceEngine = new ToolGovernanceEngine();
 export async function runHubChatProcess(options) {
-    const nodeContext = buildProcessNodeContext(options);
-    const result = await chatProcessNode.execute(nodeContext);
+    const startTime = Date.now();
+    try {
+        const governed = await applyRequestToolGovernance(options.request, {
+            entryEndpoint: options.entryEndpoint,
+            requestId: options.requestId,
+            metadata: options.metadata
+        });
+        const processedRequest = buildProcessedRequest(governed);
+        return {
+            processedRequest,
+            nodeResult: buildSuccessResult(startTime, processedRequest)
+        };
+    }
+    catch (error) {
+        return {
+            nodeResult: buildErrorResult(startTime, error)
+        };
+    }
+}
+async function applyRequestToolGovernance(request, context) {
+    const entryEndpoint = context.entryEndpoint && context.entryEndpoint.trim()
+        ? context.entryEndpoint
+        : '/v1/chat/completions';
+    const metadata = normalizeRecord(context.metadata);
+    const providerProtocol = readString(metadata.providerProtocol) ?? readString(metadata.provider) ?? 'openai-chat';
+    const metadataToolHints = metadata.toolFilterHints;
+    const metadataStreamFlag = metadata.stream;
+    const metadataStream = typeof metadataStreamFlag === 'boolean' ? metadataStreamFlag : request.parameters?.stream === true;
+    const shaped = {
+        model: request.model,
+        messages: deepClone(request.messages),
+        tools: request.tools ? deepClone(request.tools) : undefined,
+        tool_choice: request.parameters?.tool_choice,
+        stream: request.parameters?.stream === true,
+        parameters: { ...request.parameters }
+    };
+    const governedPayload = await runChatRequestToolFilters(shaped, {
+        entryEndpoint,
+        requestId: context.requestId,
+        model: request.model,
+        profile: providerProtocol,
+        stream: metadataStream,
+        toolFilterHints: metadataToolHints
+    });
+    const governed = normalizeRecord(governedPayload);
+    const merged = {
+        ...request,
+        messages: Array.isArray(governed.messages)
+            ? governed.messages
+            : request.messages,
+        tools: governed.tools !== undefined ? castGovernedTools(governed.tools) : request.tools,
+        parameters: {
+            ...request.parameters,
+            ...(isRecord(governed.parameters) ? governed.parameters : {})
+        },
+        metadata: {
+            ...request.metadata,
+            toolChoice: readToolChoice(governed.tool_choice),
+            originalStream: request.parameters?.stream === true,
+            stream: typeof governed.stream === 'boolean'
+                ? governed.stream
+                : request.parameters?.stream,
+            governedTools: governed.tools !== undefined,
+            governanceTimestamp: Date.now()
+        }
+    };
+    if (typeof governed.stream === 'boolean') {
+        merged.parameters = {
+            ...merged.parameters,
+            stream: governed.stream
+        };
+    }
+    if (governed.tool_choice !== undefined) {
+        merged.parameters = {
+            ...merged.parameters,
+            tool_choice: governed.tool_choice
+        };
+    }
+    if (typeof governed.model === 'string' && governed.model.trim()) {
+        merged.model = governed.model.trim();
+    }
+    const { request: sanitized, summary } = toolGovernanceEngine.governRequest(merged, providerProtocol);
+    if (summary.applied) {
+        sanitized.metadata = {
+            ...sanitized.metadata,
+            toolGovernance: {
+                ...sanitized.metadata?.toolGovernance,
+                request: summary
+            }
+        };
+    }
+    return sanitized;
+}
+function buildProcessedRequest(request) {
+    const timestamp = Date.now();
+    const streamingEnabled = request.parameters?.stream === true;
     return {
-        processedRequest: result.success ? result.data?.processedRequest : undefined,
-        nodeResult: result
+        ...request,
+        processed: {
+            timestamp,
+            appliedRules: ['tool-governance'],
+            status: 'success'
+        },
+        processingMetadata: {
+            streaming: {
+                enabled: streamingEnabled,
+                chunkCount: 0
+            },
+            context: buildContextMetadata(request.metadata)
+        }
     };
 }
-function buildProcessNodeContext(options) {
+function buildContextMetadata(metadata) {
+    if (!metadata?.capturedContext || typeof metadata.capturedContext !== 'object') {
+        return undefined;
+    }
+    return { ...metadata.capturedContext };
+}
+function buildSuccessResult(startTime, processedRequest) {
+    const endTime = Date.now();
     return {
-        request: {
-            id: options.requestId,
-            timestamp: Date.now(),
-            endpoint: options.entryEndpoint,
-            payload: options.rawPayload,
-            context: {
-                metadata: options.metadata
+        success: true,
+        metadata: {
+            node: 'hub-chat-process',
+            executionTime: endTime - startTime,
+            startTime,
+            endTime,
+            dataProcessed: {
+                messages: processedRequest.messages.length,
+                tools: processedRequest.tools?.length ?? 0
             }
+        }
+    };
+}
+function buildErrorResult(startTime, error) {
+    const endTime = Date.now();
+    return {
+        success: false,
+        metadata: {
+            node: 'hub-chat-process',
+            executionTime: endTime - startTime,
+            startTime,
+            endTime
         },
-        data: {
-            standardizedRequest: options.request
-        },
-        pipeline: {
-            currentNode: CHAT_PROCESS_CONFIG.id,
-            previousResults: [],
-            isPassthrough: false,
-            startTime: Date.now()
-        },
-        nodeConfig: CHAT_PROCESS_CONFIG,
-        callbacks: null
+        error: {
+            message: error instanceof Error ? error.message : String(error)
+        }
+    };
+}
+function castGovernedTools(tools) {
+    if (!Array.isArray(tools)) {
+        return undefined;
+    }
+    const normalized = [];
+    for (const tool of tools) {
+        const converted = castSingleTool(tool) ?? castCustomTool(tool);
+        if (converted) {
+            normalized.push(converted);
+        }
+    }
+    return normalized.length ? normalized : [];
+}
+function castSingleTool(tool) {
+    if (!isRecord(tool)) {
+        return null;
+    }
+    const fn = tool.function;
+    if (!isRecord(fn) || typeof fn.name !== 'string') {
+        return null;
+    }
+    const parameters = castToolParameters(fn.parameters);
+    const description = typeof fn.description === 'string' ? fn.description : undefined;
+    const strictFlag = fn.strict === true || tool.strict === true;
+    return {
+        type: 'function',
+        function: {
+            name: fn.name,
+            description,
+            parameters,
+            strict: strictFlag ? true : undefined
+        }
+    };
+}
+function castCustomTool(tool) {
+    if (!isRecord(tool)) {
+        return null;
+    }
+    const type = typeof tool.type === 'string' ? tool.type.toLowerCase() : '';
+    const name = typeof tool.name === 'string' ? tool.name : '';
+    if (type !== 'custom' || !name) {
+        return null;
+    }
+    if (name.trim() !== 'apply_patch') {
+        return null;
+    }
+    const description = typeof tool.description === 'string' ? tool.description : undefined;
+    return {
+        type: 'function',
+        function: {
+            name: 'apply_patch',
+            description,
+            parameters: {
+                type: 'object',
+                properties: {
+                    patch: {
+                        type: 'string',
+                        description: 'Unified diff patch content (FREEFORM, not JSON)'
+                    }
+                },
+                required: ['patch'],
+                additionalProperties: false
+            },
+            strict: true
+        }
+    };
+}
+function castToolParameters(value) {
+    if (isRecord(value)) {
+        const properties = value.properties && typeof value.properties === 'object'
+            ? value.properties
+            : {};
+        const required = Array.isArray(value.required) ? value.required : undefined;
+        const additionalProperties = typeof value.additionalProperties === 'boolean' ? value.additionalProperties : undefined;
+        return {
+            type: 'object',
+            properties,
+            required,
+            additionalProperties
+        };
+    }
+    return {
+        type: 'object',
+        properties: {},
+        additionalProperties: true
     };
 }
+function normalizeRecord(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+function deepClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function readString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function readToolChoice(value) {
+    if (!value) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'object') {
+        return value;
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}