@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/sse/shared/utils.d.ts

@@ -1,254 +0,0 @@
-/**
- * 共享工具函数
- * 提供JSON↔SSE双向转换中常用的工具函数
- */
-import { Readable } from 'stream';
-/**
- * 字符串工具
- */
-export declare class StringUtils {
-    /**
-     * 安全地将值转换为字符串
-     */
-    static safeStringify(value: unknown): string;
-    /**
-     * 安全地解析JSON字符串
-     */
-    static safeParse<T = any>(text: string): T | null;
-    /**
-     * 检查字符串是否为空或只包含空白字符
-     */
-    static isEmpty(str: string): boolean;
-    /**
-     * 检查字符串是否为有效的JSON
-     */
-    static isValidJson(str: string): boolean;
-    /**
-     * 截断字符串到指定长度
-     */
-    static truncate(str: string, maxLength: number, suffix?: string): string;
-    /**
-     * 生成随机字符串
-     */
-    static random(length?: number): string;
-    /**
-     * 分割字符串为块
-     */
-    static chunkString(text: string, chunkSize: number, boundary: RegExp): string[];
-}
-/**
- * 对象工具
- */
-export declare class ObjectUtils {
-    /**
-     * 深度冻结对象
-     */
-    static deepFreeze<T>(obj: T): T;
-    /**
-     * 深度克隆对象
-     */
-    static deepClone<T>(obj: T): T;
-    /**
-     * 安全地获取嵌套对象属性
-     */
-    static get(obj: any, path: string, defaultValue?: any): any;
-    /**
-     * 安全地设置嵌套对象属性
-     */
-    static set(obj: any, path: string, value: any): void;
-    /**
-     * 检查对象是否为空
-     */
-    static isEmpty(obj: any): boolean;
-    /**
-     * 合并对象
-     */
-    static merge<T extends Record<string, any>>(target: T, source: Partial<T>): T;
-}
-/**
- * 数组工具
- */
-export declare class ArrayUtils {
-    /**
-     * 数组去重
-     */
-    static unique<T>(arr: T[]): T[];
-    /**
-     * 分组数组
-     */
-    static groupBy<T, K extends string | number>(arr: T[], keyFn: (item: T) => K): Record<K, T[]>;
-    /**
-     * 分块数组
-     */
-    static chunk<T>(arr: T[], size: number): T[][];
-    /**
-     * 扁平化数组
-     */
-    static flatten<T>(arr: (T | T[])[]): T[];
-    /**
-     * 找到数组中的差异
-     */
-    static diff<T>(arr1: T[], arr2: T[]): {
-        added: T[];
-        removed: T[];
-        common: T[];
-    };
-}
-/**
- * 时间工具
- */
-export declare class TimeUtils {
-    /**
-     * 获取当前时间戳（毫秒）
-     */
-    static now(): number;
-    /**
-     * 获取当前时间戳（秒）
-     */
-    static nowSeconds(): number;
-    /**
-     * 格式化时间戳
-     */
-    static formatTimestamp(timestamp: number, format?: string): string;
-    /**
-     * 延迟指定时间
-     */
-    static delay(ms: number): Promise<void>;
-    /**
-     * 带超时的Promise
-     */
-    static timeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T>;
-}
-/**
- * 验证工具
- */
-export declare class ValidationUtils {
-    /**
-     * 检查值是否为对象
-     */
-    static isObject(value: unknown): value is Record<string, unknown>;
-    /**
-     * 检查值是否为有效的ID
-     */
-    static isValidId(value: string, pattern: RegExp): boolean;
-    /**
-     * 验证序列号
-     */
-    static isValidSequenceNumber(value: number, max?: number): boolean;
-    /**
-     * 验证时间戳
-     */
-    static isValidTimestamp(value: number): boolean;
-    /**
-     * 验证JSON结构
-     */
-    static validateJsonStructure(obj: any, schema: any): {
-        valid: boolean;
-        errors: string[];
-    };
-}
-/**
- * 流工具
- */
-export declare class StreamUtils {
-    /**
-     * 创建可读流
-     */
-    static createReadable<T>(data: T[]): Readable;
-    /**
-     * 将异步生成器转换为流
-     */
-    static asyncGeneratorToStream<T>(generator: AsyncGenerator<T>): Readable;
-    /**
-     * 将流转换为数组
-     */
-    static streamToArray<T>(stream: Readable): Promise<T[]>;
-    /**
-     * 管道流超时
-     */
-    static pipeWithTimeout<T>(source: Readable, destination: NodeJS.WritableStream, timeoutMs: number): Promise<void>;
-}
-/**
- * ID生成工具
- */
-export declare class IdUtils {
-    /**
-     * 生成请求ID
-     */
-    static generateRequestId(): string;
-    /**
-     * 生成响应ID
-     */
-    static generateResponseId(): string;
-    /**
-     * 生成推理项目ID
-     */
-    static generateReasoningId(): string;
-    /**
-     * 生成函数调用ID
-     */
-    static generateFunctionCallId(): string;
-    /**
-     * 生成工具调用ID
-     */
-    static generateToolCallId(): string;
-    /**
-     * 生成消息ID
-     */
-    static generateMessageId(): string;
-}
-/**
- * 错误处理工具
- */
-export declare class ErrorUtils {
-    /**
-     * 创建标准错误
-     */
-    static createError(message: string, code: string, context?: any): Error & {
-        code: string;
-        context?: any;
-    };
-    /**
-     * 包装错误
-     */
-    static wrapError(error: unknown, context?: string): Error;
-    /**
-     * 判断是否为超时错误
-     */
-    static isTimeoutError(error: Error): boolean;
-    /**
-     * 判断是否为网络错误
-     */
-    static isNetworkError(error: Error): boolean;
-}
-/**
- * 正则表达式模式
- */
-export declare const REGEX_PATTERNS: {
-    readonly WORD_BOUNDARY: RegExp;
-};
-/**
- * 性能监控工具
- */
-export declare class PerformanceUtils {
-    /**
-     * 创建性能计时器
-     */
-    static createTimer(): () => number;
-    /**
-     * 测量函数执行时间
-     */
-    static measureTime<T>(fn: () => T | Promise<T>): Promise<{
-        result: T;
-        duration: number;
-    }>;
-    /**
-     * 创建内存使用快照
-     */
-    static createMemorySnapshot(): {
-        rss: number;
-        heapUsed: number;
-        heapTotal: number;
-        external: number;
-    };
-}

