@jsonstudio/llms 0.4.2

package/dist/bridge/routecodex-adapter.js

@@ -0,0 +1,226 @@
+const DEFAULT_ENDPOINT = '/v1/chat/completions';
+function isJsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function asJsonObject(value) {
+    return isJsonObject(value) ? value : undefined;
+}
+function readString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function generateRequestId() {
+    return `req_${Date.now()}_${Math.floor(Math.random() * 1_000_000)}`;
+}
+function normalizeEndpoint(candidate) {
+    if (candidate && candidate.trim()) {
+        return candidate.trim();
+    }
+    return DEFAULT_ENDPOINT;
+}
+function inferProviderType(protocol) {
+    const value = (protocol ?? '').toLowerCase();
+    if (value.includes('anthropic'))
+        return 'anthropic';
+    if (value.includes('responses'))
+        return 'responses';
+    if (value.includes('gemini'))
+        return 'gemini';
+    return 'openai';
+}
+function buildContext(input) {
+    const envelope = input ?? {};
+    const route = asJsonObject(envelope.route);
+    const metadata = { ...(asJsonObject(envelope.metadata) ?? {}) };
+    const rootEntry = readString(envelope.entryEndpoint);
+    const routeId = readString(route?.requestId);
+    const dataWrapper = asJsonObject(envelope.data);
+    const dataEntry = readString(dataWrapper?.entryEndpoint);
+    const dataMeta = asJsonObject(dataWrapper?.metadata);
+    const metaEntry = readString(metadata.entryEndpoint);
+    const metaEndpoint = readString(metadata.endpoint);
+    const dataMetaEntry = readString(dataMeta?.entryEndpoint);
+    const endpoint = metaEndpoint ??
+        metaEntry ??
+        dataMetaEntry ??
+        dataEntry ??
+        rootEntry ??
+        DEFAULT_ENDPOINT;
+    const entryEndpoint = metaEntry ??
+        dataEntry ??
+        dataMetaEntry ??
+        rootEntry ??
+        endpoint;
+    const requestId = routeId ?? readString(metadata.requestId) ?? generateRequestId();
+    metadata.requestId = requestId;
+    metadata.endpoint = endpoint;
+    metadata.entryEndpoint = entryEndpoint;
+    return {
+        requestId,
+        endpoint: normalizeEndpoint(endpoint),
+        entryEndpoint: normalizeEndpoint(entryEndpoint),
+        metadata
+    };
+}
+function extractPayload(subject) {
+    if (!subject) {
+        return {};
+    }
+    if ('data' in subject && subject.data !== undefined) {
+        return subject.data;
+    }
+    if ('payload' in subject && subject.payload !== undefined) {
+        return subject.payload;
+    }
+    return subject;
+}
+function buildConversionEnvelope(payload, ctx, options, overrides) {
+    const endpoint = normalizeEndpoint(overrides?.endpoint ??
+        options?.entryEndpoint ??
+        ctx.entryEndpoint ??
+        ctx.endpoint);
+    const metadata = { ...ctx.metadata };
+    metadata.entryEndpoint = ctx.entryEndpoint || endpoint;
+    if (options?.processMode) {
+        metadata.processMode = options.processMode;
+    }
+    if (overrides?.metadata) {
+        Object.assign(metadata, overrides.metadata);
+    }
+    const providerProtocol = options?.providerProtocol ?? 'openai-chat';
+    const providerType = options?.providerType ?? inferProviderType(providerProtocol);
+    const streamSetting = metadata.stream;
+    const streamingFormat = streamSetting === true ? 'sse' : 'json';
+    return {
+        id: ctx.requestId || generateRequestId(),
+        timestamp: Date.now(),
+        endpoint,
+        payload,
+        metadata,
+        options: {
+            providerProtocol,
+            providerType,
+            processMode: options?.processMode,
+            streamingFormat,
+            stage: overrides?.stage ?? options?.stage,
+            direction: overrides?.direction ?? options?.direction
+        }
+    };
+}
+function prepareReturnPayload(envelope) {
+    return {
+        data: envelope.payload,
+        metadata: {
+            ...envelope.metadata,
+            conversionId: envelope.id,
+            conversionEndpoint: envelope.endpoint,
+            conversionStage: envelope.options.stage
+        }
+    };
+}
+class CoreAdapter {
+    options;
+    lastRequests = new Map();
+    constructor(opts) {
+        this.options = opts;
+    }
+    mergeOptions(opts) {
+        if (opts) {
+            this.options = { ...(this.options ?? {}), ...opts };
+        }
+    }
+    async processInboundRequest(request, opts) {
+        this.mergeOptions(opts);
+        const ctx = buildContext(request);
+        const body = extractPayload(request);
+        const entryEndpoint = opts?.entryEndpoint ?? ctx.entryEndpoint ?? ctx.endpoint;
+        const result = prepareReturnPayload(buildConversionEnvelope(body, ctx, { ...this.options, stage: 'inbound', direction: 'request' }, {
+            metadata: { direction: 'request' },
+            endpoint: entryEndpoint,
+            stage: 'inbound',
+            direction: 'request'
+        }));
+        this.lastRequests.set(ctx.requestId, body);
+        return result;
+    }
+    async processInboundResponse(response, opts) {
+        this.mergeOptions(opts);
+        const ctx = buildContext(response);
+        const body = extractPayload(response);
+        const entryEndpoint = opts?.entryEndpoint ?? ctx.entryEndpoint ?? ctx.endpoint;
+        const targetEndpoint = entryEndpoint.includes('#response')
+            ? entryEndpoint
+            : `${entryEndpoint}#response`;
+        return prepareReturnPayload(buildConversionEnvelope(body, ctx, { ...this.options, stage: 'inbound', direction: 'response' }, {
+            metadata: { direction: 'response' },
+            endpoint: targetEndpoint,
+            stage: 'inbound',
+            direction: 'response'
+        }));
+    }
+    async processOutboundRequest(request, opts) {
+        this.mergeOptions(opts);
+        const ctx = buildContext(request);
+        const body = extractPayload(request);
+        const entryEndpoint = opts?.entryEndpoint ?? ctx.entryEndpoint ?? ctx.endpoint;
+        return prepareReturnPayload(buildConversionEnvelope(body, ctx, { ...this.options, stage: 'outbound', direction: 'request' }, {
+            metadata: { direction: 'request' },
+            endpoint: entryEndpoint,
+            stage: 'outbound',
+            direction: 'request'
+        }));
+    }
+    async processOutboundResponse(response, opts) {
+        this.mergeOptions(opts);
+        const ctx = buildContext(response);
+        const body = extractPayload(response);
+        const entryEndpoint = opts?.entryEndpoint ?? ctx.entryEndpoint ?? ctx.endpoint;
+        const targetEndpoint = entryEndpoint.includes('#response')
+            ? entryEndpoint
+            : `${entryEndpoint}#response`;
+        const result = prepareReturnPayload(buildConversionEnvelope(body, ctx, { ...this.options, stage: 'outbound', direction: 'response' }, {
+            endpoint: targetEndpoint,
+            metadata: {
+                direction: 'response',
+                originalRequest: this.lastRequests.get(ctx.requestId) ?? {}
+            },
+            stage: 'outbound',
+            direction: 'response'
+        }));
+        return result;
+    }
+    async processIncoming(request, opts) {
+        return this.processInboundRequest(request, opts);
+    }
+    async processOutgoing(response, opts) {
+        const dto = await this.processOutboundResponse(response, opts);
+        return dto;
+    }
+}
+const singleton = new CoreAdapter();
+export async function processIncoming(request, options) {
+    return singleton.processIncoming(request, options);
+}
+export async function processOutgoing(response, options) {
+    return singleton.processOutgoing(response, options);
+}
+export async function processInboundRequest(request, options) {
+    return singleton.processInboundRequest(request, options);
+}
+export async function processInboundResponse(response, options) {
+    return singleton.processInboundResponse(response, options);
+}
+export async function processOutboundRequest(request, options) {
+    return singleton.processOutboundRequest(request, options);
+}
+export async function processOutboundResponse(response, options) {
+    const dto = await singleton.processOutboundResponse(response, options);
+    return dto;
+}
+export default {
+    processIncoming,
+    processOutgoing,
+    processInboundRequest,
+    processInboundResponse,
+    processOutboundRequest,
+    processOutboundResponse
+};

