@jsonstudio/llms 0.4.2

package/dist/conversion/hub/standardized-bridge.js

@@ -0,0 +1,248 @@
+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 (chat.metadata?.rawSystem !== undefined) {
+        hubState.rawSystem = chat.metadata.rawSystem;
+    }
+    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) => ({
+        role: message.role,
+        content: message.content ?? '',
+        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
+    };
+    if (hubState?.missingFields) {
+        metadata.missingFields = hubState.missingFields;
+    }
+    if (hubState?.providerMetadata) {
+        metadata.providerMetadata = hubState.providerMetadata;
+    }
+    if (hubState?.extraFields) {
+        metadata.extraFields = hubState.extraFields;
+    }
+    if (hubState?.rawSystem !== undefined) {
+        metadata.rawSystem = hubState.rawSystem;
+    }
+    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: normalizeContent(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 normalizeContent(content) {
+    if (content === undefined || content === null) {
+        return null;
+    }
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        const parts = content
+            .map((part) => {
+            if (part && typeof part === 'object') {
+                if (typeof part.text === 'string') {
+                    return String(part.text);
+                }
+                return JSON.stringify(part);
+            }
+            return '';
+        })
+            .filter(Boolean);
+        return parts.join('\n');
+    }
+    return String(content);
+}
+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;
+    }
+    if (!fn || typeof fn !== 'object') {
+        return null;
+    }
+    const fnName = fn.name;
+    if (typeof fnName !== 'string' || !fnName.trim()) {
+        return null;
+    }
+    const args = fn.arguments;
+    const serializedArgs = typeof args === 'string' ? args : safeStringify(args ?? {});
+    return {
+        id: id.trim(),
+        type: 'function',
+        function: {
+            name: fnName.trim(),
+            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 isJsonObject(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+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.rawSystem !== undefined);
+}

package/dist/conversion/hub/types/chat-envelope.d.ts

@@ -0,0 +1,67 @@
+export type ChatRole = 'system' | 'user' | 'assistant' | 'tool';
+import type { JsonObject, JsonValue } from './json.js';
+export interface ChatMessageContentPart {
+    type: string;
+    text?: string;
+    [key: string]: JsonValue;
+}
+export interface ChatToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+    [key: string]: JsonValue;
+}
+export interface ChatMessage {
+    role: ChatRole;
+    content?: string | ChatMessageContentPart[];
+    tool_calls?: ChatToolCall[];
+    name?: string;
+    [key: string]: JsonValue;
+}
+export interface ChatToolDefinition {
+    type: 'function' | string;
+    function: {
+        name: string;
+        description?: string;
+        parameters?: JsonValue;
+        strict?: boolean;
+    };
+    [key: string]: JsonValue;
+}
+export interface ChatToolOutput {
+    tool_call_id: string;
+    content: string;
+    name?: string;
+    [key: string]: JsonValue;
+}
+export interface MissingField extends JsonObject {
+    path: string;
+    reason: string;
+    originalValue?: JsonValue;
+}
+export interface AdapterContext {
+    requestId: string;
+    entryEndpoint: string;
+    providerProtocol: string;
+    providerId?: string;
+    routeId?: string;
+    profileId?: string;
+    streamingHint?: 'auto' | 'force' | 'disable';
+    originalModelId?: string;
+    clientModelId?: string;
+    [key: string]: JsonValue;
+}
+export interface ChatEnvelope {
+    messages: ChatMessage[];
+    tools?: ChatToolDefinition[];
+    toolOutputs?: ChatToolOutput[];
+    parameters?: JsonObject;
+    metadata: {
+        context: AdapterContext;
+        missingFields?: MissingField[];
+        [key: string]: JsonValue;
+    };
+}

package/dist/conversion/hub/types/chat-envelope.js

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

package/dist/conversion/hub/types/chat-schema.d.ts