package/dist/sse/sse-to-json/parsers/sse-parser.d.ts

@@ -1,73 +0,0 @@
-/**
- * SSE事件解析器
- * 负责将SSE文本帧解析为标准化的SSE事件对象
- */
-import { BaseSseEvent } from '../../types/index.js';
-export interface SseParserConfig {
-    enableStrictValidation: boolean;
-    enableEventRecovery: boolean;
-    maxEventSize: number;
-    allowedEventTypes: Set<string>;
-}
-export interface SseParseResult {
-    success: boolean;
-    event?: BaseSseEvent;
-    error?: string;
-    rawData: string;
-}
-export declare const DEFAULT_SSE_PARSER_CONFIG: SseParserConfig;
-/**
- * SSE原始事件数据
- */
-export interface RawSseEvent {
-    id?: string;
-    event: string;
-    data: string;
-    retry?: string;
-    timestamp?: number;
-}
-/**
- * 将原始SSE行组装为事件
- */
-export declare function assembleSseEvent(lines: string[]): RawSseEvent | null;
-/**
- * 解析SSE事件文本为标准化事件对象
- */
-export declare function parseSseEvent(sseText: string, config?: SseParserConfig): SseParseResult;
-/**
- * 解析SSE流（处理多事件数据）
- */
-export declare function parseSseStream(sseData: string, config?: SseParserConfig): Generator<SseParseResult>;
-/**
- * 流式解析SSE数据
- */
-export declare function parseSseStreamAsync(asyncSseData: AsyncIterable<string>, config?: SseParserConfig): AsyncGenerator<SseParseResult>;
-/**
- * 创建SSE解析器工厂
- */
-export declare function createSseParser(config?: Partial<SseParserConfig>): {
-    /**
-     * 解析单个事件
-     */
-    parseEvent(sseText: string): SseParseResult;
-    /**
-     * 解析多事件流
-     */
-    parseStream(sseData: string): Generator<SseParseResult>;
-    /**
-     * 异步解析流
-     */
-    parseStreamAsync(asyncSseData: AsyncIterable<string>): AsyncGenerator<SseParseResult>;
-    /**
-     * 获取当前配置
-     */
-    getConfig(): SseParserConfig;
-    /**
-     * 添加允许的事件类型
-     */
-    addEventType(eventType: string): void;
-    /**
-     * 移除允许的事件类型
-     */
-    removeEventType(eventType: string): void;
-};