package/dist/config/index.d.ts

@@ -0,0 +1,3 @@
+/**
+ * 配置模块导出
+ */

package/dist/config/index.js

@@ -0,0 +1,5 @@
+/**
+ * 配置模块导出
+ */
+// TODO: 实现具体的配置文件
+// export { someConfig } from './some-config.js';

package/dist/config-unified/enhanced-path-resolver.d.ts

@@ -0,0 +1,5 @@
+export interface ResolvedPaths {
+    hostRoot: string;
+    configDir: string;
+}
+export declare function resolveHostPaths(): ResolvedPaths;

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

@@ -0,0 +1,38 @@
+// Enhanced path resolver for host application roots and config directory
+// Strategy:
+// 1) Prefer process.cwd()/config when present
+// 2) If running from inside llmswitch-core dist, scan upward to find a dir that contains 'config'
+// 3) Fallback to 'config' relative to current module
+import path from 'path';
+import fs from 'fs';
+export function resolveHostPaths() {
+    // Attempt 1: process.cwd()
+    try {
+        const cwd = process.cwd();
+        const cfg = path.join(cwd, 'config');
+        if (fs.existsSync(cfg))
+            return { hostRoot: cwd, configDir: cfg };
+    }
+    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))
+                break;
+            visited.add(cur);
+            const cfg = path.join(cur, 'config');
+            if (fs.existsSync(cfg))
+                return { hostRoot: cur, configDir: cfg };
+            const parent = path.dirname(cur);
+            if (parent === cur)
+                break;
+            cur = parent;
+        }
+    }
+    catch { /* ignore */ }
+    // Fallback to relative 'config'
+    const fallbackRoot = process.cwd();
+    return { hostRoot: fallbackRoot, configDir: path.join(fallbackRoot, 'config') };
+}

