@jsonstudio/rcc 0.89.555 → 0.89.682

package/node_modules/@jsonstudio/llms/dist/conversion/hub/semantic-mappers/responses-mapper.js

@@ -1,278 +0,0 @@
-import { isJsonObject, jsonClone } from '../types/json.js';
-import { createBridgeActionState, runBridgeActionPipeline } from '../../shared/bridge-actions.js';
-import { resolveBridgePolicy, resolvePolicyActions } from '../../shared/bridge-policies.js';
-import { captureResponsesContext, buildChatRequestFromResponses, buildResponsesRequestFromChat } from '../../responses/responses-openai-bridge.js';
-const RESPONSES_PARAMETER_KEYS = [
-    'model',
-    'temperature',
-    'top_p',
-    'top_k',
-    'max_tokens',
-    'max_output_tokens',
-    'response_format',
-    'tool_choice',
-    'parallel_tool_calls',
-    'user',
-    'logit_bias',
-    'seed',
-    'stop',
-    'stop_sequences',
-    'modalities'
-];
-function mapToolOutputs(entries, missing) {
-    if (!entries || !entries.length)
-        return undefined;
-    const outputs = [];
-    entries.forEach((entry, index) => {
-        if (!isJsonObject(entry)) {
-            missing.push({ path: `tool_outputs[${index}]`, reason: 'invalid_entry', originalValue: jsonClone(entry) });
-            return;
-        }
-        const callId = entry.tool_call_id || entry.call_id || entry.id;
-        if (!callId) {
-            missing.push({ path: `tool_outputs[${index}].tool_call_id`, reason: 'missing_tool_call_id' });
-            return;
-        }
-        let content = '';
-        if (typeof entry.output === 'string') {
-            content = entry.output;
-        }
-        else if (entry.output != null) {
-            try {
-                content = JSON.stringify(entry.output);
-            }
-            catch {
-                content = String(entry.output);
-            }
-        }
-        outputs.push({
-            tool_call_id: String(callId),
-            content,
-            name: typeof entry.name === 'string' ? entry.name : undefined
-        });
-    });
-    return outputs.length ? outputs : undefined;
-}
-function collectParameters(payload, streamHint) {
-    const params = {};
-    for (const key of RESPONSES_PARAMETER_KEYS) {
-        if (payload[key] !== undefined) {
-            params[key] = payload[key];
-        }
-    }
-    if (streamHint !== undefined) {
-        params.stream = streamHint;
-    }
-    return Object.keys(params).length ? params : undefined;
-}
-function normalizeTools(rawTools, missing) {
-    if (!rawTools || rawTools.length === 0)
-        return undefined;
-    const tools = [];
-    rawTools.forEach((tool, index) => {
-        if (!tool || typeof tool !== 'object' || Array.isArray(tool)) {
-            missing.push({ path: `tools[${index}]`, reason: 'invalid_entry', originalValue: jsonClone(tool) });
-            return;
-        }
-        const fn = tool.function;
-        if (!fn || typeof fn !== 'object' || Array.isArray(fn))
-            return;
-        const name = fn.name;
-        const nameValue = typeof name === 'string' ? name : undefined;
-        if (!nameValue)
-            return;
-        const descriptionValue = fn.description;
-        const parametersValue = fn.parameters;
-        const strictValue = fn.strict;
-        const definition = {
-            type: 'function',
-            function: {
-                name: nameValue,
-                description: typeof descriptionValue === 'string' ? descriptionValue : undefined,
-                parameters: parametersValue,
-                strict: typeof strictValue === 'boolean' ? strictValue : undefined
-            }
-        };
-        tools.push(definition);
-    });
-    return tools.length ? tools : undefined;
-}
-function normalizeMessages(value, missing) {
-    if (!Array.isArray(value)) {
-        if (value !== undefined) {
-            missing.push({ path: 'messages', reason: 'invalid_type', originalValue: jsonClone(value) });
-        }
-        else {
-            missing.push({ path: 'messages', reason: 'absent' });
-        }
-        return [];
-    }
-    const messages = [];
-    value.forEach((item, index) => {
-        if (!item || typeof item !== 'object' || Array.isArray(item)) {
-            missing.push({ path: `messages[${index}]`, reason: 'invalid_entry', originalValue: jsonClone(item) });
-            return;
-        }
-        messages.push(item);
-    });
-    return messages;
-}
-function serializeSystemContent(message) {
-    if (!message)
-        return undefined;
-    const content = message.content;
-    if (typeof content === 'string')
-        return content;
-    if (Array.isArray(content)) {
-        const parts = [];
-        content.forEach(part => {
-            if (typeof part === 'string') {
-                parts.push(part);
-            }
-            else if (part && typeof part === 'object') {
-                const text = part.text;
-                if (typeof text === 'string') {
-                    parts.push(text);
-                }
-            }
-        });
-        return parts.join('');
-    }
-    if (content != null) {
-        try {
-            return JSON.stringify(content);
-        }
-        catch {
-            return String(content);
-        }
-    }
-    return undefined;
-}
-function mergeMetadata(a, b) {
-    if (!a && !b) {
-        return undefined;
-    }
-    if (!a && b) {
-        return jsonClone(b);
-    }
-    if (a && !b) {
-        return jsonClone(a);
-    }
-    const left = jsonClone(a);
-    const right = jsonClone(b);
-    return { ...left, ...right };
-}
-export class ResponsesSemanticMapper {
-    async toChat(format, ctx) {
-        const payload = format.payload || {};
-        const responsesContext = captureResponsesContext(payload, { route: { requestId: ctx.requestId } });
-        const { request, toolsNormalized } = buildChatRequestFromResponses(payload, responsesContext);
-        const missingFields = [];
-        const messages = normalizeMessages(request.messages, missingFields);
-        const toolOutputs = mapToolOutputs(payload.tool_outputs, missingFields);
-        const parameters = collectParameters(payload, responsesContext.stream);
-        const metadata = { context: ctx };
-        try {
-            const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
-            const actions = resolvePolicyActions(bridgePolicy, 'request_inbound');
-            if (actions?.length) {
-                const actionState = createBridgeActionState({
-                    rawRequest: payload,
-                    metadata: metadata
-                });
-                runBridgeActionPipeline({
-                    stage: 'request_inbound',
-                    actions,
-                    protocol: bridgePolicy?.protocol ?? 'openai-responses',
-                    moduleType: bridgePolicy?.moduleType ?? 'openai-responses',
-                    requestId: ctx.requestId,
-                    state: actionState
-                });
-            }
-        }
-        catch {
-            // ignore policy hook failures
-        }
-        if (missingFields.length) {
-            metadata.missingFields = missingFields;
-        }
-        if (responsesContext.responseFormat) {
-            metadata.responseFormat = jsonClone(responsesContext.responseFormat);
-        }
-        return {
-            messages,
-            tools: normalizeTools(toolsNormalized, missingFields),
-            toolOutputs,
-            parameters,
-            metadata
-        };
-    }
-    async fromChat(chat, ctx) {
-        const modelValue = chat.parameters?.model;
-        if (typeof modelValue !== 'string' || !modelValue.trim()) {
-            throw new Error('ChatEnvelope.parameters.model is required for openai-responses outbound conversion');
-        }
-        const requestShape = {
-            ...(chat.parameters || {}),
-            model: modelValue,
-            messages: chat.messages,
-            tools: chat.tools
-        };
-        const originalSystemMessages = (chat.messages || [])
-            .filter((message) => Boolean(message && typeof message === 'object' && message.role === 'system'))
-            .map(message => serializeSystemContent(message))
-            .filter((content) => typeof content === 'string' && content.length > 0);
-        const capturedContext = chat.metadata?.responsesContext;
-        const envelopeMetadata = chat.metadata && isJsonObject(chat.metadata) ? chat.metadata : undefined;
-        const responsesContext = isJsonObject(capturedContext)
-            ? {
-                ...capturedContext,
-                metadata: mergeMetadata(capturedContext.metadata, envelopeMetadata),
-                originalSystemMessages
-            }
-            : {
-                metadata: envelopeMetadata,
-                originalSystemMessages
-            };
-        const responsesResult = buildResponsesRequestFromChat(requestShape, responsesContext);
-        const responses = responsesResult.request;
-        if (chat.parameters && chat.parameters.stream !== undefined) {
-            responses.stream = chat.parameters.stream;
-        }
-        // Do not forward ChatEnvelope.toolOutputs to OpenAI Responses create requests.
-        // Upstream expects historical tool results to remain inside input[] as
-        // tool role messages; sending the legacy top-level `tool_outputs` field
-        // causes providers like FAI to reject the request (HTTP 400). Any actual
-        // submit_tool_outputs call should be issued via the dedicated endpoint
-        // upstream, not through this mapper.
-        try {
-            const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
-            const actions = resolvePolicyActions(bridgePolicy, 'request_outbound');
-            if (actions?.length) {
-                const actionState = createBridgeActionState({
-                    rawRequest: responses,
-                    metadata: chat.metadata
-                });
-                runBridgeActionPipeline({
-                    stage: 'request_outbound',
-                    actions,
-                    protocol: bridgePolicy?.protocol ?? 'openai-responses',
-                    moduleType: bridgePolicy?.moduleType ?? 'openai-responses',
-                    requestId: ctx.requestId,
-                    state: actionState
-                });
-            }
-        }
-        catch {
-            // ignore metadata propagation failures
-        }
-        return {
-            protocol: 'openai-responses',
-            direction: 'response',
-            payload: responses,
-            meta: {
-                context: ctx
-            }
-        };
-    }
-}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/snapshot-recorder.d.ts

