@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/conversion/shared/bridge-id-utils.js

@@ -1,79 +0,0 @@
-import { createHash } from 'node:crypto';
-const MAX_RESPONSES_ITEM_ID_LENGTH = 64;
-function sanitizeCore(value) {
-    return value
-        .replace(/[^A-Za-z0-9_-]/g, '_')
-        .replace(/_{2,}/g, '_')
-        .replace(/^_+/, '')
-        .replace(/_+$/, '');
-}
-function shortHash(value) {
-    try {
-        return createHash('sha1').update(value).digest('hex').slice(0, 10);
-    }
-    catch {
-        return Math.random().toString(36).slice(2, 12);
-    }
-}
-function clampPrefixedId(prefix, core, hashSource) {
-    const sanitized = sanitizeCore(core) || Math.random().toString(36).slice(2, 10);
-    const direct = `${prefix}${sanitized}`;
-    if (direct.length <= MAX_RESPONSES_ITEM_ID_LENGTH) {
-        return direct;
-    }
-    const hash = shortHash(`${prefix}|${hashSource}|${sanitized}`);
-    const room = Math.max(1, MAX_RESPONSES_ITEM_ID_LENGTH - prefix.length - 1 - hash.length);
-    const head = sanitizeCore(sanitized.slice(0, room)) || 'id';
-    return `${prefix}${head}_${hash}`;
-}
-function extractCore(value) {
-    if (typeof value !== 'string')
-        return null;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return null;
-    let sanitized = sanitizeCore(trimmed);
-    if (!sanitized)
-        return null;
-    if (/^fc[_-]/i.test(sanitized)) {
-        sanitized = sanitized.replace(/^fc[_-]?/i, '');
-    }
-    else if (/^call[_-]/i.test(sanitized)) {
-        sanitized = sanitized.replace(/^call[_-]?/i, '');
-    }
-    return sanitizeCore(sanitized) || null;
-}
-function normalizeWithFallback(options, prefix) {
-    const callCore = extractCore(options.callId);
-    if (callCore) {
-        return clampPrefixedId(prefix, callCore, String(options.callId));
-    }
-    const fallbackCore = extractCore(options.fallback);
-    if (fallbackCore) {
-        return clampPrefixedId(prefix, fallbackCore, String(options.fallback));
-    }
-    const randomCore = Math.random().toString(36).slice(2, 10);
-    return clampPrefixedId(prefix, randomCore, randomCore);
-}
-export function normalizeFunctionCallId(options) {
-    return normalizeWithFallback(options, 'fc_');
-}
-export function normalizeFunctionCallOutputId(options) {
-    return normalizeWithFallback(options, 'fc_');
-}
-export function normalizeResponsesCallId(options) {
-    return normalizeWithFallback(options, 'call_');
-}
-export function clampResponsesInputItemId(raw) {
-    const trimmed = typeof raw === 'string' ? raw.trim() : '';
-    if (!trimmed) {
-        return undefined;
-    }
-    if (trimmed.length <= MAX_RESPONSES_ITEM_ID_LENGTH) {
-        return trimmed;
-    }
-    const hash = shortHash(trimmed);
-    const room = Math.max(1, MAX_RESPONSES_ITEM_ID_LENGTH - 1 - hash.length);
-    const head = trimmed.slice(0, room);
-    return `${head}_${hash}`;
-}

package/dist/conversion/shared/bridge-metadata.js

@@ -1 +0,0 @@
-export const BRIDGE_RAW_SYSTEM_METADATA_KEY = '__rcc_raw_system';

package/dist/conversion/shared/bridge-policies.js