package/dist/config-unified/unified-config.d.ts

@@ -0,0 +1,26 @@
+export interface ContextBudget {
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+}
+export declare class UnifiedConfigFacade {
+    private static _instance;
+    static getInstance(): UnifiedConfigFacade;
+    private watchers;
+    private fsWatcher;
+    getContextBudgetForModel(modelId: string): ContextBudget;
+    validateConfig(): {
+        ok: boolean;
+        issues: string[];
+    };
+    watchConfig(cb: (ev: {
+        file: string;
+        event: string;
+    }) => void): void;
+    unwatchConfig(cb?: (ev: {
+        file: string;
+        event: string;
+    }) => void): void;
+}
+export declare const UnifiedConfig: UnifiedConfigFacade;

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

@@ -0,0 +1,187 @@
+// Unified configuration facade (minimal, focused on context budget for Phase 1)
+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) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function listMergedConfigs(configDir) {
+    try {
+        const files = fs.readdirSync(configDir)
+            .filter(n => /merged-config.*\.json$/i.test(n))
+            .map(n => path.join(configDir, n));
+        files.sort((a, b) => {
+            try {
+                const sa = fs.statSync(a);
+                const sb = fs.statSync(b);
+                return (sb.mtimeMs || 0) - (sa.mtimeMs || 0);
+            }
+            catch {
+                return 0;
+            }
+        });
+        return files;
+    }
+    catch {
+        return [];
+    }
+}
+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;
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+export class UnifiedConfigFacade {
+    static _instance = null;
+    static getInstance() {
+        if (!this._instance)
+            this._instance = new UnifiedConfigFacade();
+        return this._instance;
+    }
+    watchers = [];
+    fsWatcher = null;
+    // Phase 1: only context budget API
+    getContextBudgetForModel(modelId) {
+        const envDirect = Number(process.env.ROUTECODEX_CONTEXT_BUDGET_BYTES || process.env.RCC_CONTEXT_BUDGET_BYTES || '');
+        const envSafety = Number(process.env.RCC_CONTEXT_BUDGET_SAFETY || 'NaN');
+        const safetyFromEnv = (Number.isFinite(envSafety) && envSafety >= 0 && envSafety < 1) ? envSafety : NaN;
+        if (Number.isFinite(envDirect) && envDirect > 0) {
+            const safety = Number.isFinite(safetyFromEnv) ? safetyFromEnv : 0.1;
+            return { maxBytes: envDirect, safetyRatio: safety, allowedBytes: Math.floor(envDirect * (1 - safety)), source: 'env' };
+        }
+        const { configDir } = resolveHostPaths();
+        // modules.json defaults
+        let modulesDefault = null;
+        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;
+                }
+            }
+        }
+        catch { /* ignore */ }
+        // merged-config*.json
+        try {
+            const merged = listMergedConfigs(configDir);
+            for (const f of merged) {
+                const cfg = readJsonSync(f);
+                if (!cfg)
+                    continue;
+                const v = findMaxContextInConfig(cfg, modelId);
+                if (v && v > 0) {
+                    const safety = Number.isFinite(safetyFromEnv) ? safetyFromEnv : (modulesSafety ?? 0.1);
+                    return { maxBytes: v, safetyRatio: safety, allowedBytes: Math.floor(v * (1 - safety)), source: `merged:${path.basename(f)}` };
+                }
+            }
+        }
+        catch { /* ignore */ }
+        // config.json
+        try {
+            const cfg = readJsonSync(path.join(configDir, 'config.json'));
+            if (cfg) {
+                const v = findMaxContextInConfig(cfg, modelId);
+                if (v && v > 0) {
+                    const safety = Number.isFinite(safetyFromEnv) ? safetyFromEnv : (modulesSafety ?? 0.1);
+                    return { maxBytes: v, safetyRatio: safety, allowedBytes: Math.floor(v * (1 - safety)), source: 'config.json' };
+                }
+            }
+        }
+        catch { /* ignore */ }
+        // fallback
+        const def = modulesDefault && modulesDefault > 0 ? modulesDefault : 200_000;
+        const safety = Number.isFinite(safetyFromEnv) ? safetyFromEnv : (modulesSafety ?? 0.1);
+        return { maxBytes: def, safetyRatio: safety, allowedBytes: Math.floor(def * (1 - safety)), source: (modulesDefault ? 'modules.json' : 'default') };
+    }
+    // Minimal schema check for contextBudget fields in modules.json (Phase 1 scope)
+    validateConfig() {
+        const issues = [];
+        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))
+                        issues.push('contextBudget.defaultMaxContextBytes must be positive number');
+                    if (!(Number.isFinite(s) && s >= 0 && s < 1))
+                        issues.push('contextBudget.safetyRatio must be in [0,1)');
+                }
+            }
+        }
+        catch (e) {
+            issues.push(`validateConfig error: ${e?.message || String(e)}`);
+        }
+        return { ok: issues.length === 0, issues };
+    }
+    watchConfig(cb) {
+        this.watchers.push(cb);
+        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 }));
+                }
+                catch { /* ignore */ }
+            });
+        }
+        catch { /* ignore */ }
+    }
+    unwatchConfig(cb) {
+        if (!cb) {
+            this.watchers = [];
+        }
+        else {
+            this.watchers = this.watchers.filter(fn => fn !== cb);
+        }
+        if (this.watchers.length === 0 && this.fsWatcher) {
+            try {
+                this.fsWatcher.close();
+            }
+            catch { /* ignore */ }
+            this.fsWatcher = null;
+        }
+    }
+}
+export const UnifiedConfig = UnifiedConfigFacade.getInstance();