@@ -0,0 +1,112 @@
+import type { JsonObject, JsonValue } from './json.js';
+export type ChatHubVersion = 'chat-hub@1';
+export interface ConversationReference {
+    readonly id?: string;
+    readonly parentIds?: readonly string[];
+    readonly metadata?: JsonObject;
+}
+export interface InstructionSegment {
+    readonly id?: string;
+    readonly source: string;
+    readonly content: string;
+    readonly metadata?: JsonObject;
+}
+export interface InstructionsEnvelope {
+    readonly segments: readonly InstructionSegment[];
+}
+export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+interface BaseContentBlock {
+    readonly type: string;
+    readonly metadata?: JsonObject;
+}
+export interface TextContentBlock extends BaseContentBlock {
+    readonly type: 'text';
+    readonly text: string;
+    readonly annotations?: readonly JsonObject[];
+}
+export interface ImageContentBlock extends BaseContentBlock {
+    readonly type: 'image';
+    readonly mimeType?: string;
+    readonly data?: string;
+    readonly uri?: string;
+}
+export interface AudioContentBlock extends BaseContentBlock {
+    readonly type: 'audio';
+    readonly mimeType?: string;
+    readonly data?: string;
+    readonly uri?: string;
+}
+export interface DataContentBlock extends BaseContentBlock {
+    readonly type: 'data';
+    readonly mimeType?: string;
+    readonly value: JsonValue;
+}
+export interface ToolCallContentBlock extends BaseContentBlock {
+    readonly type: 'tool_call';
+    readonly toolCallId: string;
+    readonly name: string;
+    readonly arguments: JsonObject;
+}
+export interface ToolResultContentBlock extends BaseContentBlock {
+    readonly type: 'tool_result';
+    readonly toolCallId: string;
+    readonly output: readonly TextContentBlock[];
+    readonly isError?: boolean;
+}
+export type ChatContentBlock = TextContentBlock | ImageContentBlock | AudioContentBlock | DataContentBlock | ToolCallContentBlock | ToolResultContentBlock;
+export interface ChatMessage {
+    readonly id?: string;
+    readonly role: MessageRole;
+    readonly name?: string;
+    readonly content: readonly ChatContentBlock[];
+    readonly metadata?: JsonObject;
+}
+export interface ChatToolDefinition {
+    readonly id?: string;
+    readonly type: 'function' | string;
+    readonly name: string;
+    readonly description?: string;
+    readonly parameters?: JsonObject;
+    readonly strict?: boolean;
+    readonly metadata?: JsonObject;
+}
+export interface ChatAttachment {
+    readonly id: string;
+    readonly kind: 'file' | 'image' | 'audio';
+    readonly uri?: string;
+    readonly mimeType?: string;
+    readonly metadata?: JsonObject;
+}
+export interface ChatGenerationConfig {
+    readonly temperature?: number;
+    readonly topP?: number;
+    readonly topK?: number;
+    readonly maxOutputTokens?: number;
+    readonly stopSequences?: readonly string[];
+    readonly stream?: boolean;
+    readonly parallelToolCalls?: boolean;
+    readonly responseFormat?: JsonObject;
+    readonly metadata?: JsonObject;
+}
+export interface DetourEntry {
+    readonly path: string;
+    readonly value?: JsonValue;
+    readonly reason: string;
+    readonly stage: string;
+}
+export interface DetourState {
+    readonly inbound: readonly DetourEntry[];
+    readonly outbound: readonly DetourEntry[];
+}
+export interface ChatHubEnvelope {
+    readonly version: ChatHubVersion;
+    readonly conversation?: ConversationReference;
+    readonly instructions?: InstructionsEnvelope;
+    readonly messages: readonly ChatMessage[];
+    readonly tools?: readonly ChatToolDefinition[];
+    readonly config?: ChatGenerationConfig;
+    readonly attachments?: readonly ChatAttachment[];
+    readonly detours?: DetourState;
+    readonly metadata?: JsonObject;
+}
+export {};

package/dist/conversion/hub/types/chat-schema.js

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

package/dist/conversion/hub/types/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class ConversionError extends Error {
+    readonly nodeId?: string;
+    readonly stage?: string;
+    constructor(message: string, nodeId?: string, stage?: string, cause?: Error);
+}

package/dist/conversion/hub/types/errors.js

@@ -0,0 +1,13 @@
+export class ConversionError extends Error {
+    nodeId;
+    stage;
+    constructor(message, nodeId, stage, cause) {
+        super(message);
+        this.name = 'ConversionError';
+        this.nodeId = nodeId;
+        this.stage = stage;
+        if (cause) {
+            this.cause = cause;
+        }
+    }
+}

package/dist/conversion/hub/types/format-envelope.d.ts

@@ -0,0 +1,7 @@
+import type { JsonObject } from './json.js';
+export interface FormatEnvelope<TPayload extends JsonObject = JsonObject> {
+    protocol: string;
+    direction: 'request' | 'response';
+    payload: TPayload;
+    meta?: JsonObject;
+}

package/dist/conversion/hub/types/format-envelope.js

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

package/dist/conversion/hub/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './chat-envelope.js';
+export * from './format-envelope.js';
+export * from './json.js';
+export * from './standardized.js';
+export * from './errors.js';
+export * from './node.js';

package/dist/conversion/hub/types/index.js

@@ -0,0 +1,6 @@
+export * from './chat-envelope.js';
+export * from './format-envelope.js';
+export * from './json.js';
+export * from './standardized.js';
+export * from './errors.js';
+export * from './node.js';

package/dist/conversion/hub/types/json.d.ts

@@ -0,0 +1,9 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | JsonObject;
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export type JsonArray = JsonValue[];
+export declare function isJsonObject(value: JsonValue | null | undefined): value is JsonObject;
+export declare function isJsonArray(value: JsonValue | null | undefined): value is JsonArray;
+export declare function jsonClone<T extends JsonValue>(value: T): T;