@@ -1,195 +0,0 @@
-import { RESPONSES_INSTRUCTIONS_REASONING_FIELD } from './reasoning-normalizer.js';
-import { ANTHROPIC_ALLOWED_FIELDS, GEMINI_ALLOWED_FIELDS, OPENAI_CHAT_ALLOWED_FIELDS, OPENAI_RESPONSES_ALLOWED_FIELDS } from './protocol-field-allowlists.js';
-function reasoningAction(idPrefix) {
-    return {
-        name: 'reasoning.extract',
-        options: {
-            dropFromContent: true,
-            idPrefix
-        }
-    };
-}
-function toolCallNormalizationAction(idPrefix) {
-    if (idPrefix && idPrefix.trim().length) {
-        return {
-            name: 'tools.normalize-call-ids',
-            options: { idPrefix: idPrefix.trim() }
-        };
-    }
-    return { name: 'tools.normalize-call-ids' };
-}
-const RESPONSES_POLICY = {
-    id: 'openai-responses-default',
-    protocol: 'openai-responses',
-    request: {
-        inbound: [
-            {
-                name: 'messages.inject-system-instruction',
-                options: {
-                    field: 'instructions',
-                    reasoningField: RESPONSES_INSTRUCTIONS_REASONING_FIELD
-                }
-            },
-            { name: 'messages.ensure-system-instruction' },
-            reasoningAction('responses_reasoning'),
-            toolCallNormalizationAction('responses_tool_call'),
-            { name: 'tools.ensure-placeholders' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_RESPONSES_ALLOWED_FIELDS } },
-            { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
-            { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } }
-        ],
-        outbound: [
-            { name: 'messages.normalize-history' },
-            { name: 'tools.capture-results' },
-            toolCallNormalizationAction('responses_tool_call'),
-            { name: 'tools.ensure-placeholders' },
-            { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
-            { name: 'messages.ensure-system-instruction' },
-            reasoningAction('responses_reasoning'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_RESPONSES_ALLOWED_FIELDS } },
-            { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
-            { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } }
-        ]
-    },
-    response: {
-        inbound: [
-            { name: 'reasoning.attach-output' },
-            reasoningAction('responses_reasoning'),
-            toolCallNormalizationAction('responses_tool_call'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_RESPONSES_ALLOWED_FIELDS } }
-        ],
-        outbound: [
-            reasoningAction('responses_reasoning'),
-            toolCallNormalizationAction('responses_tool_call'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_RESPONSES_ALLOWED_FIELDS } }
-        ]
-    }
-};
-const OPENAI_CHAT_POLICY = {
-    id: 'openai-chat-default',
-    protocol: 'openai-chat',
-    request: {
-        inbound: [
-            reasoningAction('openai_chat_reasoning'),
-            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
-            { name: 'messages.ensure-system-instruction' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } },
-            { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
-            { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } }
-        ],
-        outbound: [
-            { name: 'messages.normalize-history' },
-            { name: 'tools.capture-results' },
-            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
-            { name: 'tools.ensure-placeholders' },
-            { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
-            { name: 'messages.ensure-system-instruction' },
-            reasoningAction('openai_chat_reasoning'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } },
-            { name: 'metadata.provider-field', options: { field: 'metadata', target: 'providerMetadata' } },
-            { name: 'metadata.provider-sentinel', options: { sentinel: '__rcc_provider_metadata', target: 'providerMetadata' } }
-        ]
-    },
-    response: {
-        inbound: [
-            reasoningAction('openai_chat_reasoning'),
-            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } }
-        ],
-        outbound: [
-            reasoningAction('openai_chat_reasoning'),
-            toolCallNormalizationAction('openai_chat_tool_call'), { name: 'compat.fix-apply-patch' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: OPENAI_CHAT_ALLOWED_FIELDS } }
-        ]
-    }
-};
-const ANTHROPIC_POLICY = {
-    id: 'anthropic-messages-default',
-    protocol: 'anthropic-messages',
-    request: {
-        inbound: [
-            reasoningAction('anthropic_reasoning'),
-            toolCallNormalizationAction('anthropic_tool_call'),
-            { name: 'messages.ensure-system-instruction' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: ANTHROPIC_ALLOWED_FIELDS } }
-        ],
-        outbound: [
-            { name: 'messages.normalize-history' },
-            { name: 'tools.capture-results' },
-            toolCallNormalizationAction('anthropic_tool_call'),
-            { name: 'tools.ensure-placeholders' },
-            { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
-            { name: 'messages.ensure-system-instruction' },
-            reasoningAction('anthropic_reasoning'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: ANTHROPIC_ALLOWED_FIELDS } }
-        ]
-    },
-    response: {
-        inbound: [
-            reasoningAction('anthropic_reasoning'),
-            toolCallNormalizationAction('anthropic_tool_call'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: ANTHROPIC_ALLOWED_FIELDS } }
-        ],
-        outbound: [
-            reasoningAction('anthropic_reasoning'),
-            toolCallNormalizationAction('anthropic_tool_call'),
-            { name: 'metadata.extra-fields', options: { allowedKeys: ANTHROPIC_ALLOWED_FIELDS } }
-        ]
-    }
-};
-const GEMINI_POLICY = {
-    id: 'gemini-chat-default',
-    protocol: 'gemini-chat',
-    request: {
-        inbound: [
-            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
-            { name: 'messages.ensure-system-instruction' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
-        ],
-        outbound: [
-            { name: 'messages.normalize-history' },
-            { name: 'tools.capture-results' },
-            { name: 'tools.ensure-placeholders' },
-            { name: 'messages.ensure-output-fields', options: { toolFallback: 'Tool call completed (no output).' } },
-            { name: 'messages.ensure-system-instruction' },
-            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
-        ]
-    },
-    response: {
-        inbound: [
-            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
-        ],
-        outbound: [
-            reasoningAction('gemini_reasoning'), { name: 'compat.fix-apply-patch' },
-            { name: 'metadata.extra-fields', options: { allowedKeys: GEMINI_ALLOWED_FIELDS } }
-        ]
-    }
-};
-const POLICIES = [RESPONSES_POLICY, OPENAI_CHAT_POLICY, ANTHROPIC_POLICY, GEMINI_POLICY];
-export function resolveBridgePolicy(options) {
-    if (!options)
-        return undefined;
-    const { protocol, moduleType } = options;
-    if (protocol) {
-        const match = POLICIES.find((policy) => policy.protocol === protocol);
-        if (match)
-            return match;
-    }
-    if (moduleType) {
-        const match = POLICIES.find((policy) => policy.moduleType === moduleType);
-        if (match)
-            return match;
-    }
-    return undefined;
-}
-export function resolvePolicyActions(policy, stage) {
-    if (!policy)
-        return undefined;
-    const [phaseKey, directionKey] = stage.split('_');
-    const phase = policy[phaseKey];
-    if (!phase)
-        return undefined;
-    return phase[directionKey];
-}

package/dist/conversion/shared/compaction-detect.js

@@ -1,59 +0,0 @@
-function hasCompactionMarker(value) {
-    // Compaction markers are intended to be explicit “header-like” sentinels produced by
-    // our own compaction flows, not arbitrary substrings inside user/dev instructions.
-    //
-    // If we treat any occurrence as a compaction request, normal conversations that
-    // contain phrases like “handoff summary …” (e.g. debug summaries pasted into chat)
-    // will get misclassified and will disable stopMessage / other servertools.
-    const lower = value.trimStart().toLowerCase();
-    return (lower.startsWith('context checkpoint compaction') ||
-        lower.startsWith('checkpoint compaction') ||
-        lower.startsWith('handoff summary for another llm'));
-}
-function containsMarker(value) {
-    if (typeof value === 'string') {
-        return hasCompactionMarker(value);
-    }
-    if (!value || typeof value !== 'object') {
-        return false;
-    }
-    if (Array.isArray(value)) {
-        return value.some((entry) => containsMarker(entry));
-    }
-    const record = value;
-    if (typeof record.text === 'string' && hasCompactionMarker(record.text)) {
-        return true;
-    }
-    if (typeof record.content === 'string' && hasCompactionMarker(record.content)) {
-        return true;
-    }
-    if (Array.isArray(record.content) && record.content.some((entry) => containsMarker(entry))) {
-        return true;
-    }
-    if (Array.isArray(record.parts) && record.parts.some((entry) => containsMarker(entry))) {
-        return true;
-    }
-    return false;
-}
-export function isCompactionRequest(payload) {
-    if (containsMarker(payload)) {
-        return true;
-    }
-    const messages = payload.messages;
-    if (Array.isArray(messages) && messages.some((msg) => containsMarker(msg))) {
-        return true;
-    }
-    const input = payload.input;
-    if (containsMarker(input)) {
-        return true;
-    }
-    const system = payload.system;
-    if (containsMarker(system)) {
-        return true;
-    }
-    const instructions = payload.instructions;
-    if (containsMarker(instructions)) {
-        return true;
-    }
-    return false;
-}

package/dist/conversion/shared/errors.js

@@ -1,31 +0,0 @@
-function inferCategoryFromCode(code) {
-    switch (code) {
-        case 'TOOL_PROTOCOL_ERROR':
-            return 'TOOL_ERROR';
-        case 'SERVERTOOL_TIMEOUT':
-        case 'SERVERTOOL_HANDLER_FAILED':
-            return 'INTERNAL_ERROR';
-        case 'SSE_DECODE_ERROR':
-        case 'MALFORMED_RESPONSE':
-        case 'MALFORMED_REQUEST':
-        default:
-            // 默认视为外部协议/载荷问题；真正的内部错误由上层使用 INTERNAL_ERROR 显式标记。
-            return 'EXTERNAL_ERROR';
-    }
-}
-export class ProviderProtocolError extends Error {
-    code;
-    protocol;
-    providerType;
-    category;
-    details;
-    constructor(message, options) {
-        super(message);
-        this.name = 'ProviderProtocolError';
-        this.code = options.code;
-        this.protocol = options.protocol;
-        this.providerType = options.providerType;
-        this.category = options.category ?? inferCategoryFromCode(options.code);
-        this.details = options.details;
-    }
-}

package/dist/conversion/shared/jsonish.js

@@ -1,177 +0,0 @@
-// Shared JSON-ish parsing helpers
-export function tryParseJson(s) {
-    if (typeof s !== 'string')
-        return s;
-    try {
-        return JSON.parse(s);
-    }
-    catch {
-        return s;
-    }
-}
-// Lenient parsing for function.arguments often produced by models
-export function parseLenient(value) {
-    if (value === undefined || value === null)
-        return {};
-    if (typeof value === 'object')
-        return value;
-    if (typeof value !== 'string')
-        return { _raw: String(value) };
-    const s0 = value.trim();
-    if (!s0)
-        return {};
-    // 1) strict JSON
-    try {
-        return JSON.parse(s0);
-    }
-    catch { /* continue */ }
-    // 2) fenced ```json ... ``` or ``` ... ```
-    const fence = s0.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
-    const candidate = fence ? fence[1] : s0;
-    // 3) object substring
-    const objMatch = candidate.match(/\{[\s\S]*\}/);
-    if (objMatch) {
-        try {
-            return JSON.parse(objMatch[0]);
-        }
-        catch { /* ignore */ }
-    }
-    // 4) array substring
-    const arrMatch = candidate.match(/\[[\s\S]*\]/);
-    if (arrMatch) {
-        try {
-            return JSON.parse(arrMatch[0]);
-        }
-        catch { /* ignore */ }
-    }
-    // 5) single quotes → double; unquoted keys → quoted
-    let t = candidate.replace(/'([^']*)'/g, '"$1"');
-    t = t.replace(/([{,\s])([A-Za-z_][A-Za-z0-9_-]*)\s*:/g, '$1"$2":');
-    try {
-        return JSON.parse(t);
-    }
-    catch { /* ignore */ }
-    // 6) key=value fallback across lines/commas
-    const obj = {};
-    const parts = candidate.split(/[\n,]+/).map(p => p.trim()).filter(Boolean);
-    for (const p of parts) {
-        const m = p.match(/^([A-Za-z_][A-Za-z0-9_-]*)\s*[:=]\s*(.+)$/);
-        if (!m)
-            continue;
-        const k = m[1];
-        let v = m[2].trim();
-        if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'")))
-            v = v.slice(1, -1);
-        try {
-            const pv = JSON.parse(v);
-            obj[k] = pv;
-            continue;
-        }
-        catch { /* fallthrough */ }
-        if (/^(true|false)$/i.test(v)) {
-            obj[k] = /^true$/i.test(v);
-            continue;
-        }
-        if (/^-?\d+(?:\.\d+)?$/.test(v)) {
-            obj[k] = Number(v);
-            continue;
-        }
-        obj[k] = v;
-    }
-    return obj;
-}
-// CCR-style repair: JSON -> JSON5-like cleanup -> safe fallback
-export function repairArgumentsToString(value) {
-    try {
-        if (value === undefined || value === null)
-            return '{}';
-        if (typeof value === 'object') {
-            try {
-                return JSON.stringify(value);
-            }
-            catch {
-                return '{}';
-            }
-        }
-        if (typeof value !== 'string') {
-            try {
-                return JSON.stringify({ _raw: String(value) });
-            }
-            catch {
-                return '{}';
-            }
-        }
-        let s = value.trim();
-        if (!s)
-            return '{}';
-        // 1) strict JSON
-        try {
-            JSON.parse(s);
-            return s;
-        }
-        catch { /* continue */ }
-        // 2) fenced ```json ... ``` or ``` ... ```
-        const fence = s.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
-        if (fence && fence[1])
-            s = fence[1].trim();
-        // 3) strip comments (// and /* */)
-        try {
-            s = s.replace(/\/\/.*$/gm, '');
-            s = s.replace(/\/\*[\s\S]*?\*\//g, '');
-        }
-        catch { /* ignore */ }
-        // 4) remove trailing commas before } or ]
-        try {
-            s = s.replace(/,\s*(?=[}\]])/g, '');
-        }
-        catch { /* ignore */ }
-        // 5) single quotes to double
-        try {
-            s = s.replace(/'([^'\\]*(?:\\.[^'\\]*)*)'/g, '"$1"');
-        }
-        catch { /* ignore */ }
-        // 6) quote unquoted keys
-        try {
-            s = s.replace(/([{,\s])([A-Za-z_][A-Za-z0-9_-]*)\s*:/g, '$1"$2":');
-        }
-        catch { /* ignore */ }
-        // 7) try parse after cleanup
-        try {
-            const obj = JSON.parse(s);
-            try {
-                if (obj && typeof obj === 'object' && Object.prototype.hasOwnProperty.call(obj, 'command')) {
-                    const cmd = obj.command;
-                    if (Array.isArray(cmd)) {
-                        obj.command = cmd.map((t) => String(t)).join(' ');
-                    }
-                }
-            }
-            catch { /* ignore */ }
-            return JSON.stringify(obj);
-        }
-        catch { /* continue */ }
-        // 8) extract first {...} or [...] substring and try again
-        try {
-            const m = s.match(/\{[\s\S]*\}|\[[\s\S]*\]/);
-            if (m) {
-                const obj = JSON.parse(m[0]);
-                try {
-                    if (obj && typeof obj === 'object' && Object.prototype.hasOwnProperty.call(obj, 'command')) {
-                        const cmd = obj.command;
-                        if (Array.isArray(cmd)) {
-                            obj.command = cmd.map((t) => String(t)).join(' ');
-                        }
-                    }
-                }
-                catch { /* ignore */ }
-                return JSON.stringify(obj);
-            }
-        }
-        catch { /* ignore */ }
-        // 9) final fallback
-        return '{}';
-    }
-    catch {
-        return '{}';
-    }
-}