@@ -1,13 +0,0 @@
-import type { StageRecorder } from './format-adapters/index.js';
-import type { AdapterContext } from './types/chat-envelope.js';
-export interface SnapshotStageRecorderOptions {
-    context: AdapterContext;
-    endpoint: string;
-}
-export declare class SnapshotStageRecorder implements StageRecorder {
-    private readonly options;
-    private readonly writer?;
-    constructor(options: SnapshotStageRecorderOptions);
-    record(stage: string, payload: object): void;
-}
-export declare function createSnapshotRecorder(context: AdapterContext, endpoint: string): StageRecorder;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/snapshot-recorder.js

@@ -1,109 +0,0 @@
-import { createSnapshotWriter } from '../shared/snapshot-utils.js';
-import { jsonClone } from './types/json.js';
-export class SnapshotStageRecorder {
-    options;
-    writer;
-    constructor(options) {
-        this.options = options;
-        this.writer = createSnapshotWriter({
-            requestId: options.context.requestId,
-            endpoint: options.endpoint
-        });
-    }
-    record(stage, payload) {
-        if (!this.writer) {
-            return;
-        }
-        const normalized = normalizeStagePayload(stage, payload);
-        if (!normalized) {
-            return;
-        }
-        try {
-            this.writer(stage, normalized);
-        }
-        catch {
-            // ignore snapshot write errors
-        }
-    }
-}
-export function createSnapshotRecorder(context, endpoint) {
-    return new SnapshotStageRecorder({ context, endpoint });
-}
-const STAGE_KIND_MAP = {
-    req_inbound_stage2_semantic_map: 'request_inbound',
-    req_outbound_stage1_semantic_map: 'request_outbound',
-    resp_inbound_stage3_semantic_map: 'response_inbound',
-    resp_outbound_stage1_client_remap: 'response_outbound'
-};
-function normalizeStagePayload(stage, payload) {
-    const kind = STAGE_KIND_MAP[stage];
-    if (!kind) {
-        return payload;
-    }
-    if ((kind === 'request_inbound' || kind === 'request_outbound') && isChatEnvelope(payload)) {
-        return buildOpenAIChatSnapshot(payload);
-    }
-    if (kind === 'response_inbound' || kind === 'response_outbound') {
-        return cloneJson(payload);
-    }
-    return payload;
-}
-function isChatEnvelope(value) {
-    return Boolean(value &&
-        typeof value === 'object' &&
-        Array.isArray(value.messages) &&
-        value.metadata &&
-        typeof value.metadata === 'object');
-}
-function buildOpenAIChatSnapshot(envelope) {
-    const snapshot = {};
-    if (envelope.parameters && Object.keys(envelope.parameters).length) {
-        Object.assign(snapshot, jsonClone(envelope.parameters));
-    }
-    snapshot.messages = jsonClone(envelope.messages);
-    if (envelope.tools && envelope.tools.length) {
-        snapshot.tools = jsonClone(envelope.tools);
-    }
-    if (envelope.toolOutputs && envelope.toolOutputs.length) {
-        snapshot.tool_outputs = jsonClone(envelope.toolOutputs);
-    }
-    const meta = buildMetaSnapshot(envelope.metadata);
-    if (meta) {
-        snapshot.meta = meta;
-    }
-    return snapshot;
-}
-function buildMetaSnapshot(metadata) {
-    if (!metadata || typeof metadata !== 'object') {
-        return undefined;
-    }
-    const meta = {};
-    if (metadata.context) {
-        meta.context = jsonClone(metadata.context);
-    }
-    if (Array.isArray(metadata.missingFields) && metadata.missingFields.length) {
-        meta.missing_fields = jsonClone(metadata.missingFields);
-    }
-    const extraKeys = Object.keys(metadata).filter((key) => key !== 'context' && key !== 'missingFields');
-    if (extraKeys.length) {
-        const extras = {};
-        for (const key of extraKeys) {
-            const value = metadata[key];
-            if (value !== undefined) {
-                extras[key] = jsonClone(value);
-            }
-        }
-        if (Object.keys(extras).length) {
-            meta.extra = extras;
-        }
-    }
-    return Object.keys(meta).length ? meta : undefined;
-}
-function cloneJson(payload) {
-    try {
-        return JSON.parse(JSON.stringify(payload));
-    }
-    catch {
-        return payload;
-    }
-}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/standardized-bridge.js