package/dist/conversion/codec-registry.d.ts

@@ -0,0 +1,10 @@
+import type { ConversionCodec } from './types.js';
+export type CodecFactory = () => Promise<ConversionCodec> | ConversionCodec;
+export declare class CodecRegistry {
+    private readonly factories;
+    private readonly instances;
+    constructor(_deps?: unknown);
+    register(id: string, factory: CodecFactory): void;
+    resolve(id: string): Promise<ConversionCodec>;
+}
+export declare function getDefaultCodecFactories(): Record<string, CodecFactory>;

package/dist/conversion/codec-registry.js

@@ -0,0 +1,25 @@
+export class CodecRegistry {
+    factories = new Map();
+    instances = new Map();
+    constructor(_deps) { }
+    register(id, factory) {
+        this.factories.set(id, factory);
+    }
+    async resolve(id) {
+        if (this.instances.has(id))
+            return this.instances.get(id);
+        const factory = this.factories.get(id);
+        if (!factory)
+            throw new Error(`Unknown conversion codec: ${id}`);
+        const instance = await factory();
+        await instance.initialize();
+        this.instances.set(id, instance);
+        return instance;
+    }
+}
+// Default codec factories placeholder. In phase 1 we intentionally do not
+// reimplement codecs here; the router will not be switched yet. This file is
+// prepared so later phases can register actual codecs.
+export function getDefaultCodecFactories() {
+    return {};
+}

package/dist/conversion/codecs/anthropic-openai-codec.d.ts

@@ -0,0 +1,23 @@
+import type { ConversionCodec, ConversionContext, ConversionProfile } from '../types.js';
+export declare function mapAnthropicToolsToOpenAI(tools: any[]): any[];
+export declare function buildOpenAIChatFromAnthropic(payload: any): {
+    messages: any[];
+};
+/**
+ * ChatRequest → AnthropicRequest 编码器（请求侧）
+ *
+ * 用于在 v3 管线中，将 canonical Chat 请求编码为 Anthropic /v1/messages wire 形状：
+ *  - messages: Chat messages → Anthropic content blocks（仅 text，工具调用由 tools 列表承载）
+ *  - tools: Chat tools[].function → Anthropic { name, description, input_schema }
+ *  - 参数：max_tokens/temperature/top_p/stop → Anthropic 对应字段
+ */
+export declare function buildAnthropicRequestFromOpenAIChat(chatReq: any): any;
+export declare class AnthropicOpenAIConversionCodec implements ConversionCodec {
+    private readonly _dependencies;
+    readonly id = "anthropic-openai";
+    private initialized;
+    constructor(_dependencies: any);
+    initialize(): Promise<void>;
+    convertRequest(payload: any, _profile: ConversionProfile, context: ConversionContext): Promise<any>;
+    convertResponse(payload: any, _profile: ConversionProfile, context: ConversionContext): Promise<any>;
+}