@jsonstudio/rcc 0.90.364 → 0.90.429

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-argument-repairer.d.ts

@@ -1,39 +0,0 @@
-/**
- * Tool Argument Repairer
- *
- * Tool calls require `function.arguments` to be a JSON string. Models often emit JSON-ish
- * payloads (single quotes, fenced blocks, comments, trailing commas, etc.).
- *
- * This module provides a deterministic, best-effort repair surface that returns a JSON string
- * or `{}` and never throws.
- */
-export interface RepairResult {
-    repaired: string;
-    success: boolean;
-    error?: string;
-}
-export declare class ToolArgumentRepairer {
-    repairToString(args: unknown): string;
-    validateAndRepair(toolName: string, args: unknown): RepairResult;
-    /**
-     * 批量修复工具参数
-     *
-     * @param toolCalls - 工具调用列表
-     * @returns 修复后的工具调用列表
-     */
-    repairToolCalls(toolCalls: Array<{
-        name?: string;
-        arguments?: unknown;
-    }>): Array<{
-        name?: string;
-        arguments: string;
-    }>;
-}
-/**
- * 快捷函数：修复工具参数
- */
-export declare function repairToolArguments(args: unknown): string;
-/**
- * 快捷函数：验证并修复工具参数
- */
-export declare function validateToolArguments(toolName: string, args: unknown): RepairResult;

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-argument-repairer.js