package/dist/tools/proxy/anthropic-tool-proxy.d.ts

@@ -1,19 +0,0 @@
-import type { ProxyPlan } from './types.js';
-export declare class AnthropicToolProxy {
-    constructor();
-    /**
-     * Inspect an Anthropic message (round-1) content blocks, execute supported
-     * tool_use blocks server-side, and return a plan of tool_result blocks.
-     */
-    buildProxyPlan(firstRoundAnthropicMessage: any): Promise<ProxyPlan>;
-    /**
-     * Build a second Anthropic Messages request payload by appending:
-     *  - assistant (original tool_use blocks)
-     *  - user (tool_result[] built from proxy plan)
-     */
-    buildSecondRoundPayload(originalAnthropicRequest: any, plan: ProxyPlan): any;
-}
-declare const _default: {
-    AnthropicToolProxy: typeof AnthropicToolProxy;
-};
-export default _default;

package/dist/tools/proxy/anthropic-tool-proxy.js

@@ -1,57 +0,0 @@
-import { GlobalToolRegistry } from './registry.js';
-import { WebFetchExecutor } from './executors/web-fetch.js';
-function registerDefaults() {
-    try {
-        GlobalToolRegistry.register(new WebFetchExecutor());
-    }
-    catch { }
-}
-export class AnthropicToolProxy {
-    constructor() { registerDefaults(); }
-    /**
-     * Inspect an Anthropic message (round-1) content blocks, execute supported
-     * tool_use blocks server-side, and return a plan of tool_result blocks.
-     */
-    async buildProxyPlan(firstRoundAnthropicMessage) {
-        const assistantBlocks = (firstRoundAnthropicMessage && typeof firstRoundAnthropicMessage === 'object' && Array.isArray(firstRoundAnthropicMessage.content))
-            ? firstRoundAnthropicMessage.content : [];
-        const out = [];
-        for (const b of assistantBlocks) {
-            try {
-                const t = String(b?.type || '').toLowerCase();
-                if (t !== 'tool_use')
-                    continue;
-                const name = String(b?.name || '');
-                const ex = GlobalToolRegistry.resolve(name);
-                if (!ex)
-                    continue;
-                const input = (b && typeof b === 'object') ? (b.input ?? {}) : {};
-                const result = await ex.execute(input);
-                const id = String(b?.id || '');
-                if (id)
-                    out.push({ tool_use_id: id, content: result.content });
-            }
-            catch { }
-        }
-        return { assistantBlocks, results: out };
-    }
-    /**
-     * Build a second Anthropic Messages request payload by appending:
-     *  - assistant (original tool_use blocks)
-     *  - user (tool_result[] built from proxy plan)
-     */
-    buildSecondRoundPayload(originalAnthropicRequest, plan) {
-        const messagesOrig = Array.isArray(originalAnthropicRequest?.messages) ? originalAnthropicRequest.messages : [];
-        const assistantMsg = { role: 'assistant', content: plan.assistantBlocks };
-        const userMsg = { role: 'user', content: plan.results.map(r => ({ type: 'tool_result', tool_use_id: r.tool_use_id, content: r.content })) };
-        return {
-            model: String(originalAnthropicRequest?.model || 'unknown'),
-            system: originalAnthropicRequest?.system,
-            tools: Array.isArray(originalAnthropicRequest?.tools) ? originalAnthropicRequest.tools : undefined,
-            messages: [...messagesOrig, assistantMsg, userMsg],
-            stream: true,
-            metadata: { ...(originalAnthropicRequest?.metadata || {}), entryEndpoint: '/v1/messages', stream: true }
-        };
-    }
-}
-export default { AnthropicToolProxy };

package/dist/tools/proxy/executors/web-fetch.d.ts

@@ -1,6 +0,0 @@
-import type { ToolExecutor, ToolExecutionResult } from '../types.js';
-export declare class WebFetchExecutor implements ToolExecutor {
-    readonly id = "web-fetch-executor";
-    readonly names: string[];
-    execute(input: unknown): Promise<ToolExecutionResult>;
-}