@@ -1,276 +0,0 @@
-import { isJsonObject, jsonClone } from './types/json.js';
-const HUB_CAPTURE_KEY = '__hub_capture';
-export function chatEnvelopeToStandardized(chat, options) {
-    const parameters = { ...(chat.parameters ?? {}) };
-    const model = extractModel(parameters);
-    const messages = chat.messages.map((message) => normalizeChatMessage(message));
-    const tools = normalizeTools(chat.tools);
-    const metadataCaptured = {};
-    const hubState = {};
-    if (Array.isArray(chat.metadata?.missingFields) && chat.metadata?.missingFields.length) {
-        hubState.missingFields = chat.metadata.missingFields;
-    }
-    if (isJsonObject(chat.metadata?.providerMetadata)) {
-        hubState.providerMetadata = chat.metadata?.providerMetadata;
-    }
-    if (isJsonObject(chat.metadata?.extraFields)) {
-        hubState.extraFields = chat.metadata?.extraFields;
-    }
-    if (isJsonObject(chat.metadata?.protocolState)) {
-        hubState.protocolState = chat.metadata?.protocolState;
-    }
-    hubState.context = options.adapterContext;
-    if (hubStateContextPopulated(hubState)) {
-        metadataCaptured[HUB_CAPTURE_KEY] = hubState;
-    }
-    const standardized = {
-        model,
-        messages,
-        tools,
-        parameters: {
-            ...parameters
-        },
-        metadata: {
-            originalEndpoint: options.endpoint,
-            capturedContext: metadataCaptured,
-            requestId: options.requestId,
-            stream: parameters.stream === true
-        }
-    };
-    return standardized;
-}
-export function standardizedToChatEnvelope(request, options) {
-    const adapterContext = options.adapterContext;
-    const hubState = extractHubCapture(request);
-    const messages = request.messages.map((message) => {
-        const restoredContent = restoreMessageContent(message.content);
-        return {
-            role: message.role,
-            content: restoredContent,
-            tool_calls: mapToolCalls(message.tool_calls),
-            tool_call_id: message.tool_call_id,
-            name: message.name
-        };
-    });
-    const tools = mapStandardizedTools(request.tools);
-    const parameters = {
-        ...(request.parameters ?? {}),
-        model: request.model
-    };
-    const metadata = {
-        context: adapterContext
-    };
-    const sourceMeta = (request.metadata && typeof request.metadata === 'object'
-        ? request.metadata
-        : undefined);
-    if (sourceMeta) {
-        if (sourceMeta.webSearch && typeof sourceMeta.webSearch === 'object') {
-            metadata.webSearch = sourceMeta.webSearch;
-        }
-        if (sourceMeta.forceWebSearch === true) {
-            metadata.forceWebSearch = true;
-        }
-        if (sourceMeta.forceVision === true) {
-            metadata.forceVision = true;
-        }
-    }
-    if (typeof adapterContext.toolCallIdStyle === 'string' && adapterContext.toolCallIdStyle.length) {
-        metadata.toolCallIdStyle = adapterContext.toolCallIdStyle;
-    }
-    if (hubState?.missingFields) {
-        metadata.missingFields = hubState.missingFields;
-    }
-    if (hubState?.providerMetadata) {
-        metadata.providerMetadata = hubState.providerMetadata;
-    }
-    if (hubState?.extraFields) {
-        metadata.extraFields = hubState.extraFields;
-    }
-    if (hubState?.protocolState) {
-        metadata.protocolState = hubState.protocolState;
-    }
-    return {
-        messages,
-        tools,
-        parameters,
-        metadata
-    };
-}
-function extractModel(parameters) {
-    const candidate = parameters.model;
-    if (typeof candidate === 'string' && candidate.trim()) {
-        return candidate.trim();
-    }
-    throw new Error('ChatEnvelope parameters must include model string');
-}
-function normalizeChatMessage(message) {
-    const normalized = {
-        role: message.role,
-        content: cloneMessageContent(message.content)
-    };
-    if (Array.isArray(message.tool_calls) && message.tool_calls.length) {
-        normalized.tool_calls = message.tool_calls
-            .map((tool) => normalizeToolCall(tool))
-            .filter((tool) => Boolean(tool));
-    }
-    if (typeof message.tool_call_id === 'string') {
-        normalized.tool_call_id = message.tool_call_id.trim();
-    }
-    if (typeof message.name === 'string' && message.name.trim()) {
-        normalized.name = message.name.trim();
-    }
-    return normalized;
-}
-function cloneMessageContent(content) {
-    if (content === undefined || content === null) {
-        return null;
-    }
-    if (typeof content === 'string') {
-        return content;
-    }
-    if (Array.isArray(content)) {
-        return cloneContentArray(content);
-    }
-    return String(content);
-}
-function restoreMessageContent(content) {
-    if (content === undefined) {
-        return undefined;
-    }
-    if (content === null) {
-        return null;
-    }
-    if (typeof content === 'string') {
-        return content;
-    }
-    return cloneContentArray(content);
-}
-function cloneContentArray(parts) {
-    return parts.map((part) => {
-        if (part && typeof part === 'object') {
-            return jsonClone(part);
-        }
-        const text = typeof part === 'string' ? part : String(part ?? '');
-        const fallback = {
-            type: 'text',
-            text
-        };
-        return fallback;
-    });
-}
-function normalizeToolCall(toolCall) {
-    if (!toolCall || typeof toolCall !== 'object') {
-        return null;
-    }
-    const { id, type, function: fn } = toolCall;
-    if (typeof id !== 'string' || !id.trim()) {
-        return null;
-    }
-    if (type !== 'function') {
-        return null;
-    }
-    const fnRecord = fn && typeof fn === 'object' ? fn : undefined;
-    const rawName = typeof fnRecord?.name === 'string' ? fnRecord.name : '';
-    const normalizedName = rawName.trim();
-    const args = fnRecord?.arguments;
-    const serializedArgs = typeof args === 'string' ? args : safeStringify(args ?? {});
-    return {
-        id: id.trim(),
-        type: 'function',
-        function: {
-            name: normalizedName.length ? normalizedName : rawName,
-            arguments: serializedArgs
-        }
-    };
-}
-function mapToolCalls(toolCalls) {
-    if (!Array.isArray(toolCalls) || !toolCalls.length) {
-        return undefined;
-    }
-    return toolCalls.map((tool) => ({
-        id: tool.id,
-        type: 'function',
-        function: {
-            name: tool.function.name,
-            arguments: tool.function.arguments
-        }
-    }));
-}
-function mapStandardizedTools(tools) {
-    if (!Array.isArray(tools) || !tools.length) {
-        return undefined;
-    }
-    return tools.map((tool) => ({
-        type: tool.type,
-        function: {
-            name: tool.function.name,
-            description: tool.function.description,
-            parameters: tool.function.parameters,
-            strict: tool.function.strict
-        }
-    }));
-}
-function normalizeTools(tools) {
-    if (!Array.isArray(tools) || !tools.length) {
-        return [];
-    }
-    const normalized = [];
-    for (const tool of tools) {
-        if (!tool || typeof tool !== 'object')
-            continue;
-        if (tool.type !== 'function')
-            continue;
-        const fn = tool.function;
-        if (!fn || typeof fn !== 'object')
-            continue;
-        const name = fn.name;
-        if (typeof name !== 'string' || !name.trim())
-            continue;
-        const parametersCast = fn.parameters;
-        normalized.push({
-            type: 'function',
-            function: {
-                name: name.trim(),
-                description: typeof fn.description === 'string'
-                    ? fn.description
-                    : undefined,
-                parameters: parametersCast ?? {
-                    type: 'object',
-                    properties: {}
-                },
-                strict: typeof fn.strict === 'boolean'
-                    ? fn.strict
-                    : undefined
-            }
-        });
-    }
-    return normalized;
-}
-function extractHubCapture(request) {
-    const captured = request.metadata?.capturedContext;
-    if (!captured || typeof captured !== 'object') {
-        return undefined;
-    }
-    const state = captured[HUB_CAPTURE_KEY];
-    if (!state || typeof state !== 'object') {
-        return undefined;
-    }
-    return state;
-}
-function safeStringify(value) {
-    if (typeof value === 'string')
-        return value;
-    try {
-        return JSON.stringify(value ?? {});
-    }
-    catch {
-        return String(value);
-    }
-}
-function hubStateContextPopulated(state) {
-    return Boolean(state.context ||
-        (state.missingFields && state.missingFields.length) ||
-        state.providerMetadata ||
-        state.extraFields ||
-        (state.protocolState && Object.keys(state.protocolState).length));
-}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/tool-governance/engine.d.ts

@@ -1,16 +0,0 @@
-import type { JsonObject } from '../types/json.js';
-import type { StandardizedRequest } from '../types/standardized.js';
-import type { GovernedChatCompletionPayload, GovernedStandardizedRequest, ToolGovernanceProtocol, ToolGovernanceRegistry } from './types.js';
-export declare class ToolGovernanceError extends Error {
-    readonly protocol: ToolGovernanceProtocol;
-    readonly direction: 'request' | 'response';
-    readonly field: string;
-    constructor(message: string, protocol: ToolGovernanceProtocol, direction: 'request' | 'response', field: string);
-}
-export declare class ToolGovernanceEngine {
-    private readonly registry;
-    constructor(registry?: ToolGovernanceRegistry);
-    governRequest(request: StandardizedRequest, protocol: ToolGovernanceProtocol): GovernedStandardizedRequest;
-    governResponse(payload: JsonObject, protocol: ToolGovernanceProtocol): GovernedChatCompletionPayload;
-    private resolveRules;
-}