@jsonstudio/llms 0.4.2 → 0.4.4

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

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

@@ -1,65 +0,0 @@
-/**
- * 核心转换适配器（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

@@ -1,183 +0,0 @@
-/**
- * 核心转换适配器（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

@@ -1,88 +0,0 @@
-/**
- * 错误工厂
- *
- * 提供统一的错误创建机制，遵循零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

@@ -1,138 +0,0 @@
-/**
- * 错误工厂
- *
- * 提供统一的错误创建机制，遵循零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);
-    }
-}