@jsonstudio/llms 0.4.2

package/dist/conversion/hub/format-adapters/chat-format-adapter.d.ts

@@ -0,0 +1,17 @@
+import type { FormatAdapter } from './index.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject, JsonValue } from '../types/json.js';
+interface ChatFormatPayload extends JsonObject {
+    messages?: JsonValue[];
+    tools?: JsonValue[];
+    tool_outputs?: JsonValue[];
+}
+export declare class ChatFormatAdapter implements FormatAdapter {
+    readonly protocol = "openai-chat";
+    parseRequest(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<ChatFormatPayload>>;
+    buildRequest(format: FormatEnvelope<ChatFormatPayload>, _ctx: AdapterContext): Promise<ChatFormatPayload>;
+    parseResponse(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<ChatFormatPayload>>;
+    buildResponse(format: FormatEnvelope<ChatFormatPayload>, _ctx: AdapterContext): Promise<ChatFormatPayload>;
+}
+export {};

package/dist/conversion/hub/format-adapters/chat-format-adapter.js

@@ -0,0 +1,23 @@
+export class ChatFormatAdapter {
+    protocol = 'openai-chat';
+    async parseRequest(original, _ctx) {
+        return {
+            protocol: this.protocol,
+            direction: 'request',
+            payload: original
+        };
+    }
+    async buildRequest(format, _ctx) {
+        return format.payload;
+    }
+    async parseResponse(original, _ctx) {
+        return {
+            protocol: this.protocol,
+            direction: 'response',
+            payload: original
+        };
+    }
+    async buildResponse(format, _ctx) {
+        return format.payload;
+    }
+}

package/dist/conversion/hub/format-adapters/gemini-format-adapter.d.ts

@@ -0,0 +1,16 @@
+import type { FormatAdapter } from './index.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject } from '../types/json.js';
+interface GeminiFormatPayload extends JsonObject {
+    contents?: JsonObject[];
+    tools?: JsonObject[];
+}
+export declare class GeminiFormatAdapter implements FormatAdapter {
+    readonly protocol = "gemini-chat";
+    parseRequest(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<GeminiFormatPayload>>;
+    buildRequest(format: FormatEnvelope<GeminiFormatPayload>, _ctx: AdapterContext): Promise<GeminiFormatPayload>;
+    parseResponse(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<GeminiFormatPayload>>;
+    buildResponse(format: FormatEnvelope<GeminiFormatPayload>, _ctx: AdapterContext): Promise<GeminiFormatPayload>;
+}
+export {};

package/dist/conversion/hub/format-adapters/gemini-format-adapter.js

@@ -0,0 +1,23 @@
+export class GeminiFormatAdapter {
+    protocol = 'gemini-chat';
+    async parseRequest(original, _ctx) {
+        return {
+            protocol: this.protocol,
+            direction: 'request',
+            payload: original
+        };
+    }
+    async buildRequest(format, _ctx) {
+        return format.payload;
+    }
+    async parseResponse(original, _ctx) {
+        return {
+            protocol: this.protocol,
+            direction: 'response',
+            payload: original
+        };
+    }
+    async buildResponse(format, _ctx) {
+        return format.payload;
+    }
+}

package/dist/conversion/hub/format-adapters/index.d.ts

@@ -0,0 +1,21 @@
+import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject } from '../types/json.js';
+export interface FormatAdapter<TRequestPayload extends JsonObject = JsonObject, TResponsePayload extends JsonObject = JsonObject> {
+    readonly protocol: string;
+    parseRequest(original: TRequestPayload, ctx: AdapterContext): Promise<FormatEnvelope<TRequestPayload>> | FormatEnvelope<TRequestPayload>;
+    buildRequest(format: FormatEnvelope, ctx: AdapterContext): Promise<TRequestPayload> | TRequestPayload;
+    parseResponse(original: TResponsePayload, ctx: AdapterContext): Promise<FormatEnvelope<TResponsePayload>> | FormatEnvelope<TResponsePayload>;
+    buildResponse(format: FormatEnvelope, ctx: AdapterContext): Promise<TResponsePayload> | TResponsePayload;
+}
+export interface StageRecorder {
+    record(stage: string, payload: object): void;
+}
+export interface SemanticMapper {
+    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope> | ChatEnvelope;
+    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope> | FormatEnvelope;
+}
+export { ChatFormatAdapter } from './chat-format-adapter.js';
+export { AnthropicFormatAdapter } from './anthropic-format-adapter.js';
+export { ResponsesFormatAdapter } from './responses-format-adapter.js';
+export { GeminiFormatAdapter } from './gemini-format-adapter.js';

package/dist/conversion/hub/format-adapters/index.js

@@ -0,0 +1,4 @@
+export { ChatFormatAdapter } from './chat-format-adapter.js';
+export { AnthropicFormatAdapter } from './anthropic-format-adapter.js';
+export { ResponsesFormatAdapter } from './responses-format-adapter.js';
+export { GeminiFormatAdapter } from './gemini-format-adapter.js';

package/dist/conversion/hub/format-adapters/responses-format-adapter.d.ts

@@ -0,0 +1,17 @@
+import type { FormatAdapter } from './index.js';
+import type { AdapterContext } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import type { JsonObject, JsonValue } from '../types/json.js';
+interface ResponsesFormatPayload extends JsonObject {
+    input?: JsonValue[];
+    tools?: JsonValue[];
+    tool_outputs?: JsonValue[];
+}
+export declare class ResponsesFormatAdapter implements FormatAdapter {
+    readonly protocol = "openai-responses";
+    parseRequest(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<ResponsesFormatPayload>>;
+    buildRequest(format: FormatEnvelope<ResponsesFormatPayload>, _ctx: AdapterContext): Promise<ResponsesFormatPayload>;
+    parseResponse(original: JsonObject, _ctx: AdapterContext): Promise<FormatEnvelope<ResponsesFormatPayload>>;
+    buildResponse(format: FormatEnvelope<ResponsesFormatPayload>, _ctx: AdapterContext): Promise<ResponsesFormatPayload>;
+}
+export {};

package/dist/conversion/hub/format-adapters/responses-format-adapter.js

@@ -0,0 +1,23 @@
+export class ResponsesFormatAdapter {
+    protocol = 'openai-responses';
+    async parseRequest(original, _ctx) {
+        return {
+            protocol: this.protocol,
+            direction: 'request',
+            payload: original
+        };
+    }
+    async buildRequest(format, _ctx) {
+        return format.payload;
+    }
+    async parseResponse(original, _ctx) {
+        return {
+            protocol: this.protocol,
+            direction: 'response',
+            payload: original
+        };
+    }
+    async buildResponse(format, _ctx) {
+        return format.payload;
+    }
+}

package/dist/conversion/hub/hub-feature.d.ts

@@ -0,0 +1 @@
+export declare function isHubProtocolEnabled(protocol: string): boolean;

package/dist/conversion/hub/hub-feature.js

@@ -0,0 +1,25 @@
+const DISABLE_FLAG = (process.env.ROUTECODEX_HUB_ENABLED || process.env.ROUTECODEX_ENABLE_HUB) ?? '1';
+const PROTOCOL_LIST = process.env.ROUTECODEX_HUB_PROTOCOLS;
+function parseProtocolList(input) {
+    if (!input)
+        return null;
+    const entries = input
+        .split(',')
+        .map((token) => token.trim().toLowerCase())
+        .filter(Boolean);
+    if (!entries.length) {
+        return null;
+    }
+    return new Set(entries);
+}
+const normalizedList = parseProtocolList(PROTOCOL_LIST);
+export function isHubProtocolEnabled(protocol) {
+    if (DISABLE_FLAG.trim() === '0' || DISABLE_FLAG.trim().toLowerCase() === 'false') {
+        return false;
+    }
+    if (!normalizedList) {
+        return true;
+    }
+    const normalizedProtocol = protocol.trim().toLowerCase();
+    return normalizedList.has(normalizedProtocol);
+}

package/dist/conversion/hub/node-support.d.ts

@@ -0,0 +1,19 @@
+import type { StandardizedRequest, ProcessedRequest } from './types/standardized.js';
+import type { HubNodeContext, HubNodeResult } from './types/node.js';
+export interface HubInboundOptions {
+    protocol: string;
+    rawRequest: Record<string, unknown>;
+    nodeContext: HubNodeContext;
+    nodeId: string;
+    inputFormat: string;
+    outputFormat: string;
+    startTime: number;
+}
+export interface HubOutboundOptions {
+    protocol: string;
+    request: StandardizedRequest | ProcessedRequest;
+    nodeContext: HubNodeContext;
+}
+export declare function shouldUseHub(protocol: string): boolean;
+export declare function runHubInboundConversion(options: HubInboundOptions): Promise<HubNodeResult>;
+export declare function runHubOutboundConversion(options: HubOutboundOptions): Promise<Record<string, unknown>>;

package/dist/conversion/hub/node-support.js

@@ -0,0 +1,115 @@
+import { createProtocolPlans } from './registry.js';
+import { runInboundPipeline } from './pipelines/inbound.js';
+import { runOutboundPipeline } from './pipelines/outbound.js';
+import { chatEnvelopeToStandardized, standardizedToChatEnvelope } from './standardized-bridge.js';
+import { createSnapshotRecorder } from './snapshot-recorder.js';
+import { ConversionError } from './types/errors.js';
+import { isHubProtocolEnabled } from './hub-feature.js';
+export function shouldUseHub(protocol) {
+    return isHubProtocolEnabled(protocol);
+}
+export async function runHubInboundConversion(options) {
+    const adapterContext = deriveAdapterContext(options.nodeContext, options.protocol);
+    const rawPayload = ensureJsonObject(options.rawRequest, options.nodeId);
+    const stageRecorder = maybeCreateStageRecorder(adapterContext, options.nodeContext.request.endpoint);
+    const { inbound } = createProtocolPlans(options.protocol);
+    const chatEnvelope = await runInboundPipeline({
+        rawRequest: rawPayload,
+        context: adapterContext,
+        plan: inbound,
+        stageRecorder
+    });
+    const standardized = chatEnvelopeToStandardized(chatEnvelope, {
+        adapterContext,
+        endpoint: options.nodeContext.request.endpoint,
+        requestId: options.nodeContext.request.id
+    });
+    return buildHubNodeResult({
+        nodeId: options.nodeId,
+        startTime: options.startTime,
+        standardized,
+        inputFormat: options.inputFormat,
+        outputFormat: options.outputFormat
+    });
+}
+export async function runHubOutboundConversion(options) {
+    const adapterContext = deriveAdapterContext(options.nodeContext, options.protocol);
+    const providerEndpoint = resolveEndpointForProtocol(adapterContext.providerProtocol);
+    const stageRecorder = maybeCreateStageRecorder(adapterContext, options.nodeContext.request.endpoint, providerEndpoint);
+    const { outbound } = createProtocolPlans(options.protocol);
+    const chatEnvelope = standardizedToChatEnvelope(options.request, { adapterContext });
+    const payload = await runOutboundPipeline({
+        chat: chatEnvelope,
+        context: adapterContext,
+        plan: outbound,
+        stageRecorder
+    });
+    return payload;
+}
+function maybeCreateStageRecorder(adapterContext, defaultEndpoint, override) {
+    const flag = process.env.ROUTECODEX_HUB_SNAPSHOTS;
+    if (flag && flag.trim() === '0') {
+        return undefined;
+    }
+    const endpoint = override || defaultEndpoint || adapterContext.entryEndpoint || '/v1/chat/completions';
+    return createSnapshotRecorder(adapterContext, endpoint);
+}
+function resolveEndpointForProtocol(protocol) {
+    if (!protocol)
+        return undefined;
+    const value = protocol.toLowerCase();
+    if (value === 'openai-responses')
+        return '/v1/responses';
+    if (value === 'openai-chat')
+        return '/v1/chat/completions';
+    if (value === 'anthropic-messages' || value === 'anthropic')
+        return '/v1/messages';
+    if (value === 'gemini' || value === 'google-gemini')
+        return '/v1/responses';
+    return undefined;
+}
+function ensureJsonObject(value, nodeId) {
+    if (!value || typeof value !== 'object') {
+        throw new ConversionError('Hub inbound requires JSON object payload', nodeId);
+    }
+    return value;
+}
+function buildHubNodeResult(options) {
+    return {
+        success: true,
+        data: {
+            standardizedRequest: options.standardized,
+            originalFormat: options.inputFormat,
+            targetFormat: options.outputFormat
+        },
+        metadata: {
+            node: options.nodeId,
+            executionTime: Date.now() - options.startTime,
+            startTime: options.startTime,
+            endTime: Date.now(),
+            dataProcessed: {
+                messages: options.standardized.messages.length,
+                tools: options.standardized.tools?.length ?? 0
+            }
+        }
+    };
+}
+function deriveAdapterContext(context, fallbackProtocol) {
+    const requestContext = (context.request.context ?? {});
+    const metadata = (requestContext.metadata ?? {});
+    const target = metadata.target;
+    const providerProtocol = target?.outboundProfile ||
+        (typeof metadata.providerProtocol === 'string' ? metadata.providerProtocol : undefined) ||
+        fallbackProtocol;
+    const streamingHint = metadata.stream === true ? 'force' : metadata.stream === false ? 'disable' : 'auto';
+    return {
+        requestId: context.request.id,
+        entryEndpoint: (typeof requestContext.entryEndpoint === 'string' ? requestContext.entryEndpoint : context.request.endpoint) ||
+            '/v1/chat/completions',
+        providerProtocol,
+        providerId: (target?.providerKey || metadata.providerKey),
+        routeId: metadata.routeName,
+        profileId: metadata.pipelineId,
+        streamingHint
+    };
+}

package/dist/conversion/hub/pipeline/hub-pipeline.d.ts

@@ -0,0 +1,68 @@
+import { Readable } from 'node:stream';
+import type { HubNodeResult } from '../types/node.js';
+import type { StandardizedRequest, ProcessedRequest } from '../types/standardized.js';
+import type { JsonObject } from '../types/json.js';
+import type { NodeResult as V3NodeResult } from '../../conversion-v3/types/index.js';
+import type { VirtualRouterConfig, RoutingDecision, RoutingDiagnostics, TargetMetadata } from '../../../router/virtual-router/types.js';
+export interface HubPipelineConfig {
+    virtualRouter: VirtualRouterConfig;
+}
+export interface HubPipelineRequestMetadata extends Record<string, unknown> {
+    entryEndpoint?: string;
+    providerProtocol?: string;
+    processMode?: 'chat' | 'passthrough';
+    stage?: 'inbound' | 'outbound';
+    direction?: 'request' | 'response';
+    stream?: boolean;
+    routeHint?: string;
+}
+export interface HubPipelineRequest {
+    id?: string;
+    endpoint: string;
+    payload: Record<string, unknown> | {
+        readable?: Readable;
+    } | Readable;
+    metadata?: HubPipelineRequestMetadata;
+}
+type HubPipelineNodeMetadata = HubNodeResult['metadata'] | V3NodeResult['metadata'];
+export interface HubPipelineNodeResult {
+    id: string;
+    success: boolean;
+    metadata: HubPipelineNodeMetadata;
+    error?: HubNodeResult['error'] | JsonObject;
+}
+export interface HubPipelineResult {
+    requestId: string;
+    providerPayload?: Record<string, unknown>;
+    standardizedRequest?: StandardizedRequest;
+    processedRequest?: ProcessedRequest;
+    routingDecision?: RoutingDecision;
+    routingDiagnostics?: RoutingDiagnostics;
+    target?: TargetMetadata;
+    metadata: Record<string, unknown>;
+    nodeResults: HubPipelineNodeResult[];
+}
+export declare class HubPipeline {
+    private readonly routerEngine;
+    private config;
+    constructor(config: HubPipelineConfig);
+    updateVirtualRouterConfig(nextConfig: VirtualRouterConfig): void;
+    execute(request: HubPipelineRequest): Promise<HubPipelineResult>;
+    private runInboundStage;
+    private runProcessStage;
+    private routeRequest;
+    private applyTargetMetadata;
+    private applyTargetToSubject;
+    private extractModelFromTarget;
+    private runOutboundStage;
+    private normalizeRequest;
+    private createHubNodeContext;
+    private convertHubNodeResult;
+    private convertV3NodeResult;
+    private materializePayload;
+    private unwrapReadable;
+    private convertSsePayload;
+    private resolveSseProtocol;
+    private extractModelHint;
+}
+export {};