@jsonstudio/llms 0.4.3 → 0.4.4

package/dist/sse/types/utility-types.d.ts

@@ -2,6 +2,7 @@
  * 工具类型定义
  * 提供JSON↔SSE双向转换中常用的工具类型和辅助函数
  */
+import type { JsonObject, JsonValue } from './core-interfaces.js';
 export type ProtocolType = 'chat' | 'responses';
 export type ConversionDirection = 'json_to_sse' | 'sse_to_json';
 export interface EventTypeMap {
@@ -17,9 +18,9 @@ export interface EventTypeMap {
 export interface GenericConverter<TProtocol extends ProtocolType, TDirection extends ConversionDirection> {
     protocol: TProtocol;
     direction: TDirection;
-    convert(input: any, options: any): Promise<any>;
-    validate?(input: any): boolean;
-    getStats?(): any;
+    convert(input: unknown, options: JsonObject): Promise<unknown>;
+    validate?(input: unknown): boolean;
+    getStats?(): JsonObject;
 }
 export interface UnifiedConversionOptions {
     requestId: string;
@@ -34,12 +35,12 @@ export interface UnifiedConversionOptions {
     onError?: (error: Error) => void;
     onComplete?: () => void;
 }
-export interface UnifiedEventStream extends AsyncIterable<any> {
+export interface UnifiedEventStream extends AsyncIterable<unknown> {
     protocol: ProtocolType;
     direction: ConversionDirection;
     requestId: string;
-    getStats(): any;
-    getConfig(): any;
+    getStats(): JsonObject;
+    getConfig(): JsonObject;
     pause?(): void;
     resume?(): void;
     complete(): void;
@@ -47,7 +48,7 @@ export interface UnifiedEventStream extends AsyncIterable<any> {
     on?(event: 'error', handler: (error: Error) => void): this;
     on?(event: 'complete', handler: () => void): this;
     on?(event: 'timeout', handler: () => void): this;
-    on?(event: 'stats', handler: (stats: any) => void): this;
+    on?(event: 'stats', handler: (stats: JsonObject) => void): this;
 }
 export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type RequireKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;
@@ -58,8 +59,8 @@ export interface ChatJsonType {
     object: 'chat.completion' | 'chat.completion.chunk';
     created: number;
     model: string;
-    choices: any[];
-    usage?: any;
+    choices: unknown[];
+    usage?: JsonObject;
 }
 export type ChatSseEventType = 'chat_chunk' | 'chat.done' | 'error' | 'ping';
 export interface ResponsesJsonType {
@@ -68,11 +69,11 @@ export interface ResponsesJsonType {
     created_at: number;
     model: string;
     status: string;
-    output: any[];
-    usage?: any;
+    output: unknown[];
+    usage?: JsonObject;
 }
 export type ResponsesSseEventType = 'response.created' | 'response.in_progress' | 'response.completed' | 'response.required_action' | 'response.done' | 'response.output_item.added' | 'response.output_item.done' | 'response.content_part.added' | 'response.content_part.done' | 'response.output_text.delta' | 'response.output_text.done' | 'response.reasoning_text.delta' | 'response.reasoning_text.done' | 'response.function_call_arguments.delta' | 'response.function_call_arguments.done';
-export interface ConversionResult<TSuccess = any, TError = Error> {
+export interface ConversionResult<TSuccess = unknown, TError = Error> {
     success: boolean;
     data?: TSuccess;
     error?: TError;
@@ -84,7 +85,7 @@ export interface ConversionResult<TSuccess = any, TError = Error> {
         direction: ConversionDirection;
     };
 }
-export type AsyncConversionResult<TSuccess = any, TError = Error> = Promise<ConversionResult<TSuccess, TError>>;
+export type AsyncConversionResult<TSuccess = unknown, TError = Error> = Promise<ConversionResult<TSuccess, TError>>;
 export interface ConverterFactory {
     createJsonToSseConverter<TProtocol extends ProtocolType>(protocol: TProtocol, options: UnifiedConversionOptions): GenericConverter<TProtocol, 'json_to_sse'>;
     createSseToJsonConverter<TProtocol extends ProtocolType>(protocol: TProtocol, options: UnifiedConversionOptions): GenericConverter<TProtocol, 'sse_to_json'>;
@@ -95,7 +96,7 @@ export interface ConverterRegistry {
     list(): Array<{
         protocol: ProtocolType;
         direction: ConversionDirection;
-        converter: GenericConverter<any, any>;
+        converter: GenericConverter<ProtocolType, ConversionDirection>;
     }>;
 }
 export interface Validator<T> {
@@ -112,13 +113,13 @@ export interface ValidationError {
     code: string;
     message: string;
     path: string;
-    value?: any;
+    value?: JsonValue;
 }
 export interface ValidationWarning {
     code: string;
     message: string;
     path: string;
-    value?: any;
+    value?: JsonValue;
 }
 export interface Serializer<T> {
     serialize(input: T): string;
@@ -138,14 +139,15 @@ export interface MetricsCollector {
     recordHistogram(name: string, value: number, tags?: Record<string, string>): void;
     setGauge(name: string, value: number, tags?: Record<string, string>): void;
     recordTimer(name: string, duration: number, tags?: Record<string, string>): void;
-    getMetrics(): Record<string, any>;
+    getMetrics(): Record<string, unknown>;
 }
+type LoggerMetadata = Record<string, unknown>;
 export interface Logger {
-    debug(message: string, meta?: any): void;
-    info(message: string, meta?: any): void;
-    warn(message: string, meta?: any): void;
-    error(message: string, error?: Error, meta?: any): void;
-    child(meta: any): Logger;
+    debug(message: string, meta?: LoggerMetadata): void;
+    info(message: string, meta?: LoggerMetadata): void;
+    warn(message: string, meta?: LoggerMetadata): void;
+    error(message: string, error?: Error, meta?: LoggerMetadata): void;
+    child(meta: LoggerMetadata): Logger;
 }
 export interface RetryConfig {
     maxAttempts: number;
@@ -175,26 +177,27 @@ export interface HealthCheck {
 export interface HealthStatus {
     healthy: boolean;
     timestamp: number;
-    details?: Record<string, any>;
+    details?: Record<string, unknown>;
 }
+type LifecycleContext = Record<string, unknown>;
 export interface LifecycleHooks {
-    beforeConversion?: (context: any) => Promise<void>;
-    afterConversion?: (context: any, result: any) => Promise<void>;
-    onError?: (context: any, error: Error) => Promise<void>;
-    onTimeout?: (context: any) => Promise<void>;
-    onRetry?: (context: any, attempt: number) => Promise<void>;
+    beforeConversion?: (context: LifecycleContext) => Promise<void>;
+    afterConversion?: (context: LifecycleContext, result: unknown) => Promise<void>;
+    onError?: (context: LifecycleContext, error: Error) => Promise<void>;
+    onTimeout?: (context: LifecycleContext) => Promise<void>;
+    onRetry?: (context: LifecycleContext, attempt: number) => Promise<void>;
 }
 export interface Middleware {
     name: string;
     priority: number;
-    beforeConversion?: (context: any) => Promise<void>;
-    afterConversion?: (context: any, result: any) => Promise<void>;
-    onError?: (context: any, error: Error) => Promise<void>;
+    beforeConversion?: (context: LifecycleContext) => Promise<void>;
+    afterConversion?: (context: LifecycleContext, result: unknown) => Promise<void>;
+    onError?: (context: LifecycleContext, error: Error) => Promise<void>;
 }
 export interface Plugin {
     name: string;
     version: string;
-    initialize(context: any): Promise<void>;
+    initialize(context: LifecycleContext): Promise<void>;
     destroy(): Promise<void>;
     getMiddlewares(): Middleware[];
     getHooks(): LifecycleHooks;
@@ -209,22 +212,23 @@ export interface EnvironmentParser {
     getNumber(key: string, defaultValue?: number): number;
     getBoolean(key: string, defaultValue?: boolean): boolean;
     getArray(key: string, delimiter?: string): string[];
-    getObject(key: string): any;
+    getObject(key: string): JsonObject;
 }
 export declare const TypeGuards: {
-    isString: (value: any) => value is string;
-    isNumber: (value: any) => value is number;
-    isBoolean: (value: any) => value is boolean;
-    isObject: (value: any) => value is object;
-    isArray: (value: any) => value is any[];
-    isFunction: (value: any) => value is Function;
-    isDate: (value: any) => value is Date;
-    isNull: (value: any) => value is null;
-    isUndefined: (value: any) => value is undefined;
-    isNullOrUndefined: (value: any) => value is null | undefined;
+    isString: (value: unknown) => value is string;
+    isNumber: (value: unknown) => value is number;
+    isBoolean: (value: unknown) => value is boolean;
+    isObject: (value: unknown) => value is JsonObject;
+    isArray: (value: unknown) => value is JsonValue[];
+    isFunction: (value: unknown) => value is (...args: unknown[]) => unknown;
+    isDate: (value: unknown) => value is Date;
+    isNull: (value: unknown) => value is null;
+    isUndefined: (value: unknown) => value is undefined;
+    isNullOrUndefined: (value: unknown) => value is null | undefined;
 };
 export declare const AsyncUtils: {
     delay: (ms: number) => Promise<void>;
     timeout: <T>(promise: Promise<T>, ms: number) => Promise<T>;
     retry: <T>(fn: () => Promise<T>, config: RetryConfig) => Promise<T>;
 };
+export {};

package/dist/sse/types/utility-types.js

@@ -5,15 +5,15 @@
 // 类型守卫工具函数
 export const TypeGuards = {
     isString: (value) => typeof value === 'string',
-    isNumber: (value) => typeof value === 'number' && !isNaN(value),
+    isNumber: (value) => typeof value === 'number' && !Number.isNaN(value),
     isBoolean: (value) => typeof value === 'boolean',
-    isObject: (value) => value !== null && typeof value === 'object',
+    isObject: (value) => value !== null && typeof value === 'object' && !Array.isArray(value),
     isArray: (value) => Array.isArray(value),
     isFunction: (value) => typeof value === 'function',
     isDate: (value) => value instanceof Date,
     isNull: (value) => value === null,
     isUndefined: (value) => value === undefined,
-    isNullOrUndefined: (value) => value == null
+    isNullOrUndefined: (value) => value === null || value === undefined
 };
 // 异步工具函数
 export const AsyncUtils = {
@@ -31,19 +31,16 @@ export const AsyncUtils = {
                 return await fn();
             }
             catch (error) {
-                lastError = error;
-                if (!config.retryableErrors.includes(error.name) || attempt === config.maxAttempts) {
-                    throw error;
+                const normalizedError = error instanceof Error ? error : new Error(String(error));
+                lastError = normalizedError;
+                if (!config.retryableErrors.includes(normalizedError.name) || attempt === config.maxAttempts) {
+                    throw normalizedError;
                 }
                 const delay = Math.min(config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt - 1), config.maxDelayMs);
-                if (config.jitter) {
-                    await AsyncUtils.delay(delay + Math.random() * delay * 0.1);
-                }
-                else {
-                    await AsyncUtils.delay(delay);
-                }
+                const jitter = config.jitter ? Math.random() * delay * 0.1 : 0;
+                await AsyncUtils.delay(delay + jitter);
             }
         }
-        throw lastError;
+        throw lastError ?? new Error('Operation failed after retry attempts');
     }
 };

package/dist/tools/tool-registry.js

@@ -1,21 +1,77 @@
-function tryParse(s) {
+// Tool registry and validator (single source of truth)
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const asString = (value) => {
+    if (typeof value === 'string' && value.trim().length > 0) {
+        return value;
+    }
+    return null;
+};
+const asStringArray = (value) => {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    const normalized = [];
+    for (const entry of value) {
+        if (typeof entry !== 'string' || entry.trim().length === 0) {
+            return null;
+        }
+        normalized.push(entry);
+    }
+    return normalized;
+};
+const readBoolean = (value) => typeof value === 'boolean' ? value : undefined;
+const readNumber = (value) => {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return undefined;
+    }
+    return value;
+};
+const tryParseJson = (input) => {
     try {
-        const v = JSON.parse(s);
-        return (v && typeof v === 'object') ? v : {};
+        const parsed = JSON.parse(input);
+        return isRecord(parsed) ? parsed : {};
     }
     catch {
         return {};
     }
-}
-function isImagePath(p) {
+};
+const toJson = (value) => {
     try {
-        const s = String(p || '').toLowerCase();
-        return /\.(png|jpg|jpeg|gif|webp|bmp|svg|tiff?|ico|heic|jxl)$/.test(s);
+        return JSON.stringify(value ?? {});
     }
     catch {
+        return '{}';
+    }
+};
+const detectForbiddenWrite = (script) => {
+    const normalized = script.toLowerCase();
+    if (!normalized) {
         return false;
     }
-}
+    if (/>\s*[^\s<]/.test(normalized)) {
+        return true;
+    }
+    if (/<<</.test(normalized) || /<</.test(normalized)) {
+        return true;
+    }
+    if (/\bsed\b[^\n]*-i\b/.test(normalized)) {
+        return true;
+    }
+    if (/\bed\b[^\n]*-s\b/.test(normalized)) {
+        return true;
+    }
+    if (/\btee\b\s+/.test(normalized)) {
+        return true;
+    }
+    return false;
+};
+const isImagePath = (value) => {
+    const pathValue = asString(value);
+    if (!pathValue) {
+        return false;
+    }
+    return /\.(png|jpg|jpeg|gif|webp|bmp|svg|tiff?|ico|heic|jxl)$/i.test(pathValue);
+};
 export function getAllowedToolNames() {
     return [
         'shell',
@@ -24,131 +80,133 @@ export function getAllowedToolNames() {
         'view_image',
         'list_mcp_resources',
         'read_mcp_resource',
-        'list_mcp_resource_templates',
+        'list_mcp_resource_templates'
     ];
 }
-function detectForbiddenWrite(script) {
-    const s = script.toLowerCase();
-    if (!s)
-        return false;
-    // forbid common write patterns via shell
-    if (/>\s*[^\s<]/.test(s))
-        return true; // redirection
-    if (/<<</.test(s) || /<</.test(s))
-        return true; // heredoc
-    if (/\bsed\b[^\n]*\-i\b/.test(s))
-        return true;
-    if (/\bed\b[^\n]*\-s\b/.test(s))
-        return true;
-    if (/\btee\b\s+/.test(s))
-        return true;
-    return false;
-}
 export function validateToolCall(name, argsString) {
-    const nm = String(name || '').trim();
-    if (!nm)
+    const normalizedName = String(name || '').trim();
+    if (!normalizedName) {
         return { ok: false, reason: 'empty_tool_name' };
+    }
     const allowed = new Set(getAllowedToolNames());
-    if (!allowed.has(nm))
+    if (!allowed.has(normalizedName)) {
         return { ok: false, reason: 'unknown_tool' };
-    // Parse args once
-    const rawObj = tryParse(typeof argsString === 'string' ? argsString : '{}');
-    const toJson = (v) => { try {
-        return JSON.stringify(v ?? {});
     }
-    catch {
-        return '{}';
-    } };
-    switch (nm) {
+    const rawArgs = tryParseJson(typeof argsString === 'string' ? argsString : '{}');
+    switch (normalizedName) {
         case 'apply_patch': {
-            const patch = rawObj?.patch;
-            if (typeof patch !== 'string' || patch.trim().length === 0) {
+            const patch = asString(rawArgs.patch);
+            if (!patch) {
                 return { ok: false, reason: 'missing_patch' };
             }
             return { ok: true, normalizedArgs: toJson({ patch }) };
         }
         case 'shell': {
-            let cmd = rawObj?.command;
-            // Accept string command and coerce to argv array
-            if (typeof cmd === 'string' && cmd.trim().length) {
-                cmd = [cmd];
+            const rawCommand = rawArgs.command;
+            let normalizedCommand = null;
+            if (typeof rawCommand === 'string') {
+                normalizedCommand = [rawCommand];
+            }
+            else {
+                normalizedCommand = asStringArray(rawCommand);
             }
-            if (!Array.isArray(cmd) || !cmd.every((x) => typeof x === 'string')) {
+            if (!normalizedCommand) {
                 return { ok: false, reason: 'invalid_command' };
             }
-            // 统一 bash -lc 处理：
-            // - 当命令包含管道/与或/分号等元字符时，若未显式使用 bash -lc，则折叠为 ['bash','-lc','<script>']
-            // - 对写入型重定向/heredoc/sed -i 等仍然严格拒绝（要求使用 apply_patch）
-            const joinScript = (arr) => arr.join(' ');
-            const looksBashLc = (arr) => arr.length >= 2 && arr[0] === 'bash' && arr[1] === '-lc';
-            const hasMeta = (s) => /[|;&]/.test(s) || s.includes('&&') || s.includes('||');
-            const scriptJoined = joinScript(cmd);
-            // 拒绝危险写入模式
+            const scriptJoined = normalizedCommand.join(' ');
             if (detectForbiddenWrite(scriptJoined)) {
                 return { ok: false, reason: 'forbidden_write_redirection' };
             }
-            let finalCmd = cmd.slice();
-            if (!looksBashLc(finalCmd) && hasMeta(scriptJoined)) {
-                finalCmd = ['bash', '-lc', scriptJoined];
-            }
-            const out = { command: finalCmd };
-            if (typeof rawObj?.workdir === 'string')
-                out.workdir = rawObj.workdir;
-            if (typeof rawObj?.timeout_ms === 'number')
-                out.timeout_ms = rawObj.timeout_ms;
-            if (typeof rawObj?.with_escalated_permissions === 'boolean')
-                out.with_escalated_permissions = rawObj.with_escalated_permissions;
-            if (typeof rawObj?.justification === 'string')
-                out.justification = rawObj.justification;
-            return { ok: true, normalizedArgs: toJson(out) };
+            const looksBashLc = (arr) => arr.length >= 2 && arr[0] === 'bash' && arr[1] === '-lc';
+            const hasMetaChars = (script) => /[|;&]/.test(script) || script.includes('&&') || script.includes('||');
+            let finalCommand = normalizedCommand.slice();
+            if (!looksBashLc(finalCommand) && hasMetaChars(scriptJoined)) {
+                finalCommand = ['bash', '-lc', scriptJoined];
+            }
+            const shellArgs = { command: finalCommand };
+            const workdir = asString(rawArgs.workdir);
+            if (workdir) {
+                shellArgs.workdir = workdir;
+            }
+            const timeout = readNumber(rawArgs.timeout_ms);
+            if (timeout !== undefined) {
+                shellArgs.timeout_ms = timeout;
+            }
+            const escalated = readBoolean(rawArgs.with_escalated_permissions);
+            if (typeof escalated === 'boolean') {
+                shellArgs.with_escalated_permissions = escalated;
+            }
+            const justification = asString(rawArgs.justification);
+            if (justification) {
+                shellArgs.justification = justification;
+            }
+            return { ok: true, normalizedArgs: toJson(shellArgs) };
         }
         case 'update_plan': {
-            const plan = rawObj?.plan;
-            if (!Array.isArray(plan))
+            if (!Array.isArray(rawArgs.plan)) {
                 return { ok: false, reason: 'missing_plan' };
-            // warn for >1 in_progress
-            let inProg = 0;
-            for (const it of plan) {
-                if (it && typeof it === 'object' && it.status === 'in_progress')
-                    inProg += 1;
+            }
+            let inProgressCount = 0;
+            for (const entry of rawArgs.plan) {
+                if (isRecord(entry) && entry.status === 'in_progress') {
+                    inProgressCount += 1;
+                }
             }
             const warnings = [];
-            if (inProg > 1)
-                warnings.push({ kind: 'multiple_in_progress', count: inProg });
-            return { ok: true, warnings: warnings.length ? warnings : undefined, normalizedArgs: toJson({ explanation: rawObj?.explanation, plan }) };
+            if (inProgressCount > 1) {
+                warnings.push({ kind: 'multiple_in_progress', count: inProgressCount });
+            }
+            const explanation = asString(rawArgs.explanation);
+            return {
+                ok: true,
+                warnings: warnings.length ? warnings : undefined,
+                normalizedArgs: toJson({ explanation, plan: rawArgs.plan })
+            };
         }
         case 'view_image': {
-            const path = rawObj?.path;
-            if (typeof path !== 'string' || !isImagePath(path))
+            const pathValue = asString(rawArgs.path);
+            if (!pathValue || !isImagePath(pathValue)) {
                 return { ok: false, reason: 'invalid_image_path' };
-            return { ok: true, normalizedArgs: toJson({ path }) };
+            }
+            return { ok: true, normalizedArgs: toJson({ path: pathValue }) };
         }
         case 'list_mcp_resources': {
-            // all optional; no heavy validation here
-            const out = {};
-            if (typeof rawObj?.server === 'string')
-                out.server = rawObj.server;
-            if (typeof rawObj?.filter === 'string')
-                out.filter = rawObj.filter;
-            if (typeof rawObj?.root === 'string')
-                out.root = rawObj.root;
-            return { ok: true, normalizedArgs: toJson(out) };
+            const payload = {};
+            const server = asString(rawArgs.server);
+            if (server) {
+                payload.server = server;
+            }
+            const filter = asString(rawArgs.filter);
+            if (filter) {
+                payload.filter = filter;
+            }
+            const root = asString(rawArgs.root);
+            if (root) {
+                payload.root = root;
+            }
+            return { ok: true, normalizedArgs: toJson(payload) };
         }
         case 'read_mcp_resource': {
-            const server = rawObj?.server;
-            const uri = rawObj?.uri;
-            if (typeof server !== 'string' || typeof uri !== 'string')
+            const server = asString(rawArgs.server);
+            const uri = asString(rawArgs.uri);
+            if (!server || !uri) {
                 return { ok: false, reason: 'missing_server_or_uri' };
+            }
             return { ok: true, normalizedArgs: toJson({ server, uri }) };
         }
         case 'list_mcp_resource_templates': {
-            const out = {};
-            if (typeof rawObj?.server === 'string')
-                out.server = rawObj.server;
-            if (typeof rawObj?.cursor === 'string')
-                out.cursor = rawObj.cursor;
-            return { ok: true, normalizedArgs: toJson(out) };
+            const payload = {};
+            const server = asString(rawArgs.server);
+            if (server) {
+                payload.server = server;
+            }
+            const cursor = asString(rawArgs.cursor);
+            if (cursor) {
+                payload.cursor = cursor;
+            }
+            return { ok: true, normalizedArgs: toJson(payload) };
         }
+        default:
+            return { ok: false, reason: 'unknown_tool' };
     }
-    return { ok: false, reason: 'unknown_tool' };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -8,6 +8,8 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "build:dev": "tsc -p tsconfig.json",
+    "lint": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache",
+    "lint:fix": "eslint --no-eslintrc -c .eslintrc.json src --ext .ts --no-cache --fix",
     "postbuild": "node scripts/tests/run-matrix-ci.mjs",
     "verif": "node scripts/tests/run-matrix-ci.mjs",
     "verif:bridge": "node scripts/tests/run-cross-bridge-ci.mjs",
@@ -18,16 +20,11 @@
     "capture:chat:lmstudio": "node scripts/tools/capture-chat-golden-lmstudio.mjs",
     "capture:chat:modelscope": "node scripts/tools/capture-chat-golden-modelscope.mjs",
     "test:matrix": "npm run build:dev && node scripts/tests/run-matrix-ci.mjs",
-    "test:phase2": "npm run build && node scripts/tests/run-phase2a.mjs",
-    "test:phase3-sse": "npm run build && node scripts/tests/sse-node-roundtrip.mjs",
-    "test:anthropic-sse": "npm run build && node scripts/tests/anthropic-sse-node-roundtrip.mjs",
-    "test:anthropic-node": "npm run build && node scripts/tests/anthropic-node-roundtrip.mjs",
     "capture:anthropic:golden": "node scripts/tools/capture-anthropic-golden.mjs --config $HOME/.routecodex/provider/glm-anthropic/config.json --prompt 'Say hi in one sentence'",
     "test:anthropic-golden": "npm run build && node scripts/tests/anthropic-golden-roundtrip.mjs",
     "test:looprt:gemini": "npm run build && node scripts/tests/loop-rt-gemini.mjs",
     "replay:responses:chat-sse": "node scripts/exp3-responses-sse-to-chat-sse.mjs",
     "replay:responses:loop": "node scripts/exp4-responses-sse-loop.mjs",
-    "replay:chat:bridge": "node scripts/exp5-chat-direct-bridge.mjs",
     "test:virtual-router": "npm run build:dev && node scripts/tests/virtual-router-dry-run.mjs",
     "test:virtual-router-health": "npm run build:dev && node scripts/tests/virtual-router-health.mjs"
   },
@@ -56,10 +53,13 @@
   },
   "devDependencies": {
     "@types/node": "^20.11.25",
+    "@typescript-eslint/eslint-plugin": "^6.7.4",
+    "@typescript-eslint/parser": "^6.7.4",
+    "eslint": "^8.50.0",
     "typescript": "^5.4.0"
   },
   "files": [
     "dist",
     "README.md"
   ]
-}
+}

package/dist/api/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * LLMSwitch V2 API - 统一对外接口
- *
- * 提供 V2 版统一对外接口，保持向后兼容，同时支持新功能
- */
-export { LLMSwitchEngineV2 } from '../core/llmswitch-engine-v2.js';
-export { LLMSwitchFactoryV2, createLLMSwitchV2 } from '../core/llmswitch-factory-v2.js';
-export type { LLMSwitchV2Config, EndpointType, ProtocolType, ProcessingMode, LLMSwitchHookContext, LLMSwitchHookStage, SSEEvent, SSEProcessingResult, ProtocolConversionData, ToolProcessingData, LLMSwitchProcessingResult, LLMSwitchErrorInfo as LLMSwitchError, LLMSwitchMetrics, LLMSwitchHealthCheck, ILLMSwitchV2 } from './llmswitch-types.js';
-export type { ConfigValidationResult } from './llmswitch-config.js';
-export { DEFAULT_LLSWITCH_CONFIG, validateLLMSwitchConfig, mergeConfig, createConfigFromEnvironment } from './llmswitch-config.js';

package/dist/api/index.js

@@ -1,11 +0,0 @@
-/**
- * LLMSwitch V2 API - 统一对外接口
- *
- * 提供 V2 版统一对外接口，保持向后兼容，同时支持新功能
- */
-// 核心实现
-export { LLMSwitchEngineV2 } from '../core/llmswitch-engine-v2.js';
-export { LLMSwitchFactoryV2, createLLMSwitchV2 } from '../core/llmswitch-factory-v2.js';
-// 默认配置和验证
-export { DEFAULT_LLSWITCH_CONFIG, validateLLMSwitchConfig, mergeConfig, createConfigFromEnvironment } from './llmswitch-config.js';
-// V2 与 V1 解耦：不再从此处导出任何 V1 相关接口

package/dist/api/llmswitch-config.d.ts

@@ -1,15 +0,0 @@
-/**
- * LLMSwitch V2 配置类型和默认配置
- *
- * 定义LLMSwitch V2的配置结构、验证和默认值
- */
-import type { LLMSwitchV2Config } from './llmswitch-types.js';
-export declare const DEFAULT_LLSWITCH_CONFIG: LLMSwitchV2Config;
-export interface ConfigValidationResult {
-    valid: boolean;
-    errors: string[];
-    warnings: string[];
-}
-export declare function validateLLMSwitchConfig(config: Partial<LLMSwitchV2Config>): ConfigValidationResult;
-export declare function mergeConfig(base: LLMSwitchV2Config, override: Partial<LLMSwitchV2Config>): LLMSwitchV2Config;
-export declare function createConfigFromEnvironment(): Partial<LLMSwitchV2Config>;