package/dist/tools/proxy/executors/web-fetch.js

@@ -1,39 +0,0 @@
-import { fetchRawHtml } from '../../web-fetch-html.js';
-import { htmlToMarkdown } from '../../../html-to-markdown.js';
-export class WebFetchExecutor {
-    id = 'web-fetch-executor';
-    // 仅接受唯一名称
-    names = ['web_fetch'];
-    async execute(input) {
-        try {
-            const obj = (input && typeof input === 'object') ? input : {};
-            const url = String(obj.url || obj.href || '');
-            // 输出格式：默认 html；当 format==='markdown' 或 clean===true 时输出 markdown
-            const fmt = String(obj.format || '').toLowerCase();
-            const wantsMarkdown = fmt === 'markdown' || obj.clean === true;
-            if (!url) {
-                return { ok: false, content: 'invalid_url', error: 'invalid_url' };
-            }
-            const r = await fetchRawHtml(url, {});
-            const ok = !!r && r.ok === true;
-            const html = ok ? (r.html || '') : (r.error || 'fetch_failed');
-            let content;
-            if (wantsMarkdown && ok) {
-                try {
-                    content = htmlToMarkdown(String(html));
-                }
-                catch {
-                    content = String(html);
-                }
-            }
-            else {
-                content = String(html);
-            }
-            const limited = content.slice(0, 200000);
-            return { ok, content: limited };
-        }
-        catch (e) {
-            return { ok: false, content: String(e?.message || 'error'), error: String(e?.message || 'error') };
-        }
-    }
-}

package/dist/tools/proxy/registry.d.ts

@@ -1,8 +0,0 @@
-import type { ToolExecutor } from './types.js';
-export declare class ToolRegistry {
-    private executors;
-    register(executor: ToolExecutor): void;
-    resolve(name: string): ToolExecutor | null;
-    has(name: string): boolean;
-}
-export declare const GlobalToolRegistry: ToolRegistry;

package/dist/tools/proxy/registry.js

@@ -1,14 +0,0 @@
-export class ToolRegistry {
-    executors = new Map();
-    register(executor) {
-        for (const n of executor.names) {
-            this.executors.set(n, executor);
-        }
-    }
-    resolve(name) {
-        const ex = this.executors.get(name);
-        return ex || null;
-    }
-    has(name) { return this.executors.has(name); }
-}
-export const GlobalToolRegistry = new ToolRegistry();

package/dist/tools/proxy/types.d.ts

@@ -1,29 +0,0 @@
-export type ToolUseBlock = {
-    type: string;
-    id?: string;
-    name?: string;
-    input?: unknown;
-};
-export type ToolResultBlock = {
-    type: 'tool_result';
-    tool_use_id: string;
-    content: string;
-};
-export interface ToolExecutionResult {
-    ok: boolean;
-    content: string;
-    error?: string;
-    meta?: Record<string, unknown>;
-}
-export interface ToolExecutor {
-    readonly id: string;
-    readonly names: string[];
-    execute(input: unknown): Promise<ToolExecutionResult>;
-}
-export interface ProxyPlan {
-    assistantBlocks: any[];
-    results: Array<{
-        tool_use_id: string;
-        content: string;
-    }>;
-}

package/dist/tools/tool-registry.d.ts

@@ -1,8 +0,0 @@
-export interface ToolValidationResult {
-    ok: boolean;
-    reason?: string;
-    warnings?: Array<Record<string, unknown>>;
-    normalizedArgs?: string;
-}
-export declare function getAllowedToolNames(): string[];
-export declare function validateToolCall(name: string, argsString: string): ToolValidationResult;

package/dist/tools/web-fetch-html.d.ts

@@ -1,15 +0,0 @@
-export interface WebFetchHtmlOptions {
-    timeoutMs?: number;
-    followRedirects?: boolean;
-    maxBytes?: number;
-    headers?: Record<string, string>;
-}
-export interface WebFetchHtmlResult {
-    ok: boolean;
-    html?: string;
-    error?: string;
-    status?: number;
-    contentType?: string | null;
-    url?: string;
-}
-export declare function fetchRawHtml(url: string, opts?: WebFetchHtmlOptions): Promise<WebFetchHtmlResult>;

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;