package/dist/conversion/hub/types/json.js

@@ -0,0 +1,9 @@
+export function isJsonObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+export function isJsonArray(value) {
+    return Array.isArray(value);
+}
+export function jsonClone(value) {
+    return JSON.parse(JSON.stringify(value));
+}

package/dist/conversion/hub/types/node.d.ts

@@ -0,0 +1,31 @@
+import type { JsonObject } from './json.js';
+export interface HubNodeRequestContext {
+    id: string;
+    endpoint: string;
+    context?: Record<string, unknown>;
+}
+export interface HubNodeContext {
+    request: HubNodeRequestContext;
+}
+export interface HubNodeResult {
+    success: boolean;
+    data?: Record<string, unknown>;
+    error?: {
+        code: string;
+        message: string;
+        details?: JsonObject;
+        cause?: Error;
+    };
+    metadata: {
+        node: string;
+        executionTime: number;
+        startTime: number;
+        endTime: number;
+        dataProcessed?: {
+            messages?: number;
+            tools?: number;
+            tokens?: number;
+            responseSize?: number;
+        };
+    };
+}

package/dist/conversion/hub/types/node.js

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

package/dist/conversion/hub/types/standardized.d.ts

@@ -0,0 +1,94 @@
+import type { JsonObject } from './json.js';
+export type ToolChoice = 'none' | 'auto' | 'required' | {
+    type: 'function';
+    function: {
+        name: string;
+    };
+} | Record<string, unknown>;
+export interface StandardizedTool {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, unknown>;
+            required?: string[];
+            additionalProperties?: boolean;
+        };
+        strict?: boolean;
+    };
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ToolCallResult {
+    tool_call_id: string;
+    status: 'success' | 'error' | 'timeout' | 'pending';
+    result?: JsonObject | JsonObject[] | string | number | boolean | null;
+    error?: string;
+    executionTime?: number;
+}
+export interface StandardizedMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | null;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+    name?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface StandardizedParameters {
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    stop?: string | string[];
+    stream?: boolean;
+    [key: string]: unknown;
+}
+export interface StandardizedMetadata {
+    originalEndpoint: string;
+    capturedContext?: Record<string, unknown>;
+    requestId?: string;
+    stream?: boolean;
+    toolChoice?: ToolChoice;
+    providerKey?: string;
+    providerType?: string;
+    processMode?: 'chat' | 'passthrough';
+    routeHint?: string;
+    [key: string]: unknown;
+}
+export interface StandardizedRequest {
+    model: string;
+    messages: StandardizedMessage[];
+    tools?: StandardizedTool[];
+    parameters: StandardizedParameters;
+    metadata: StandardizedMetadata;
+}
+export interface ProcessedRequest extends StandardizedRequest {
+    processed: {
+        timestamp: number;
+        appliedRules: string[];
+        status: 'success' | 'partial' | 'failed';
+    };
+    processingMetadata: {
+        toolCalls?: ToolCallResult[];
+        streaming?: {
+            enabled: boolean;
+            chunkCount?: number;
+            totalTokens?: number;
+        };
+        context?: {
+            systemPrompt?: string;
+            conversationHistory?: string[];
+            relevantContext?: Record<string, unknown>;
+        };
+        passthrough?: boolean;
+    };
+}

package/dist/conversion/hub/types/standardized.js

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

package/dist/conversion/index.d.ts

@@ -0,0 +1,28 @@
+export * from './types.js';
+export * from './schema-validator.js';
+export * from './codec-registry.js';
+export * from './hub/node-support.js';
+export * from './hub/standardized-bridge.js';
+export * from './hub/registry.js';
+export * from './hub/pipelines/inbound.js';
+export * from './hub/pipelines/outbound.js';
+export * from './hub/response/provider-response.js';
+export * from './hub/pipeline/hub-pipeline.js';
+export * from './hub/format-adapters/index.js';
+export * from './hub/semantic-mappers/index.js';
+export * from './hub/types/index.js';
+export * from './hub/hub-feature.js';
+export { normalizeChatRequest } from './shared/openai-message-normalize.js';
+export { runStandardChatRequestFilters } from './shared/chat-request-filters.js';
+export * from './shared/tooling.js';
+export * from '../guidance/index.js';
+export * from './shared/tool-mapping.js';
+export * from './shared/reasoning-mapping.js';
+export * from './shared/args-mapping.js';
+export * from './shared/text-markup-normalizer.js';
+export * from './shared/tool-canonicalizer.js';
+export * from './shared/tool-governor.js';
+export { governTools } from './shared/tool-governor.js';
+export * from './shared/streaming-text-extractor.js';
+export * from './shared/tool-harvester.js';
+export * from './responses/responses-openai-bridge.js';