@jsonstudio/rcc 0.90.352 → 0.90.367

package/vendor/llmswitch-core/dist/conversion/shared/tool-harvester.d.ts

@@ -0,0 +1,31 @@
+type Unknown = Record<string, unknown>;
+export interface HarvestContext {
+    requestId?: string;
+    idPrefix?: string;
+    chunkSize?: number;
+    source?: 'chat' | 'responses' | 'messages';
+}
+export interface HarvestSignal {
+    type: 'delta' | 'final' | 'compat';
+    payload: Unknown;
+}
+export interface DeltaEvent {
+    tool_calls?: Array<{
+        index: number;
+        id: string;
+        type: 'function';
+        function: {
+            name?: string;
+            arguments?: string;
+        };
+    }>;
+    content?: string;
+    role?: string;
+}
+export interface HarvestResult {
+    deltaEvents: DeltaEvent[];
+    normalized?: Unknown;
+    stats?: Unknown;
+}
+export declare function harvestTools(signal: HarvestSignal, ctx?: HarvestContext): HarvestResult;
+export {};

package/vendor/llmswitch-core/dist/conversion/shared/tool-harvester.js

@@ -0,0 +1,23 @@
+import { harvestToolsWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
+function assertToolHarvesterNativeAvailable() {
+    if (typeof harvestToolsWithNative !== 'function') {
+        throw new Error('[tool-harvester] native bindings are required');
+    }
+}
+export function harvestTools(signal, ctx) {
+    assertToolHarvesterNativeAvailable();
+    const result = harvestToolsWithNative({
+        signal: signal,
+        context: ctx
+    });
+    const normalized = result?.normalized;
+    if (normalized && signal?.payload && typeof signal.payload === 'object') {
+        const target = signal.payload;
+        const next = normalized;
+        for (const key of Object.keys(target)) {
+            delete target[key];
+        }
+        Object.assign(target, next);
+    }
+    return result;
+}

package/vendor/llmswitch-core/dist/conversion/shared/tool-mapping.d.ts

@@ -0,0 +1,19 @@
+import type { ChatToolDefinition } from '../hub/types/chat-envelope.js';
+import type { BridgeToolDefinition } from '../types/bridge-message-types.js';
+export interface ToolCallFunction {
+    name: string;
+    arguments: string;
+}
+export interface ToolCallItem {
+    id?: string;
+    type: 'function';
+    function: ToolCallFunction;
+}
+export interface BridgeToolMapOptions {
+    sanitizeName?: (name: string) => string | undefined;
+}
+export declare function stringifyArgs(args: unknown): string;
+export declare function bridgeToolToChatDefinition(rawTool: BridgeToolDefinition | Record<string, unknown> | null | undefined, options?: BridgeToolMapOptions): ChatToolDefinition | null;
+export declare function mapBridgeToolsToChat(rawTools: unknown, options?: BridgeToolMapOptions): ChatToolDefinition[] | undefined;
+export declare function chatToolToBridgeDefinition(rawTool: ChatToolDefinition | Record<string, unknown> | null | undefined, options?: BridgeToolMapOptions): BridgeToolDefinition | null;
+export declare function mapChatToolsToBridge(rawTools: unknown, options?: BridgeToolMapOptions): BridgeToolDefinition[] | undefined;

package/vendor/llmswitch-core/dist/conversion/shared/tool-mapping.js

@@ -0,0 +1,65 @@
+import { bridgeToolToChatDefinitionWithNative, chatToolToBridgeDefinitionWithNative, mapBridgeToolsToChatWithNative, mapChatToolsToBridgeWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function stringifyArgs(args) {
+    if (typeof args === 'string')
+        return args;
+    try {
+        return JSON.stringify(args ?? {});
+    }
+    catch {
+        return String(args);
+    }
+}
+function assertToolMappingNativeAvailable() {
+    if (typeof bridgeToolToChatDefinitionWithNative !== 'function' ||
+        typeof chatToolToBridgeDefinitionWithNative !== 'function' ||
+        typeof mapBridgeToolsToChatWithNative !== 'function' ||
+        typeof mapChatToolsToBridgeWithNative !== 'function') {
+        throw new Error('[tool-mapping] native bindings unavailable');
+    }
+}
+function resolveSanitizeMode(options, fallback = 'responses') {
+    const probe = options?.sanitizeName?.('shell_command') ?? options?.sanitizeName?.('Bash');
+    if (typeof probe === 'string' && probe === 'shell_command') {
+        return 'anthropic';
+    }
+    if (typeof probe === 'string' && probe === 'Bash') {
+        return 'anthropic_denormalize';
+    }
+    return fallback;
+}
+export function bridgeToolToChatDefinition(rawTool, options) {
+    if (!rawTool || typeof rawTool !== 'object') {
+        return null;
+    }
+    assertToolMappingNativeAvailable();
+    const sanitizeMode = resolveSanitizeMode(options, 'responses');
+    const mapped = bridgeToolToChatDefinitionWithNative(rawTool, { sanitizeMode });
+    return mapped ?? null;
+}
+export function mapBridgeToolsToChat(rawTools, options) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+        return undefined;
+    }
+    assertToolMappingNativeAvailable();
+    const sanitizeMode = resolveSanitizeMode(options, 'responses');
+    const mapped = mapBridgeToolsToChatWithNative(rawTools, { sanitizeMode });
+    return mapped.length ? mapped : undefined;
+}
+export function chatToolToBridgeDefinition(rawTool, options) {
+    if (!rawTool || typeof rawTool !== 'object') {
+        return null;
+    }
+    assertToolMappingNativeAvailable();
+    const sanitizeMode = resolveSanitizeMode(options, 'responses');
+    const mapped = chatToolToBridgeDefinitionWithNative(rawTool, { sanitizeMode });
+    return mapped ?? null;
+}
+export function mapChatToolsToBridge(rawTools, options) {
+    if (!Array.isArray(rawTools) || rawTools.length === 0) {
+        return undefined;
+    }
+    assertToolMappingNativeAvailable();
+    const sanitizeMode = resolveSanitizeMode(options, 'responses');
+    const mapped = mapChatToolsToBridgeWithNative(rawTools, { sanitizeMode });
+    return mapped.length ? mapped : undefined;
+}

