@jsonstudio/rcc 0.85.9 → 0.89.3

package/node_modules/@jsonstudio/llms/dist/conversion/codecs/gemini-openai-codec.js

@@ -0,0 +1,503 @@
+import { createBridgeActionState, runBridgeActionPipeline } from '../shared/bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../shared/bridge-policies.js';
+import { normalizeChatMessageContent } from '../shared/chat-output-normalizer.js';
+import { mapBridgeToolsToChat } from '../shared/tool-mapping.js';
+import { prepareGeminiToolsForBridge } from '../shared/gemini-tool-utils.js';
+import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta } from '../shared/responses-reasoning-registry.js';
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+function safeJson(value) {
+    try {
+        return JSON.stringify(value ?? {});
+    }
+    catch {
+        return '{}';
+    }
+}
+function flattenGeminiTextFromParts(parts) {
+    if (!parts)
+        return '';
+    if (Array.isArray(parts)) {
+        return parts
+            .map((p) => {
+            if (p && typeof p === 'object' && typeof p.text === 'string') {
+                return String(p.text);
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join('');
+    }
+    if (parts && typeof parts === 'object' && typeof parts.text === 'string') {
+        return String(parts.text);
+    }
+    return '';
+}
+function mapGeminiRoleToChat(role) {
+    const r = String(role || '').toLowerCase();
+    if (r === 'model' || r === 'assistant')
+        return 'assistant';
+    if (r === 'system')
+        return 'system';
+    if (r === 'tool')
+        return 'tool';
+    return 'user';
+}
+function mapChatRoleToGemini(role) {
+    const r = String(role || '').toLowerCase();
+    if (r === 'assistant')
+        return 'model';
+    if (r === 'system')
+        return 'system';
+    if (r === 'tool')
+        return 'tool';
+    return 'user';
+}
+export function buildOpenAIChatFromGeminiRequest(payload) {
+    const messages = [];
+    // systemInstruction → Chat system 消息
+    try {
+        const sys = payload?.systemInstruction;
+        const sysText = flattenGeminiTextFromParts(sys?.parts ?? sys);
+        if (sysText && sysText.trim().length) {
+            messages.push({ role: 'system', content: sysText.trim() });
+        }
+    }
+    catch {
+        // ignore systemInstruction failures
+    }
+    const contents = Array.isArray(payload?.contents) ? payload.contents : [];
+    for (const content of contents) {
+        if (!content || typeof content !== 'object')
+            continue;
+        const cObj = content;
+        const role = mapGeminiRoleToChat(cObj.role);
+        const parts = Array.isArray(cObj.parts) ? cObj.parts : [];
+        const textParts = [];
+        const toolCalls = [];
+        const toolResults = [];
+        for (const part of parts) {
+            if (!part || typeof part !== 'object')
+                continue;
+            const pObj = part;
+            if (typeof pObj.text === 'string') {
+                const t = pObj.text;
+                if (t && t.trim().length)
+                    textParts.push(t);
+                continue;
+            }
+            if (pObj.functionCall && typeof pObj.functionCall === 'object') {
+                const fc = pObj.functionCall;
+                const name = typeof fc.name === 'string' ? String(fc.name) : undefined;
+                if (!name)
+                    continue;
+                const id = typeof fc.id === 'string' ? String(fc.id) : undefined;
+                const argsRaw = (fc.args ?? fc.arguments);
+                let argsStr;
+                if (typeof argsRaw === 'string') {
+                    argsStr = argsRaw;
+                }
+                else {
+                    argsStr = safeJson(argsRaw);
+                }
+                toolCalls.push({ id, type: 'function', function: { name, arguments: argsStr } });
+                continue;
+            }
+            if (pObj.functionResponse && typeof pObj.functionResponse === 'object') {
+                const fr = pObj.functionResponse;
+                const callId = typeof fr.id === 'string' ? String(fr.id) : undefined;
+                const resp = fr.response;
+                let contentStr = '';
+                if (typeof resp === 'string')
+                    contentStr = resp;
+                else if (resp != null) {
+                    try {
+                        contentStr = JSON.stringify(resp);
+                    }
+                    catch {
+                        contentStr = String(resp);
+                    }
+                }
+                toolResults.push({ role: 'tool', tool_call_id: callId, content: contentStr });
+                continue;
+            }
+        }
+        const combinedText = textParts.join('\n');
+        const normalized = combinedText.length ? normalizeChatMessageContent(combinedText) : { contentText: undefined, reasoningText: undefined };
+        const hasText = typeof normalized.contentText === 'string' && normalized.contentText.length > 0;
+        const reasoningChunks = [];
+        if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
+            reasoningChunks.push(normalized.reasoningText.trim());
+        }
+        if (hasText || toolCalls.length > 0 || reasoningChunks.length > 0) {
+            const msg = {
+                role,
+                content: normalized.contentText ?? combinedText ?? ''
+            };
+            if (reasoningChunks.length) {
+                msg.reasoning_content = reasoningChunks.join('\n');
+            }
+            if (toolCalls.length)
+                msg.tool_calls = toolCalls;
+            messages.push(msg);
+        }
+        for (const tr of toolResults)
+            messages.push(tr);
+    }
+    return { messages };
+}
+export function buildOpenAIChatFromGeminiResponse(payload) {
+    const candidates = Array.isArray(payload?.candidates) ? payload.candidates : [];
+    const primary = candidates[0] && typeof candidates[0] === 'object' ? candidates[0] : {};
+    const content = primary?.content || {};
+    const role = mapGeminiRoleToChat(content.role);
+    const parts = Array.isArray(content.parts) ? content.parts : [];
+    const textParts = [];
+    const reasoningParts = [];
+    const toolCalls = [];
+    for (const part of parts) {
+        if (!part || typeof part !== 'object')
+            continue;
+        const pObj = part;
+        if (typeof pObj.text === 'string') {
+            const t = pObj.text;
+            if (t && t.trim().length)
+                textParts.push(t);
+            continue;
+        }
+        if (Array.isArray(pObj.content)) {
+            for (const inner of pObj.content) {
+                if (typeof inner === 'string') {
+                    textParts.push(inner);
+                }
+                else if (inner && typeof inner === 'object' && typeof inner.text === 'string') {
+                    textParts.push(inner.text);
+                }
+            }
+            continue;
+        }
+        if (typeof pObj.reasoning === 'string') {
+            reasoningParts.push(pObj.reasoning);
+            continue;
+        }
+        if (pObj.functionCall && typeof pObj.functionCall === 'object') {
+            const fc = pObj.functionCall;
+            const name = typeof fc.name === 'string' ? String(fc.name) : undefined;
+            if (!name)
+                continue;
+            const id = typeof fc.id === 'string' ? String(fc.id) : undefined;
+            const argsRaw = (fc.args ?? fc.arguments);
+            let argsStr;
+            if (typeof argsRaw === 'string') {
+                argsStr = argsRaw;
+            }
+            else {
+                argsStr = safeJson(argsRaw);
+            }
+            toolCalls.push({
+                id,
+                type: 'function',
+                function: { name, arguments: argsStr }
+            });
+            continue;
+        }
+    }
+    const finish_reason = (() => {
+        const fr = String(primary?.finishReason || '').toUpperCase();
+        if (fr === 'MAX_TOKENS')
+            return 'length';
+        if (fr === 'STOP')
+            return 'stop';
+        if (fr === 'SAFETY')
+            return 'content_filter';
+        if (fr === 'OTHER')
+            return 'stop';
+        return 'stop';
+    })();
+    const usageMeta = payload?.usageMetadata || {};
+    const usage = {};
+    const promptTokens = Number(usageMeta.promptTokenCount);
+    const completionTokens = Number(usageMeta.candidatesTokenCount);
+    const totalTokens = Number(usageMeta.totalTokenCount);
+    if (Number.isFinite(promptTokens))
+        usage.prompt_tokens = promptTokens;
+    if (Number.isFinite(completionTokens))
+        usage.completion_tokens = completionTokens;
+    if (Number.isFinite(totalTokens))
+        usage.total_tokens = totalTokens;
+    const combinedText = textParts.join('\n');
+    const normalized = combinedText.length ? normalizeChatMessageContent(combinedText) : { contentText: undefined, reasoningText: undefined };
+    const chatMsg = {
+        role,
+        content: normalized.contentText ?? combinedText ?? ''
+    };
+    if (typeof normalized.reasoningText === 'string' && normalized.reasoningText.trim().length) {
+        reasoningParts.push(normalized.reasoningText.trim());
+    }
+    if (reasoningParts.length) {
+        chatMsg.reasoning_content = reasoningParts.join('\n');
+    }
+    if (toolCalls.length) {
+        chatMsg.tool_calls = toolCalls;
+    }
+    try {
+        const bridgePolicy = resolveBridgePolicy({ protocol: 'gemini-chat' });
+        const actions = resolvePolicyActions(bridgePolicy, 'response_inbound');
+        if (actions?.length) {
+            const actionState = createBridgeActionState({
+                messages: [chatMsg],
+                rawResponse: isObject(payload) ? payload : undefined
+            });
+            runBridgeActionPipeline({
+                stage: 'response_inbound',
+                actions,
+                protocol: bridgePolicy?.protocol ?? 'gemini-chat',
+                moduleType: bridgePolicy?.moduleType ?? 'gemini-chat',
+                requestId: typeof payload?.id === 'string' ? String(payload.id) : undefined,
+                state: actionState
+            });
+        }
+    }
+    catch {
+        // best-effort policy execution
+    }
+    const chatResp = {
+        id: payload?.id || `chatcmpl_${Date.now()}`,
+        object: 'chat.completion',
+        model: payload?.model || 'unknown',
+        choices: [
+            {
+                index: 0,
+                finish_reason,
+                message: chatMsg
+            }
+        ]
+    };
+    if (Object.keys(usage).length > 0) {
+        chatResp.usage = usage;
+    }
+    const preservedReasoning = consumeResponsesReasoning(chatResp.id);
+    if (preservedReasoning && preservedReasoning.length) {
+        chatResp.__responses_reasoning = preservedReasoning;
+    }
+    const preservedOutputMeta = consumeResponsesOutputTextMeta(chatResp.id);
+    if (preservedOutputMeta) {
+        chatResp.__responses_output_text_meta = preservedOutputMeta;
+    }
+    return chatResp;
+}
+export function buildGeminiFromOpenAIChat(chatResp) {
+    const choices = Array.isArray(chatResp?.choices) ? chatResp.choices : [];
+    const primary = choices[0] && typeof choices[0] === 'object' ? choices[0] : {};
+    const msg = primary?.message || {};
+    const usage = isObject(chatResp?.usage) ? chatResp.usage : {};
+    const finishReason = (() => {
+        const r = String(primary?.finish_reason || '').toLowerCase();
+        if (r === 'length')
+            return 'MAX_TOKENS';
+        if (r === 'tool_calls' || r === 'function_call')
+            return 'STOP';
+        if (r === 'content_filter')
+            return 'OTHER';
+        if (r === 'stop')
+            return 'STOP';
+        return 'STOP';
+    })();
+    const baseRole = mapChatRoleToGemini(msg.role || 'assistant');
+    if (msg) {
+        try {
+            const bridgePolicy = resolveBridgePolicy({ protocol: 'gemini-chat' });
+            const actions = resolvePolicyActions(bridgePolicy, 'response_outbound');
+            if (actions?.length) {
+                const actionState = createBridgeActionState({
+                    messages: [msg]
+                });
+                runBridgeActionPipeline({
+                    stage: 'response_outbound',
+                    actions,
+                    protocol: bridgePolicy?.protocol ?? 'gemini-chat',
+                    moduleType: bridgePolicy?.moduleType ?? 'gemini-chat',
+                    requestId: typeof chatResp?.id === 'string' ? String(chatResp.id) : undefined,
+                    state: actionState
+                });
+            }
+        }
+        catch {
+            // ignore policy failures
+        }
+    }
+    const parts = [];
+    const contentText = (() => {
+        const raw = msg.content;
+        if (typeof raw === 'string')
+            return raw;
+        if (Array.isArray(raw)) {
+            return raw
+                .map((part) => {
+                if (typeof part === 'string')
+                    return part;
+                if (part && typeof part === 'object') {
+                    if (typeof part.text === 'string')
+                        return part.text;
+                    if (typeof part.content === 'string')
+                        return part.content;
+                }
+                return '';
+            })
+                .filter(Boolean)
+                .join('');
+        }
+        return '';
+    })();
+    if (contentText && contentText.length) {
+        parts.push({ text: contentText });
+    }
+    const reasoningText = typeof msg?.reasoning_content === 'string' && msg.reasoning_content.trim().length
+        ? String(msg.reasoning_content).trim()
+        : undefined;
+    if (reasoningText) {
+        parts.push({ reasoning: reasoningText });
+    }
+    const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+    for (const tc of toolCalls) {
+        if (!tc || typeof tc !== 'object')
+            continue;
+        const fn = tc.function || {};
+        const name = typeof fn.name === 'string' ? String(fn.name) : undefined;
+        if (!name)
+            continue;
+        let argsStruct;
+        const rawArgs = fn.arguments;
+        if (typeof rawArgs === 'string') {
+            try {
+                argsStruct = JSON.parse(rawArgs);
+            }
+            catch {
+                argsStruct = { _raw: rawArgs };
+            }
+        }
+        else {
+            argsStruct = rawArgs ?? {};
+        }
+        const functionCall = { name, args: argsStruct };
+        const id = typeof tc.id === 'string' ? String(tc.id) : undefined;
+        if (id)
+            functionCall.id = id;
+        parts.push({ functionCall });
+    }
+    const candidate = {
+        content: {
+            role: baseRole,
+            parts
+        },
+        finishReason
+    };
+    const usageMetadata = {};
+    const promptTokens = Number(usage.prompt_tokens ?? usage.input_tokens);
+    const completionTokens = Number(usage.completion_tokens ?? usage.output_tokens);
+    const totalTokens = Number(usage.total_tokens);
+    if (Number.isFinite(promptTokens))
+        usageMetadata.promptTokenCount = promptTokens;
+    if (Number.isFinite(completionTokens))
+        usageMetadata.candidatesTokenCount = completionTokens;
+    if (Number.isFinite(totalTokens))
+        usageMetadata.totalTokenCount = totalTokens;
+    const responseId = typeof chatResp?.id === 'string' ? String(chatResp.id) : `chatcmpl_${Date.now()}`;
+    const out = {
+        id: responseId,
+        candidates: [candidate]
+    };
+    if (chatResp?.model) {
+        out.model = chatResp.model;
+    }
+    if (Object.keys(usageMetadata).length > 0)
+        out.usageMetadata = usageMetadata;
+    if (Array.isArray(chatResp?.__responses_reasoning)) {
+        registerResponsesReasoning(responseId, chatResp.__responses_reasoning);
+    }
+    if (chatResp?.__responses_output_text_meta) {
+        registerResponsesOutputTextMeta(responseId, chatResp.__responses_output_text_meta);
+    }
+    return out;
+}
+export class GeminiOpenAIConversionCodec {
+    _dependencies;
+    id = 'gemini-openai';
+    initialized = false;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(_dependencies) {
+        this._dependencies = _dependencies;
+    }
+    async initialize() {
+        this.initialized = true;
+    }
+    async ensureInit() {
+        if (!this.initialized)
+            await this.initialize();
+    }
+    async convertRequest(payload, _profile, _context) {
+        await this.ensureInit();
+        const model = String((payload && typeof payload === 'object' && payload.model) || 'unknown');
+        const { messages } = buildOpenAIChatFromGeminiRequest(payload);
+        const out = { model, messages };
+        try {
+            const bridgeTools = prepareGeminiToolsForBridge(payload?.tools);
+            const tools = bridgeTools ? mapBridgeToolsToChat(bridgeTools) : undefined;
+            if (tools && tools.length > 0)
+                out.tools = tools;
+        }
+        catch {
+            // keep tools undefined on failure
+        }
+        try {
+            const gen = payload?.generationConfig;
+            if (gen && typeof gen === 'object') {
+                const g = gen;
+                const max = Number(g.maxOutputTokens ?? g.max_output_tokens);
+                if (Number.isFinite(max) && max > 0)
+                    out.max_tokens = max;
+                if (typeof g.temperature === 'number')
+                    out.temperature = g.temperature;
+                if (typeof g.topP === 'number')
+                    out.top_p = g.topP;
+                const stop = g.stopSequences;
+                if (typeof stop === 'string' && stop.trim()) {
+                    out.stop = [stop.trim()];
+                }
+                else if (Array.isArray(stop) && stop.length > 0) {
+                    out.stop = stop.map((s) => String(s)).filter(Boolean);
+                }
+            }
+        }
+        catch {
+            // best-effort on generationConfig
+        }
+        try {
+            const safety = payload?.safetySettings;
+            const metadata = payload?.metadata;
+            if (safety || metadata) {
+                out.metadata = {
+                    ...(isObject(metadata) ? metadata : {}),
+                    vendor: {
+                        ...(isObject(metadata?.vendor) ? metadata.vendor : {}),
+                        gemini: {
+                            safetySettings: safety
+                        }
+                    }
+                };
+            }
+        }
+        catch {
+            // ignore metadata failures
+        }
+        // 不在此处设置 stream；流控由后半段统一处理
+        return out;
+    }
+    async convertResponse(payload, _profile, _context) {
+        await this.ensureInit();
+        // 这里假设 payload 已经是标准 Chat completion，直接映射回 Gemini 响应；
+        // 对于 provider→Chat 的路径，宿主可以直接调用 buildOpenAIChatFromGeminiResponse。
+        return buildGeminiFromOpenAIChat(payload);
+    }
+}

package/node_modules/@jsonstudio/llms/dist/conversion/codecs/openai-openai-codec.js

@@ -0,0 +1,125 @@
+import { runStandardChatRequestFilters } from '../index.js';
+import { FilterEngine, ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } from '../../filters/index.js';
+import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
+// processChatRequestTools/processChatResponseTools removed in favor of Filter pipeline
+import { finalizeOpenAIChatResponse } from '../shared/openai-finalizer.js';
+// Ported from root package (no behavior changes). Types relaxed to avoid root coupling.
+export class OpenAIOpenAIConversionCodec {
+    dependencies;
+    id = 'openai-openai';
+    initialized = false;
+    ctxMap = new Map();
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async initialize() { this.initialized = true; }
+    async convertRequest(payload, profile, context) {
+        await this.ensureInit();
+        const dto = {
+            data: payload,
+            route: {
+                providerId: 'unknown',
+                modelId: (payload && typeof payload === 'object' && payload.model) ? String(payload.model) : 'unknown',
+                requestId: context.requestId ?? `req_${Date.now()}`,
+                timestamp: Date.now()
+            },
+            metadata: {
+                endpoint: context.endpoint ?? context.entryEndpoint,
+                entryEndpoint: context.entryEndpoint,
+                targetProtocol: profile.outgoingProtocol
+            },
+            debug: { enabled: false, stages: {} }
+        };
+        // Persist inbound streaming intent per requestId for response-side SSE decision
+        try {
+            const wantsStream = !!((dto.data && dto.data.stream === true) || (context?.stream === true) || (context?.metadata && context.metadata.stream === true));
+            const ep = String(context.entryEndpoint || context.endpoint || '');
+            if (dto.route.requestId)
+                this.ctxMap.set(dto.route.requestId, { stream: wantsStream, entryEndpoint: ep });
+        }
+        catch { /* ignore */ }
+        // 统一的 Chat 请求过滤链路（与 Responses/Anthropic 保持一致）
+        const ctxForFilters = {
+            ...context,
+            requestId: dto.route.requestId,
+            entryEndpoint: context.entryEndpoint ?? dto.metadata?.entryEndpoint ?? context.endpoint,
+            endpoint: context.endpoint ?? dto.metadata?.endpoint
+        };
+        return runStandardChatRequestFilters(dto.data, profile, ctxForFilters);
+    }
+    async convertResponse(payload, _profile, context) {
+        await this.ensureInit();
+        // unwrap nested { data: {...} } wrappers until we reach an object
+        const unwrap = (obj) => {
+            let cur = obj;
+            const guard = new Set();
+            while (cur && typeof cur === 'object' && !Array.isArray(cur) && !guard.has(cur)) {
+                guard.add(cur);
+                if ('choices' in cur || 'id' in cur || 'object' in cur) {
+                    break;
+                }
+                if ('data' in cur && cur.data && typeof cur.data === 'object') {
+                    cur = cur.data;
+                    continue;
+                }
+                break;
+            }
+            return cur;
+        };
+        const unwrapped = unwrap(payload);
+        const dto = {
+            data: unwrapped,
+            metadata: {
+                requestId: context.requestId ?? `req_${Date.now()}`,
+                pipelineId: context.metadata?.pipelineId ?? 'conversion-router',
+                processingTime: 0,
+                stages: []
+            }
+        };
+        // Run filter pipeline (no-op initially). Will be populated during migration.
+        const resCtxBase = {
+            requestId: context.requestId ?? dto.metadata.requestId,
+            model: undefined,
+            endpoint: context.entryEndpoint || context.endpoint,
+            profile: 'openai-chat',
+            debug: { emit: () => { } }
+        };
+        const engine = new FilterEngine();
+        // Response-side filters (idempotent w.r.t existing logic)
+        engine.registerFilter(new ResponseToolTextCanonicalizeFilter()); // response_pre
+        try {
+            const { ResponseToolArgumentsToonDecodeFilter } = await import('../../filters/index.js');
+            engine.registerFilter(new ResponseToolArgumentsToonDecodeFilter()); // response_pre, runs before stringify
+        }
+        catch { /* optional */ }
+        engine.registerFilter(new ResponseToolArgumentsStringifyFilter()); // response_post
+        engine.registerFilter(new ResponseFinishInvariantsFilter()); // response_post
+        // Load field map config (if present) and register transforms
+        try {
+            const cfg = await loadFieldMapConfig('openai-openai.fieldmap.json');
+            if (cfg)
+                engine.setFieldMap(cfg);
+            engine.registerTransform('stringifyJson', (v) => (typeof v === 'string') ? v : (() => { try {
+                return JSON.stringify(v ?? {});
+            }
+            catch {
+                return '{}';
+            } })());
+        }
+        catch { /* ignore */ }
+        let staged = await engine.run('response_pre', dto.data, resCtxBase);
+        staged = await engine.run('response_map', staged, resCtxBase);
+        staged = await engine.run('response_post', staged, resCtxBase);
+        // Canonicalization handled by filters (staged)
+        const canonical = staged;
+        // Finalize + hooks (pre/post snapshots)
+        const finalized = await finalizeOpenAIChatResponse(canonical, {
+            requestId: context.requestId,
+            endpoint: context.entryEndpoint || context.endpoint
+        });
+        return finalized;
+    }
+    async ensureInit() { if (!this.initialized)
+        await this.initialize(); }
+}