@@ -1,53 +0,0 @@
-/**
- * Tool Argument Repairer
- *
- * Tool calls require `function.arguments` to be a JSON string. Models often emit JSON-ish
- * payloads (single quotes, fenced blocks, comments, trailing commas, etc.).
- *
- * This module provides a deterministic, best-effort repair surface that returns a JSON string
- * or `{}` and never throws.
- */
-import { repairArgumentsToStringWithNative, repairToolCallsWithNative, validateToolArgumentsWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
-export class ToolArgumentRepairer {
-    repairToString(args) {
-        if (typeof repairArgumentsToStringWithNative !== 'function') {
-            throw new Error('[tool-argument-repairer] native bindings unavailable');
-        }
-        return repairArgumentsToStringWithNative(args);
-    }
-    validateAndRepair(toolName, args) {
-        if (typeof validateToolArgumentsWithNative !== 'function') {
-            throw new Error('[tool-argument-repairer] native bindings unavailable');
-        }
-        const output = validateToolArgumentsWithNative(toolName, args);
-        return {
-            repaired: output.repaired,
-            success: output.success,
-            ...(output.error ? { error: output.error } : {})
-        };
-    }
-    /**
-     * 批量修复工具参数
-     *
-     * @param toolCalls - 工具调用列表
-     * @returns 修复后的工具调用列表
-     */
-    repairToolCalls(toolCalls) {
-        if (typeof repairToolCallsWithNative !== 'function') {
-            throw new Error('[tool-argument-repairer] native bindings unavailable');
-        }
-        return repairToolCallsWithNative(toolCalls);
-    }
-}
-/**
- * 快捷函数：修复工具参数
- */
-export function repairToolArguments(args) {
-    return new ToolArgumentRepairer().repairToString(args);
-}
-/**
- * 快捷函数：验证并修复工具参数
- */
-export function validateToolArguments(toolName, args) {
-    return new ToolArgumentRepairer().validateAndRepair(toolName, args);
-}

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-call-id-manager.d.ts

@@ -1,109 +0,0 @@
-/**
- * Tool Call ID Manager
- *
- * 提供统一的工具调用 ID 生成、规范化和风格管理功能。
- * 支持 'fc' (function call) 和 'preserve' 两种风格。
- */
-import type { JsonObject } from '../hub/types/json.js';
-export type ToolCallIdStyle = 'fc' | 'preserve';
-export interface ToolCallIdManagerOptions {
-    /**
-     * ID 风格
-     * - 'fc': 使用 fc_ 前缀的短 ID（如 fc_abc123）
-     * - 'preserve': 保留原始 ID
-     */
-    style?: ToolCallIdStyle;
-    /**
-     * ID 前缀（仅用于 'fc' 风格）
-     * 默认 'fc_'
-     */
-    prefix?: string;
-    /**
-     * ID 长度（仅用于 'fc' 风格）
-     * 默认 8
-     */
-    idLength?: number;
-}
-/**
- * 工具调用 ID 管理器
- */
-export declare class ToolCallIdManager {
-    private options;
-    private state;
-    constructor(options?: ToolCallIdManagerOptions);
-    /**
-     * 生成新的工具调用 ID
-     */
-    generateId(): string;
-    /**
-     * 规范化工具调用 ID
-     *
-     * @param id - 原始 ID
-     * @returns 规范化后的 ID
-     */
-    normalizeId(id: string | undefined | null): string;
-    /**
-     * 规范化工具调用 ID（带别名注册）
-     *
-     * @param id - 原始 ID
-     * @param aliasMap - 别名映射（用于 preserve 风格）
-     * @returns 规范化后的 ID
-     */
-    normalizeIdWithAlias(id: string | undefined | null, aliasMap?: Map<string, string>): string;
-    /**
-     * 批量规范化工具调用 ID
-     *
-     * @param ids - ID 列表
-     * @returns 规范化后的 ID 列表
-     */
-    normalizeIds(ids: (string | undefined | null)[]): string[];
-    /**
-     * 检查 ID 是否为有效的 fc_ 风格
-     */
-    isValidFcStyle(id: string): boolean;
-    /**
-     * 从 ID 中提取基础部分（移除前缀）
-     */
-    extractBaseId(id: string): string;
-    /**
-     * 重置计数器
-     */
-    resetCounter(): void;
-    /**
-     * 获取当前配置
-     */
-    getOptions(): ToolCallIdManagerOptions;
-    /**
-     * 更新配置
-     */
-    updateOptions(options: Partial<ToolCallIdManagerOptions>): void;
-}
-/**
- * 规范化工具调用 ID 值
- *
- * @param value - ID 值（可能是字符串或其他类型）
- * @param forceGenerate - 如果为 true，总是生成新 ID
- * @returns 规范化后的 ID 字符串
- */
-export declare function normalizeIdValue(value: unknown, forceGenerate?: boolean): string;
-/**
- * 从对象中提取工具调用 ID
- *
- * @param obj - 包含 ID 的对象
- * @returns 提取的 ID
- */
-export declare function extractToolCallId(obj: unknown): string | undefined;
-/**
- * 创建工具调用 ID 转换器（用于 Responses 格式）
- *
- * @param style - ID 风格
- * @returns 转换器函数
- */
-export declare function createToolCallIdTransformer(style: ToolCallIdStyle): ((id: string) => string) | null;
-/**
- * 在消息列表中强制应用工具调用 ID 风格
- *
- * @param messages - 消息列表
- * @param transformer - ID 转换器
- */
-export declare function enforceToolCallIdStyle(messages: JsonObject[], transformer: (id: string) => string): void;

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-call-id-manager.js

@@ -1,202 +0,0 @@
-/**
- * Tool Call ID Manager
- *
- * 提供统一的工具调用 ID 生成、规范化和风格管理功能。
- * 支持 'fc' (function call) 和 'preserve' 两种风格。
- */
-import { createToolCallIdTransformerWithNative, enforceToolCallIdStyleWithNative, extractToolCallIdWithNative, normalizeIdValueWithNative, transformToolCallIdWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
-const DEFAULT_OPTIONS = {
-    style: 'fc',
-    prefix: 'fc_',
-    idLength: 8
-};
-function assertToolCallIdManagerNativeAvailable() {
-    if (typeof normalizeIdValueWithNative !== 'function' ||
-        typeof extractToolCallIdWithNative !== 'function' ||
-        typeof createToolCallIdTransformerWithNative !== 'function' ||
-        typeof transformToolCallIdWithNative !== 'function' ||
-        typeof enforceToolCallIdStyleWithNative !== 'function') {
-        throw new Error('[tool-call-id-manager] native bindings unavailable');
-    }
-}
-/**
- * 工具调用 ID 管理器
- */
-export class ToolCallIdManager {
-    options;
-    state;
-    constructor(options) {
-        assertToolCallIdManagerNativeAvailable();
-        this.options = { ...DEFAULT_OPTIONS, ...options };
-        this.state = createToolCallIdTransformerWithNative(this.options.style);
-    }
-    /**
-     * 生成新的工具调用 ID
-     */
-    generateId() {
-        assertToolCallIdManagerNativeAvailable();
-        const output = transformToolCallIdWithNative(this.state, '');
-        this.state = output.state;
-        return output.id;
-    }
-    /**
-     * 规范化工具调用 ID
-     *
-     * @param id - 原始 ID
-     * @returns 规范化后的 ID
-     */
-    normalizeId(id) {
-        assertToolCallIdManagerNativeAvailable();
-        const raw = typeof id === 'string' ? id : '';
-        const output = transformToolCallIdWithNative(this.state, raw);
-        this.state = output.state;
-        return output.id;
-    }
-    /**
-     * 规范化工具调用 ID（带别名注册）
-     *
-     * @param id - 原始 ID
-     * @param aliasMap - 别名映射（用于 preserve 风格）
-     * @returns 规范化后的 ID
-     */
-    normalizeIdWithAlias(id, aliasMap) {
-        assertToolCallIdManagerNativeAvailable();
-        const raw = typeof id === 'string' ? id : '';
-        const trimmed = raw.trim();
-        if (this.options.style === 'preserve' && trimmed && aliasMap?.has(trimmed)) {
-            const existing = aliasMap.get(trimmed);
-            const aliasState = this.state.aliasMap;
-            if (aliasState && typeof aliasState === 'object') {
-                aliasState[trimmed] = existing;
-            }
-            return existing;
-        }
-        const output = transformToolCallIdWithNative(this.state, raw);
-        this.state = output.state;
-        if (this.options.style === 'preserve' && trimmed && aliasMap) {
-            aliasMap.set(trimmed, output.id);
-        }
-        return output.id;
-    }
-    /**
-     * 批量规范化工具调用 ID
-     *
-     * @param ids - ID 列表
-     * @returns 规范化后的 ID 列表
-     */
-    normalizeIds(ids) {
-        return ids.map((id) => this.normalizeId(id));
-    }
-    /**
-     * 检查 ID 是否为有效的 fc_ 风格
-     */
-    isValidFcStyle(id) {
-        return /^fc_[a-z0-9]+$/i.test(id);
-    }
-    /**
-     * 从 ID 中提取基础部分（移除前缀）
-     */
-    extractBaseId(id) {
-        if (this.options.style === 'fc') {
-            const match = id.match(/^fc_(.+)$/i);
-            return match ? match[1] : id;
-        }
-        return id;
-    }
-    /**
-     * 重置计数器
-     */
-    resetCounter() {
-        this.state = createToolCallIdTransformerWithNative(this.options.style);
-    }
-    /**
-     * 获取当前配置
-     */
-    getOptions() {
-        return { ...this.options };
-    }
-    /**
-     * 更新配置
-     */
-    updateOptions(options) {
-        this.options = { ...this.options, ...options };
-        this.state = createToolCallIdTransformerWithNative(this.options.style);
-    }
-}
-/**
- * 规范化工具调用 ID 值
- *
- * @param value - ID 值（可能是字符串或其他类型）
- * @param forceGenerate - 如果为 true，总是生成新 ID
- * @returns 规范化后的 ID 字符串
- */
-export function normalizeIdValue(value, forceGenerate = false) {
-    assertToolCallIdManagerNativeAvailable();
-    return normalizeIdValueWithNative(value, forceGenerate);
-}
-/**
- * 从对象中提取工具调用 ID
- *
- * @param obj - 包含 ID 的对象
- * @returns 提取的 ID
- */
-export function extractToolCallId(obj) {
-    assertToolCallIdManagerNativeAvailable();
-    return extractToolCallIdWithNative(obj);
-}
-/**
- * 创建工具调用 ID 转换器（用于 Responses 格式）
- *
- * @param style - ID 风格
- * @returns 转换器函数
- */
-export function createToolCallIdTransformer(style) {
-    assertToolCallIdManagerNativeAvailable();
-    if (style !== 'fc' && style !== 'preserve')
-        return null;
-    const state = createToolCallIdTransformerWithNative(style);
-    return (id) => {
-        const output = transformToolCallIdWithNative(state, id);
-        Object.assign(state, output.state);
-        return output.id;
-    };
-}
-/**
- * 在消息列表中强制应用工具调用 ID 风格
- *
- * @param messages - 消息列表
- * @param transformer - ID 转换器
- */
-export function enforceToolCallIdStyle(messages, transformer) {
-    assertToolCallIdManagerNativeAvailable();
-    if (!messages || !Array.isArray(messages)) {
-        return;
-    }
-    const state = createToolCallIdTransformerWithNative('fc');
-    const updated = enforceToolCallIdStyleWithNative(messages, state);
-    const nextMessages = updated.messages;
-    if (transformer && typeof transformer === 'function') {
-        for (const message of nextMessages) {
-            if (!message || typeof message !== 'object')
-                continue;
-            const role = message.role;
-            if (role === 'assistant' && Array.isArray(message.tool_calls)) {
-                for (const call of message.tool_calls) {
-                    if (!call || typeof call !== 'object')
-                        continue;
-                    const id = extractToolCallId(call);
-                    if (id) {
-                        call.id = transformer(id);
-                    }
-                }
-            }
-            if (role === 'tool') {
-                const id = extractToolCallId(message);
-                if (id) {
-                    message.tool_call_id = transformer(id);
-                }
-            }
-        }
-    }
-    messages.splice(0, messages.length, ...nextMessages);
-}

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-call-utils.d.ts

@@ -1,11 +0,0 @@
-type UnknownRecord = Record<string, unknown>;
-/**
- * Derive a deterministic key for a tool call by combining the normalized
- * function name and serialized arguments. Used to deduplicate inferred calls.
- */
-export declare function deriveToolCallKey(call: UnknownRecord | null | undefined): string | null;
-/**
- * Merge tool call entries with deduplication (by derived key). Returns the new array.
- */
-export declare function mergeToolCalls(existing: UnknownRecord[] | undefined, additions: UnknownRecord[] | undefined): UnknownRecord[];
-export {};

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-call-utils.js

@@ -1,14 +0,0 @@
-import { deriveToolCallKeyWithNative, mergeToolCallsWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
-/**
- * Derive a deterministic key for a tool call by combining the normalized
- * function name and serialized arguments. Used to deduplicate inferred calls.
- */
-export function deriveToolCallKey(call) {
-    return deriveToolCallKeyWithNative(call);
-}
-/**
- * Merge tool call entries with deduplication (by derived key). Returns the new array.
- */
-export function mergeToolCalls(existing, additions) {
-    return mergeToolCallsWithNative(existing, additions);
-}

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-filter-pipeline.d.ts

@@ -1,21 +0,0 @@
-import type { ToolFilterHints } from '../../filters/index.js';
-interface RequestFilterOptions {
-    entryEndpoint?: string;
-    requestId?: string;
-    model?: string;
-    profile?: string;
-    stream?: boolean;
-    toolFilterHints?: ToolFilterHints;
-    /**
-     * Optional raw payload snapshot for local tool governance (e.g. view_image exposure).
-     */
-    rawPayload?: Record<string, unknown>;
-}
-interface ResponseFilterOptions {
-    entryEndpoint?: string;
-    requestId?: string;
-    profile?: string;
-}
-export declare function runChatRequestToolFilters(chatRequest: any, options?: RequestFilterOptions): Promise<any>;
-export declare function runChatResponseToolFilters(chatJson: any, options?: ResponseFilterOptions): Promise<any>;
-export {};

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-filter-pipeline.js

@@ -1,171 +0,0 @@
-import { FilterEngine } from '../../filters/index.js';
-import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
-import { createSnapshotWriter } from '../snapshot-utils.js';
-import { normalizeChatResponseReasoningToolsWithNative as normalizeChatResponseReasoningTools } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
-const REQUEST_FILTER_STAGES = [
-    'request_pre',
-    'request_map',
-    'request_post',
-    'request_finalize'
-];
-const RESPONSE_FILTER_STAGES = [
-    'response_pre',
-    'response_map',
-    'response_post',
-    'response_finalize'
-];
-function assertStageCoverage(label, registeredStages, skeletonStages) {
-    const allowed = new Set(skeletonStages);
-    const uncovered = [];
-    for (const stage of registeredStages) {
-        if (!allowed.has(stage)) {
-            uncovered.push(stage);
-        }
-    }
-    if (uncovered.length) {
-        throw new Error(`[tool-filter-pipeline] ${label}: registered filter stage(s) not covered by skeleton: ${uncovered.join(', ')}`);
-    }
-}
-export async function runChatRequestToolFilters(chatRequest, options = {}) {
-    const reqCtxBase = {
-        requestId: options.requestId ?? `req_${Date.now()}`,
-        model: typeof options.model === 'string' ? options.model : (chatRequest && typeof chatRequest === 'object' && typeof chatRequest.model === 'string' ? String(chatRequest.model) : 'unknown'),
-        endpoint: options.entryEndpoint || '/v1/chat/completions',
-        profile: options.profile || 'openai-chat',
-        stream: options.stream === true,
-        toolFilterHints: options.toolFilterHints,
-        debug: { emit: () => { } }
-    };
-    const snapshot = createSnapshotWriter({
-        requestId: reqCtxBase.requestId,
-        endpoint: reqCtxBase.endpoint,
-        folderHint: 'openai-chat'
-    });
-    const recordStage = (stage, payload) => {
-        if (!snapshot)
-            return;
-        snapshot(stage, payload);
-    };
-    const preFiltered = applyLocalToolGovernance(chatRequest, options.rawPayload);
-    recordStage('req_process_tool_filters_input', preFiltered);
-    const engine = new FilterEngine();
-    const registeredStages = new Set();
-    const register = (filter) => {
-        registeredStages.add(filter.stage);
-        engine.registerFilter(filter);
-    };
-    const profile = (reqCtxBase.profile || '').toLowerCase();
-    const endpoint = (reqCtxBase.endpoint || '').toLowerCase();
-    const isAnthropic = profile === 'anthropic-messages' || endpoint.includes('/v1/messages');
-    if (!isAnthropic) {
-        try {
-            const { RequestToolListFilter } = await import('../../filters/index.js');
-            register(new RequestToolListFilter());
-        }
-        catch {
-            /* optional */
-        }
-    }
-    const { RequestToolCallsStringifyFilter, RequestToolChoicePolicyFilter } = await import('../../filters/index.js');
-    register(new RequestToolCallsStringifyFilter());
-    if (!isAnthropic) {
-        register(new RequestToolChoicePolicyFilter());
-    }
-    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 */ }
-    try {
-        const { RequestOpenAIToolsNormalizeFilter, ToolPostConstraintsFilter } = await import('../../filters/index.js');
-        register(new RequestOpenAIToolsNormalizeFilter());
-        register(new ToolPostConstraintsFilter('request_finalize'));
-    }
-    catch {
-        // optional; keep prior behavior when filter not available
-    }
-    assertStageCoverage('request', registeredStages, REQUEST_FILTER_STAGES);
-    let staged = preFiltered;
-    for (const stage of REQUEST_FILTER_STAGES) {
-        staged = await engine.run(stage, staged, reqCtxBase);
-        recordStage(`req_process_tool_filters_${stage}`, staged);
-    }
-    recordStage('req_process_tool_filters_output', staged);
-    return staged;
-}
-function applyLocalToolGovernance(chatRequest, _rawPayload) {
-    if (!chatRequest || typeof chatRequest !== 'object') {
-        return chatRequest;
-    }
-    return chatRequest;
-}
-export async function runChatResponseToolFilters(chatJson, options = {}) {
-    const resCtxBase = {
-        requestId: options.requestId ?? `req_${Date.now()}`,
-        model: undefined,
-        endpoint: options.entryEndpoint || '/v1/chat/completions',
-        profile: options.profile || 'openai-chat',
-        debug: { emit: () => { } }
-    };
-    const snapshot = createSnapshotWriter({
-        requestId: resCtxBase.requestId,
-        endpoint: resCtxBase.endpoint,
-        folderHint: 'openai-chat'
-    });
-    const recordStage = (stage, payload) => {
-        if (!snapshot)
-            return;
-        snapshot(stage, payload);
-    };
-    recordStage('resp_process_tool_filters_input', chatJson);
-    try {
-        if (chatJson && typeof chatJson === 'object') {
-            chatJson = normalizeChatResponseReasoningTools(chatJson, 'reasoning_choice');
-        }
-    }
-    catch {
-        // best-effort; do not block response flow on reasoning parsing issues
-    }
-    const engine = new FilterEngine();
-    const registeredStages = new Set();
-    const register = (filter) => {
-        registeredStages.add(filter.stage);
-        engine.registerFilter(filter);
-    };
-    const { ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter, ResponseToolArgumentsBlacklistFilter, ResponseToolArgumentsSchemaConvergeFilter } = await import('../../filters/index.js');
-    register(new ResponseToolTextCanonicalizeFilter());
-    try {
-        register(new ResponseToolArgumentsSchemaConvergeFilter());
-    }
-    catch { /* optional */ }
-    register(new ResponseToolArgumentsBlacklistFilter());
-    register(new ResponseToolArgumentsStringifyFilter());
-    register(new ResponseFinishInvariantsFilter());
-    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 */ }
-    assertStageCoverage('response', registeredStages, RESPONSE_FILTER_STAGES);
-    let staged = chatJson;
-    for (const stage of RESPONSE_FILTER_STAGES) {
-        staged = await engine.run(stage, staged, resCtxBase);
-        recordStage(`resp_process_tool_filters_${stage}`, staged);
-    }
-    recordStage('resp_process_tool_filters_output', staged);
-    return staged;
-}

package/vendor/@jsonstudio/llms/dist/conversion/shared/tool-governor.d.ts

@@ -1,29 +0,0 @@
-type Unknown = Record<string, unknown>;
-export interface ToolGovernanceOptions {
-    injectGuidance?: boolean;
-    snapshot?: {
-        enabled?: boolean;
-        endpoint?: string;
-        requestId?: string;
-        baseDir?: string;
-    };
-}
-/**
- * Process OpenAI Chat request (messages/tools) with unified 标准 governance.
- * - Augment tools (strict schemas)
- * - Inject/Refine system tool guidance (idempotent)
- * - Canonicalize structured tool_calls; set content=null when applicable
- */
-export declare function processChatRequestTools(request: Unknown, opts?: ToolGovernanceOptions): Unknown;
-export declare function normalizeApplyPatchToolCallsOnResponse(chat: Unknown): Unknown;
-export declare function normalizeApplyPatchToolCallsOnRequest(request: Unknown): Unknown;
-export declare function processChatResponseTools(resp: Unknown): Unknown;
-export interface GovernContext extends ToolGovernanceOptions {
-    phase: 'request' | 'response';
-    endpoint?: 'chat' | 'responses' | 'messages';
-    stream?: boolean;
-    produceRequiredAction?: boolean;
-    requestId?: string;
-}
-export declare function governTools(payload: Unknown, ctx: GovernContext): Unknown;
-export {};