package/vendor/llmswitch-core/dist/conversion/shared/tooling.d.ts

@@ -0,0 +1,29 @@
+export interface ShellArgs {
+    command: string | string[];
+    workdir?: string;
+    timeout_ms?: number;
+}
+/**
+ * Minimal, idempotent repairs for common `find` invocations inside shell scripts:
+ * - ensure `-exec … ;` is escaped as `-exec … \;`
+ * - collapse multiple backslashes before `;` into a single backslash
+ * - escape bare parentheses used in predicates: `(` / `)` → `\(` / `\)`
+ */
+export declare function repairFindMeta(script: string): string;
+export declare function splitCommandString(input: string): string[];
+/**
+ * Pack shell arguments per unified rules:
+ * - command: string -> ["bash","-lc","<string>"]
+ * - command: tokens[]
+ *   - if starts with ["cd", path, ...rest]:
+ *       - set workdir to path when absent
+ *       - if rest empty => command=["pwd"]
+ *       - else if rest has control tokens => command=["bash","-lc", join(rest)]
+ *       - else command=rest (argv)
+ *   - else if tokens contain control tokens => command=["bash","-lc", join(tokens)]
+ *   - else command=tokens (argv)
+ * - join(rest) uses single-space join without extra quoting
+ */
+export declare function packShellArgs(input: Record<string, unknown>): Record<string, unknown>;
+export declare function flattenByComma(arr: string[]): string[];
+export declare function chunkString(s: string, minParts?: number, maxParts?: number, targetChunk?: number): string[];

package/vendor/llmswitch-core/dist/conversion/shared/tooling.js

