@jsonstudio/llms 0.4.2

package/dist/tools/web-fetch-html.js

@@ -0,0 +1,83 @@
+// Server-side raw HTML fetcher (no markdown conversion)
+// Stage A: standalone utility, not yet wired into tool governance.
+function sanitizeHeaders(h) {
+    if (!h)
+        return undefined;
+    const out = {};
+    const allow = new Set(["user-agent", "accept", "accept-language"]);
+    for (const [k, v] of Object.entries(h)) {
+        const key = String(k).toLowerCase();
+        if (!allow.has(key))
+            continue;
+        if (typeof v === 'string')
+            out[key] = v;
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+function isHtmlContentType(ct) {
+    if (!ct)
+        return false;
+    const s = ct.toLowerCase();
+    return s.includes('text/html');
+}
+export async function fetchRawHtml(url, opts = {}) {
+    try {
+        const u = new URL(String(url));
+        if (u.protocol !== 'https:' && u.protocol !== 'http:') {
+            return { ok: false, error: `unsupported_scheme: ${u.protocol}`, url };
+        }
+    }
+    catch {
+        return { ok: false, error: 'invalid_url', url };
+    }
+    const timeoutMs = typeof opts.timeoutMs === 'number' && opts.timeoutMs > 0 ? Math.min(opts.timeoutMs, 60000) : 15000;
+    const follow = opts.followRedirects !== false;
+    const maxBytes = typeof opts.maxBytes === 'number' && opts.maxBytes > 0 ? Math.min(opts.maxBytes, 5 * 1024 * 1024) : 512 * 1024;
+    const headers = sanitizeHeaders(opts.headers);
+    const ctrl = new AbortController();
+    const to = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+        const resp = await fetch(url, {
+            redirect: follow ? 'follow' : 'manual',
+            signal: ctrl.signal,
+            headers
+        });
+        const status = resp.status;
+        const ct = resp.headers.get('content-type');
+        if (!isHtmlContentType(ct)) {
+            return { ok: false, error: `unsupported_content_type: ${ct ?? 'unknown'}`, status, contentType: ct, url };
+        }
+        // If content-length provided and too big, abort early
+        const cl = resp.headers.get('content-length');
+        if (cl) {
+            const n = Number(cl);
+            if (!Number.isNaN(n) && n > maxBytes) {
+                return { ok: false, error: `content_too_large: ${n} > ${maxBytes}`, status, contentType: ct, url };
+            }
+        }
+        // Read text; enforce size after the fact if needed
+        const text = await resp.text();
+        const size = Buffer.byteLength(text, 'utf8');
+        if (size > maxBytes) {
+            // Truncate roughly to maxBytes
+            // Convert to Buffer and slice; may cut multi-byte boundaries but acceptable for raw preview use
+            const buf = Buffer.from(text, 'utf8');
+            const truncated = buf.subarray(0, maxBytes).toString('utf8');
+            return { ok: true, html: truncated, status, contentType: ct, url };
+        }
+        if (status < 200 || status >= 300) {
+            return { ok: false, error: `url_not_accessible: ${status}`, status, contentType: ct, url };
+        }
+        return { ok: true, html: text, status, contentType: ct, url };
+    }
+    catch (e) {
+        const msg = (e && typeof e.message === 'string') ? e.message : String(e);
+        if (msg && /aborted|timeout/i.test(msg)) {
+            return { ok: false, error: 'timeout', url };
+        }
+        return { ok: false, error: `network_error: ${msg}`, url };
+    }
+    finally {
+        clearTimeout(to);
+    }
+}

package/dist/utils/conversion-adapter.d.ts

@@ -0,0 +1,65 @@
+/**
+ * 核心转换适配器（V2）
+ *
+ * 不依赖旧版本符号，统一封装规范化、工具治理与协议桥接的入口。
+ */
+/**
+ * 核心适配器配置（V2）
+ */
+export interface CoreAdapterConfig {
+    baseDir?: string;
+    /** Legacy alias for pipelineConfigPath */
+    profilesPath?: string;
+    pipelineConfigPath?: string;
+    enableToolCanonicalization?: boolean;
+    enableRequestNormalization?: boolean;
+}
+/**
+ * 核心转换适配器（V2）
+ */
+export declare class CoreConversionAdapter {
+    private config;
+    private initialized;
+    constructor(config?: CoreAdapterConfig);
+    /**
+     * 初始化适配器
+     */
+    initialize(): Promise<void>;
+    /**
+     * 处理Chat请求（V2核心）
+     */
+    processChatRequest(request: any): Promise<any>;
+    /**
+     * 处理Messages请求（V2核心）
+     */
+    processMessagesRequest(request: any): Promise<any>;
+    /**
+     * 处理Responses请求（V2核心）
+     */
+    processResponsesRequest(request: any): Promise<any>;
+    /**
+     * 处理响应（V2核心）
+     */
+    processResponse(response: any, originalRequest: any, endpoint: string): Promise<any>;
+    /**
+     * 将Messages格式转换为Chat格式
+     */
+    private convertMessagesToChat;
+    /**
+     * 将Chat格式转换为Messages格式
+     */
+    private convertChatToMessages;
+    /**
+     * 将Responses格式转换为Chat格式
+     */
+    private convertResponsesToChat;
+    /**
+     * 将Chat格式转换为Responses格式
+     */
+    private convertChatToResponses;
+    /**
+     * 检查适配器是否可用
+     */
+    isAvailable(): boolean;
+}
+export declare const defaultCoreAdapter: CoreConversionAdapter;

package/dist/utils/conversion-adapter.js

@@ -0,0 +1,183 @@
+/**
+ * 核心转换适配器（V2）
+ *
+ * 不依赖旧版本符号，统一封装规范化、工具治理与协议桥接的入口。
+ */
+// SwitchOrchestrator removed; adapter no longer constructs pipelines
+import { normalizeChatRequest } from '../conversion/shared/openai-message-normalize.js';
+/**
+ * 核心转换适配器（V2）
+ */
+export class CoreConversionAdapter {
+    config;
+    initialized = false;
+    constructor(config = {}) {
+        this.config = {
+            baseDir: process.cwd(),
+            profilesPath: 'config/llmswitch/pipeline-config.json',
+            enableToolCanonicalization: true,
+            enableRequestNormalization: true,
+            ...config
+        };
+    }
+    /**
+     * 初始化适配器
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+    }
+    /**
+     * 处理Chat请求（V2核心）
+     */
+    async processChatRequest(request) {
+        if (!this.initialized)
+            await this.initialize();
+        let processedRequest = { ...request };
+        try {
+            // 规范化请求
+            processedRequest = this.config.enableRequestNormalization
+                ? normalizeChatRequest(request)
+                : request;
+            // Tool governance is now handled exclusively in ChatProcessNode (conversion-v3)
+            // Disabled to prevent bash double-wrapping
+            // processedRequest = await processChatRequestTools(processedRequest);
+            return processedRequest;
+        }
+        catch (error) {
+            console.warn('Chat请求处理失败，返回原始请求:', error);
+            return request;
+        }
+    }
+    /**
+     * 处理Messages请求（V2核心）
+     */
+    async processMessagesRequest(request) {
+        if (!this.initialized)
+            await this.initialize();
+        let processedRequest = { ...request };
+        try {
+            // 转换Anthropic格式到OpenAI格式进行处理
+            const chatFormatRequest = this.convertMessagesToChat(request);
+            // 使用Chat规范化逻辑
+            const processedChatRequest = await this.processChatRequest(chatFormatRequest);
+            // 转换回Messages格式
+            processedRequest = this.convertChatToMessages(processedChatRequest);
+            return processedRequest;
+        }
+        catch (error) {
+            console.warn('Messages请求处理失败，返回原始请求:', error);
+            return request;
+        }
+    }
+    /**
+     * 处理Responses请求（V2核心）
+     */
+    async processResponsesRequest(request) {
+        if (!this.initialized)
+            await this.initialize();
+        let processedRequest = { ...request };
+        try {
+            // 转换Responses格式到Chat格式进行处理
+            const chatFormatRequest = this.convertResponsesToChat(request);
+            // 使用Chat规范化逻辑
+            const processedChatRequest = await this.processChatRequest(chatFormatRequest);
+            // 转换回Responses格式
+            processedRequest = this.convertChatToResponses(processedChatRequest);
+            return processedRequest;
+        }
+        catch (error) {
+            console.warn('Responses请求处理失败，返回原始请求:', error);
+            return request;
+        }
+    }
+    /**
+     * 处理响应（V2核心）
+     */
+    async processResponse(response, originalRequest, endpoint) {
+        if (!this.initialized)
+            await this.initialize();
+        try {
+            return response;
+        }
+        catch (error) {
+            console.warn('响应处理失败，返回原始响应:', error);
+            return response;
+        }
+    }
+    /**
+     * 将Messages格式转换为Chat格式
+     */
+    convertMessagesToChat(messagesRequest) {
+        return {
+            model: messagesRequest.model,
+            messages: [
+                ...(messagesRequest.system ? [{ role: 'system', content: messagesRequest.system }] : []),
+                ...messagesRequest.messages
+            ],
+            tools: messagesRequest.tools,
+            temperature: messagesRequest.temperature,
+            max_tokens: messagesRequest.max_tokens,
+            stream: messagesRequest.stream
+        };
+    }
+    /**
+     * 将Chat格式转换为Messages格式
+     */
+    convertChatToMessages(chatRequest) {
+        const messages = chatRequest.messages || [];
+        const systemMessage = messages.find((m) => m.role === 'system');
+        const chatMessages = messages.filter((m) => m.role !== 'system');
+        return {
+            model: chatRequest.model,
+            messages: chatMessages,
+            system: systemMessage?.content,
+            tools: chatRequest.tools,
+            temperature: chatRequest.temperature,
+            max_tokens: chatRequest.max_tokens,
+            stream: chatRequest.stream
+        };
+    }
+    /**
+     * 将Responses格式转换为Chat格式
+     */
+    convertResponsesToChat(responsesRequest) {
+        return {
+            model: responsesRequest.model,
+            messages: [
+                {
+                    role: 'user',
+                    content: responsesRequest.input
+                }
+            ],
+            tools: responsesRequest.tools,
+            temperature: responsesRequest.temperature,
+            max_tokens: responsesRequest.max_tokens,
+            stream: responsesRequest.stream
+        };
+    }
+    /**
+     * 将Chat格式转换为Responses格式
+     */
+    convertChatToResponses(chatRequest) {
+        const messages = chatRequest.messages || [];
+        const lastMessage = messages[messages.length - 1];
+        return {
+            model: chatRequest.model,
+            input: typeof lastMessage?.content === 'string' ? lastMessage.content : '',
+            tools: chatRequest.tools,
+            temperature: chatRequest.temperature,
+            max_tokens: chatRequest.max_tokens,
+            stream: chatRequest.stream
+        };
+    }
+    /**
+     * 检查适配器是否可用
+     */
+    isAvailable() {
+        return this.initialized; // Orchestrator 可选
+    }
+}
+// 默认适配器实例
+export const defaultCoreAdapter = new CoreConversionAdapter();

package/dist/utils/error-factory.d.ts

@@ -0,0 +1,88 @@
+/**
+ * 错误工厂
+ *
+ * 提供统一的错误创建机制，遵循零fallback原则
+ */
+import type { LLMSwitchErrorInfo } from '../api/llmswitch-types.js';
+/**
+ * 错误类型枚举
+ */
+export declare enum ErrorType {
+    VALIDATION_ERROR = "validation_error",
+    CONVERSION_ERROR = "conversion_error",
+    PROCESSING_ERROR = "processing_error",
+    HOOK_ERROR = "hook_error",
+    TIMEOUT_ERROR = "timeout_error",
+    ENDPOINT_ERROR = "endpoint_error",
+    PROTOCOL_ERROR = "protocol_error",
+    TOOL_ERROR = "tool_error"
+}
+/**
+ * LLMSwitch标准错误类
+ */
+export declare class LLMSwitchError extends Error {
+    readonly code: string;
+    readonly type: ErrorType;
+    readonly details?: any;
+    readonly timestamp: number;
+    readonly context?: Record<string, any>;
+    constructor(type: ErrorType, message: string, code: string, details?: any, context?: Record<string, any>, cause?: Error);
+    toJSON(): LLMSwitchErrorInfo;
+}
+/**
+ * 错误工厂类
+ */
+export declare class ErrorFactory {
+    /**
+     * 创建验证错误
+     */
+    static validationError(message: string, code?: string, details?: any, context?: Record<string, any>): LLMSwitchError;
+    /**
+     * 创建转换错误
+     */
+    static conversionError(message: string, code?: string, details?: any, context?: Record<string, any>): LLMSwitchError;
+    /**
+     * 创建处理错误
+     */
+    static processingError(message: string, code?: string, details?: any, context?: Record<string, any>): LLMSwitchError;
+    /**
+     * 创建Hook错误
+     */
+    static hookError(message: string, code?: string, details?: any, context?: Record<string, any>): LLMSwitchError;
+    /**
+     * 创建超时错误
+     */
+    static timeoutError(message: string, code?: string, details?: any, context?: Record<string, any>): LLMSwitchError;
+    /**
+     * 创建端点错误
+     */
+    static endpointError(message: string, code?: string, details?: any, context?: Record<string, any>): LLMSwitchError;
+    /**
+     * 创建协议错误
+     */
+    static protocolError(message: string, code?: string, details?: any, context?: Record<string, any>): LLMSwitchError;
+    /**
+     * 创建工具错误
+     */
+    static toolError(message: string, code?: string, details?: any, context?: Record<string, any>): LLMSwitchError;
+    /**
+     * 创建缺失必需字段错误
+     */
+    static missingRequiredField(fieldName: string, details?: any): LLMSwitchError;
+    /**
+     * 创建无效参数错误
+     */
+    static invalidParameter(parameterName: string, reason?: string, details?: any): LLMSwitchError;
+    /**
+     * 创建不支持的操作错误
+     */
+    static unsupportedOperation(operation: string, details?: any): LLMSwitchError;
+    /**
+     * 从标准Error创建LLMSwitch错误
+     */
+    static fromStandardError(error: Error, type?: ErrorType, context?: Record<string, any>): LLMSwitchError;
+    /**
+     * 包装错误以包含必要的错误信息
+     */
+    static wrapError(error: Error, defaultType?: ErrorType, context?: Record<string, any>): LLMSwitchError;
+}

package/dist/utils/error-factory.js

@@ -0,0 +1,138 @@
+/**
+ * 错误工厂
+ *
+ * 提供统一的错误创建机制，遵循零fallback原则
+ */
+/**
+ * 错误类型枚举
+ */
+export var ErrorType;
+(function (ErrorType) {
+    ErrorType["VALIDATION_ERROR"] = "validation_error";
+    ErrorType["CONVERSION_ERROR"] = "conversion_error";
+    ErrorType["PROCESSING_ERROR"] = "processing_error";
+    ErrorType["HOOK_ERROR"] = "hook_error";
+    ErrorType["TIMEOUT_ERROR"] = "timeout_error";
+    ErrorType["ENDPOINT_ERROR"] = "endpoint_error";
+    ErrorType["PROTOCOL_ERROR"] = "protocol_error";
+    ErrorType["TOOL_ERROR"] = "tool_error";
+})(ErrorType || (ErrorType = {}));
+/**
+ * LLMSwitch标准错误类
+ */
+export class LLMSwitchError extends Error {
+    code;
+    type;
+    details;
+    timestamp;
+    context;
+    constructor(type, message, code, details, context, cause) {
+        super(message);
+        this.name = 'LLMSwitchError';
+        this.type = type;
+        this.message = message;
+        this.code = code;
+        this.details = details;
+        this.timestamp = Date.now();
+        this.context = context;
+        if (cause) {
+            this.stack = cause.stack;
+        }
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            message: this.message,
+            timestamp: this.timestamp,
+            context: this.context,
+            cause: this.cause
+        };
+    }
+}
+/**
+ * 错误工厂类
+ */
+export class ErrorFactory {
+    /**
+     * 创建验证错误
+     */
+    static validationError(message, code = 'VALIDATION_ERROR', details, context) {
+        return new LLMSwitchError(ErrorType.VALIDATION_ERROR, message, code, details, context);
+    }
+    /**
+     * 创建转换错误
+     */
+    static conversionError(message, code = 'CONVERSION_ERROR', details, context) {
+        return new LLMSwitchError(ErrorType.CONVERSION_ERROR, message, code, details, context);
+    }
+    /**
+     * 创建处理错误
+     */
+    static processingError(message, code = 'PROCESSING_ERROR', details, context) {
+        return new LLMSwitchError(ErrorType.PROCESSING_ERROR, message, code, details, context);
+    }
+    /**
+     * 创建Hook错误
+     */
+    static hookError(message, code = 'HOOK_ERROR', details, context) {
+        return new LLMSwitchError(ErrorType.HOOK_ERROR, message, code, details, context);
+    }
+    /**
+     * 创建超时错误
+     */
+    static timeoutError(message, code = 'TIMEOUT_ERROR', details, context) {
+        return new LLMSwitchError(ErrorType.TIMEOUT_ERROR, message, code, details, context);
+    }
+    /**
+     * 创建端点错误
+     */
+    static endpointError(message, code = 'ENDPOINT_ERROR', details, context) {
+        return new LLMSwitchError(ErrorType.ENDPOINT_ERROR, message, code, details, context);
+    }
+    /**
+     * 创建协议错误
+     */
+    static protocolError(message, code = 'PROTOCOL_ERROR', details, context) {
+        return new LLMSwitchError(ErrorType.PROTOCOL_ERROR, message, code, details, context);
+    }
+    /**
+     * 创建工具错误
+     */
+    static toolError(message, code = 'TOOL_ERROR', details, context) {
+        return new LLMSwitchError(ErrorType.TOOL_ERROR, message, code, details, context);
+    }
+    /**
+     * 创建缺失必需字段错误
+     */
+    static missingRequiredField(fieldName, details) {
+        return this.validationError(`Missing required field: ${fieldName}`, 'MISSING_FIELD', details);
+    }
+    /**
+     * 创建无效参数错误
+     */
+    static invalidParameter(parameterName, reason, details) {
+        const message = reason ? `Invalid parameter: ${parameterName} (${reason})` : `Invalid parameter: ${parameterName}`;
+        return this.validationError(message, 'INVALID_PARAMETER', details);
+    }
+    /**
+     * 创建不支持的操作错误
+     */
+    static unsupportedOperation(operation, details) {
+        return this.processingError(`Unsupported operation: ${operation}`, 'UNSUPPORTED_OPERATION', details);
+    }
+    /**
+     * 从标准Error创建LLMSwitch错误
+     */
+    static fromStandardError(error, type = ErrorType.PROCESSING_ERROR, context) {
+        return new LLMSwitchError(type, error.message, 'STANDARD_ERROR', { originalError: error }, context, error);
+    }
+    /**
+     * 包装错误以包含必要的错误信息
+     */
+    static wrapError(error, defaultType = ErrorType.PROCESSING_ERROR, context) {
+        if (error instanceof LLMSwitchError) {
+            return error;
+        }
+        return this.fromStandardError(error, defaultType, context);
+    }
+}