@@ -0,0 +1,57 @@
+/**
+ * Shared helpers for standard tool normalization (shell packing rules).
+ * The goal is deterministic, minimal shaping so executors succeed consistently.
+ */
+import { chunkStringWithNative, flattenByCommaWithNative, packShellArgsWithNative, repairFindMetaWithNative, splitCommandStringWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function assertToolingNativeAvailable() {
+    if (typeof repairFindMetaWithNative !== 'function' ||
+        typeof splitCommandStringWithNative !== 'function' ||
+        typeof packShellArgsWithNative !== 'function' ||
+        typeof flattenByCommaWithNative !== 'function' ||
+        typeof chunkStringWithNative !== 'function') {
+        throw new Error('[tooling] native bindings unavailable');
+    }
+}
+// We intentionally do NOT evaluate shell control operators (&&, |, etc.).
+// Codex CLI executor runs argv directly (execvp-like), not through a shell.
+// So we avoid wrapping with "bash -lc" and leave such tokens as-is.
+/**
+ * Minimal, idempotent repairs for common `find` invocations inside shell scripts:
+ * - ensure `-exec … ;` is escaped as `-exec … \;`
+ * - collapse multiple backslashes before `;` into a single backslash
+ * - escape bare parentheses used in predicates: `(` / `)` → `\(` / `\)`
+ */
+export function repairFindMeta(script) {
+    assertToolingNativeAvailable();
+    return repairFindMetaWithNative(script ?? '');
+}
+export function splitCommandString(input) {
+    assertToolingNativeAvailable();
+    return splitCommandStringWithNative(input ?? '');
+}
+/**
+ * Pack shell arguments per unified rules:
+ * - command: string -> ["bash","-lc","<string>"]
+ * - command: tokens[]
+ *   - if starts with ["cd", path, ...rest]:
+ *       - set workdir to path when absent
+ *       - if rest empty => command=["pwd"]
+ *       - else if rest has control tokens => command=["bash","-lc", join(rest)]
+ *       - else command=rest (argv)
+ *   - else if tokens contain control tokens => command=["bash","-lc", join(tokens)]
+ *   - else command=tokens (argv)
+ * - join(rest) uses single-space join without extra quoting
+ */
+export function packShellArgs(input) {
+    assertToolingNativeAvailable();
+    return packShellArgsWithNative(input);
+}
+export function flattenByComma(arr) {
+    assertToolingNativeAvailable();
+    return flattenByCommaWithNative(arr);
+}
+// Helper to chunk a long string into N parts (bounded)
+export function chunkString(s, minParts = 3, maxParts = 12, targetChunk = 12) {
+    assertToolingNativeAvailable();
+    return chunkStringWithNative(s, minParts, maxParts, targetChunk);
+}

package/vendor/llmswitch-core/dist/conversion/snapshot-utils.d.ts

@@ -0,0 +1,31 @@
+export interface SnapshotHookOptions {
+    endpoint: string;
+    stage: string;
+    requestId: string;
+    data: unknown;
+    verbosity?: 'minimal' | 'verbose';
+    channel?: string;
+    providerKey?: string;
+    groupRequestId?: string;
+}
+interface SnapshotPayload {
+    stage: string;
+    requestId: string;
+    endpoint?: string;
+    data: unknown;
+    folderHint?: string;
+    providerKey?: string;
+    groupRequestId?: string;
+}
+export declare function shouldRecordSnapshots(): boolean;
+export declare function writeSnapshotViaHooks(options: SnapshotHookOptions): Promise<void>;
+export declare function recordSnapshot(options: SnapshotPayload): Promise<void>;
+export type SnapshotWriter = (stage: string, payload: unknown) => void;
+export declare function createSnapshotWriter(opts: {
+    requestId: string;
+    endpoint?: string;
+    folderHint?: string;
+    providerKey?: string;
+    groupRequestId?: string;
+}): SnapshotWriter | undefined;
+export {};

package/vendor/llmswitch-core/dist/conversion/snapshot-utils.js

@@ -0,0 +1,49 @@
+import { shouldRecordSnapshotsWithNative, writeSnapshotViaHooksWithNative } from '../router/virtual-router/engine-selection/native-snapshot-hooks.js';
+export function shouldRecordSnapshots() {
+    return shouldRecordSnapshotsWithNative();
+}
+export async function writeSnapshotViaHooks(options) {
+    writeSnapshotViaHooksWithNative({
+        endpoint: options.endpoint,
+        stage: options.stage,
+        requestId: options.requestId,
+        data: options.data,
+        verbosity: options.verbosity,
+        channel: options.channel,
+        providerKey: options.providerKey,
+        groupRequestId: options.groupRequestId
+    });
+}
+export async function recordSnapshot(options) {
+    if (!shouldRecordSnapshots())
+        return;
+    const endpoint = options.endpoint || '/v1/chat/completions';
+    void writeSnapshotViaHooks({
+        endpoint,
+        stage: options.stage,
+        requestId: options.requestId,
+        providerKey: options.providerKey,
+        groupRequestId: options.groupRequestId,
+        data: options.data,
+        verbosity: 'verbose'
+    }).catch(() => {
+        // ignore hook errors
+    });
+}
+export function createSnapshotWriter(opts) {
+    if (!shouldRecordSnapshots()) {
+        return undefined;
+    }
+    const endpoint = opts.endpoint || '/v1/chat/completions';
+    return (stage, payload) => {
+        void recordSnapshot({
+            stage,
+            requestId: opts.requestId,
+            endpoint,
+            folderHint: opts.folderHint,
+            providerKey: opts.providerKey,
+            groupRequestId: opts.groupRequestId,
+            data: payload
+        });
+    };
+}

package/vendor/llmswitch-core/dist/conversion/types/bridge-message-types.d.ts

@@ -0,0 +1,41 @@
+import type { NativeReqInboundSemanticLiftApplyInput } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export type BridgeContentPart = {
+    type: string;
+    text?: string;
+    content?: unknown;
+};
+export type BridgeInputItem = {
+    type: string;
+    role?: string;
+    content?: Array<BridgeContentPart> | null;
+    name?: string;
+    arguments?: unknown;
+    call_id?: string;
+    output?: unknown;
+    function?: {
+        name?: string;
+        arguments?: unknown;
+    };
+    message?: {
+        role?: string;
+        content?: Array<BridgeContentPart>;
+    };
+    id?: string;
+    tool_call_id?: string;
+    tool_use_id?: string;
+    text?: string;
+};
+export type BridgeToolDefinition = {
+    type: string;
+    name?: string;
+    description?: string;
+    strict?: boolean;
+    parameters?: unknown;
+    function?: {
+        name?: string;
+        description?: string;
+        strict?: boolean;
+        parameters?: unknown;
+    };
+};
+export type BridgeNativeEnvelope = NativeReqInboundSemanticLiftApplyInput['chatEnvelope'];

package/vendor/llmswitch-core/dist/conversion/types/bridge-message-types.js

@@ -0,0 +1 @@
+export {};

package/vendor/llmswitch-core/dist/conversion/types/text-markup-normalizer.d.ts

@@ -0,0 +1,13 @@
+export type JsonToolArgumentAliasMap = Record<string, string[]>;
+export type JsonToolRepairConfig = {
+    toolNameAliases?: Record<string, string>;
+    argumentAliases?: Record<string, JsonToolArgumentAliasMap>;
+};
+export type TextMarkupNormalizeOptions = {
+    jsonToolRepair?: JsonToolRepairConfig;
+};
+export type ToolCallLite = {
+    id?: string;
+    name: string;
+    args: string;
+};

package/vendor/llmswitch-core/dist/conversion/types/text-markup-normalizer.js

@@ -0,0 +1 @@
+export {};

package/vendor/llmswitch-core/dist/conversion/types.d.ts

@@ -0,0 +1,33 @@
+export interface ConversionProfile {
+    id: string;
+    incomingProtocol: string;
+    outgoingProtocol: string;
+    codec: string;
+    inputSchema?: string;
+    canonicalRequestSchema?: string;
+    canonicalResponseSchema?: string;
+    clientResponseSchema?: string;
+    trace?: boolean;
+}
+export interface ConversionConfigFile {
+    profiles: Record<string, Omit<ConversionProfile, 'id'>>;
+    endpointBindings?: Record<string, string>;
+}
+export interface ConversionContext {
+    requestId?: string;
+    endpoint?: string;
+    entryEndpoint?: string;
+    targetProtocol?: string;
+    stream?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface ConversionResult {
+    profile: ConversionProfile;
+    payload: any;
+}
+export interface ConversionCodec {
+    readonly id: string;
+    initialize(): Promise<void>;
+    convertRequest(payload: any, profile: ConversionProfile, context: ConversionContext): Promise<any>;
+    convertResponse(payload: any, profile: ConversionProfile, context: ConversionContext): Promise<any>;
+}

package/vendor/llmswitch-core/dist/conversion/types.js

@@ -0,0 +1 @@
+export {};

package/vendor/llmswitch-core/dist/filters/builtin/add-fields-filter.d.ts

@@ -0,0 +1,8 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+export declare class AddFieldsFilter implements Filter<JsonObject> {
+    readonly name = "add_fields";
+    readonly stage: any;
+    private readonly fields;
+    constructor(stage: FilterContext['stage'], fields: Record<string, unknown>);
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}

package/vendor/llmswitch-core/dist/filters/builtin/add-fields-filter.js

@@ -0,0 +1,16 @@
+export class AddFieldsFilter {
+    name = 'add_fields';
+    stage;
+    fields;
+    constructor(stage, fields) {
+        this.stage = stage;
+        this.fields = fields || {};
+    }
+    apply(input) {
+        const out = JSON.parse(JSON.stringify(input || {}));
+        for (const [k, v] of Object.entries(this.fields)) {
+            out[k] = v;
+        }
+        return { ok: true, data: out };
+    }
+}

package/vendor/llmswitch-core/dist/filters/builtin/blacklist-filter.d.ts

@@ -0,0 +1,8 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+export declare class BlacklistFilter implements Filter<JsonObject> {
+    readonly name = "blacklist";
+    readonly stage: any;
+    private readonly deny;
+    constructor(stage: FilterContext['stage'], deny: string[]);
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}

package/vendor/llmswitch-core/dist/filters/builtin/blacklist-filter.js

@@ -0,0 +1,19 @@
+export class BlacklistFilter {
+    name = 'blacklist';
+    stage;
+    deny;
+    constructor(stage, deny) {
+        this.stage = stage;
+        this.deny = new Set(deny || []);
+    }
+    apply(input) {
+        if (!input || typeof input !== 'object')
+            return { ok: true, data: input };
+        const out = JSON.parse(JSON.stringify(input));
+        for (const k of Object.keys(out)) {
+            if (this.deny.has(k))
+                delete out[k];
+        }
+        return { ok: true, data: out };
+    }
+}

package/vendor/llmswitch-core/dist/filters/builtin/whitelist-filter.d.ts

@@ -0,0 +1,8 @@
+import type { Filter, FilterContext, FilterResult, JsonObject } from '../types.js';
+export declare class WhitelistFilter implements Filter<JsonObject> {
+    readonly name = "whitelist";
+    readonly stage: any;
+    private readonly allow;
+    constructor(stage: FilterContext['stage'], allow: string[]);
+    apply(input: JsonObject): FilterResult<JsonObject>;
+}

package/vendor/llmswitch-core/dist/filters/builtin/whitelist-filter.js

@@ -0,0 +1,19 @@
+export class WhitelistFilter {
+    name = 'whitelist';
+    stage;
+    allow;
+    constructor(stage, allow) {
+        this.stage = stage;
+        this.allow = new Set(allow || []);
+    }
+    apply(input) {
+        if (!input || typeof input !== 'object')
+            return { ok: true, data: input };
+        const out = {};
+        for (const k of Object.keys(input)) {
+            if (this.allow.has(k))
+                out[k] = input[k];
+        }
+        return { ok: true, data: out };
+    }
+}

package/vendor/llmswitch-core/dist/filters/config/openai-openai.fieldmap.json

@@ -0,0 +1,18 @@
+{
+    "request": [
+        {
+            "sourcePath": "messages[*].tool_calls[*].function.arguments",
+            "targetPath": "messages[*].tool_calls[*].function.arguments",
+            "type": "string",
+            "transform": "stringifyJson"
+        }
+    ],
+    "response": [
+        {
+            "sourcePath": "choices[*].message.tool_calls[*].function.arguments",
+            "targetPath": "choices[*].message.tool_calls[*].function.arguments",
+            "type": "string",
+            "transform": "stringifyJson"
+        }
+    ]
+}

package/vendor/llmswitch-core/dist/filters/engine.d.ts

@@ -0,0 +1,16 @@
+import type { Filter, FilterContext, FieldMapConfig, JsonObject } from './types.js';
+export declare class FilterEngine {
+    private readonly filters;
+    private fieldMap?;
+    private readonly transforms;
+    registerFilter(filter: Filter): void;
+    setFieldMap(config: FieldMapConfig): void;
+    registerTransform(name: string, fn: (v: unknown) => unknown): void;
+    run(stage: FilterContext['stage'], payload: JsonObject, ctxBase: Omit<FilterContext, 'stage'>): Promise<JsonObject>;
+    private applyFieldMap;
+    private coerce;
+    private deepClone;
+    private mutateWildcardPath;
+    private getByPath;
+    private setByPath;
+}