@jsonstudio/llms 0.6.802 → 0.6.954

package/dist/conversion/hub/policy/protocol-spec.js

@@ -0,0 +1,105 @@
+const RESPONSES_SPEC = {
+    id: 'openai-responses',
+    providerOutbound: {
+        enforceEnabled: true,
+        forbidWrappers: [
+            {
+                code: 'forbid_wrapper',
+                path: 'parameters',
+                detail: 'Responses provider payload must not contain a top-level parameters wrapper (expects flattened fields).'
+            },
+            {
+                code: 'forbid_wrapper',
+                path: 'request',
+                detail: 'Responses provider payload must not contain a nested request wrapper.'
+            }
+        ],
+        reservedKeyPrefixes: ['__', '_'],
+        flattenWrappers: [
+            {
+                wrapperKey: 'request',
+                onlyIfTargetMissing: true
+            },
+            {
+                wrapperKey: 'parameters',
+                onlyIfTargetMissing: true,
+                aliasKeys: {
+                    max_tokens: 'max_output_tokens'
+                },
+                allowKeys: [
+                    'temperature',
+                    'top_p',
+                    'max_output_tokens',
+                    'seed',
+                    'logit_bias',
+                    'user',
+                    'parallel_tool_calls',
+                    'tool_choice',
+                    'response_format',
+                    'stream',
+                    'stop',
+                    'stop_sequences',
+                    'modalities',
+                    'top_k'
+                ]
+            }
+        ]
+    }
+};
+const DEFAULT_SPEC = {
+    id: 'openai-chat',
+    providerOutbound: {
+        enforceEnabled: false,
+        forbidWrappers: [
+            {
+                code: 'forbid_wrapper',
+                path: 'parameters',
+                detail: 'OpenAI Chat provider payload must not contain a top-level parameters wrapper (expects flattened fields).'
+            },
+            {
+                code: 'forbid_wrapper',
+                path: 'request',
+                detail: 'OpenAI Chat provider payload must not contain a nested request wrapper.'
+            }
+        ],
+        reservedKeyPrefixes: ['__', '_'],
+        flattenWrappers: []
+    }
+};
+export const HUB_PROTOCOL_SPECS = {
+    'openai-chat': DEFAULT_SPEC,
+    'openai-responses': RESPONSES_SPEC,
+    'anthropic-messages': {
+        id: 'anthropic-messages',
+        providerOutbound: {
+            enforceEnabled: false,
+            forbidWrappers: [
+                {
+                    code: 'forbid_wrapper',
+                    path: 'parameters',
+                    detail: 'Anthropic Messages provider payload must not contain a top-level parameters wrapper.'
+                },
+                {
+                    code: 'forbid_wrapper',
+                    path: 'request',
+                    detail: 'Anthropic Messages provider payload must not contain a nested request wrapper.'
+                }
+            ],
+            reservedKeyPrefixes: ['__', '_'],
+            flattenWrappers: []
+        }
+    },
+    'gemini-chat': {
+        id: 'gemini-chat',
+        providerOutbound: {
+            enforceEnabled: false,
+            forbidWrappers: [],
+            reservedKeyPrefixes: ['__', '_'],
+            flattenWrappers: []
+        }
+    }
+};
+export function resolveHubProtocolSpec(protocol) {
+    const normalized = (protocol || '').trim().toLowerCase();
+    return HUB_PROTOCOL_SPECS[normalized] ?? DEFAULT_SPEC;
+}

package/dist/conversion/hub/process/chat-process.d.ts

@@ -0,0 +1,32 @@
+import type { ProcessedRequest, StandardizedRequest } from '../types/standardized.js';
+import type { JsonObject } from '../types/json.js';
+export interface HubChatProcessOptions {
+    request: StandardizedRequest;
+    requestId: string;
+    entryEndpoint: string;
+    rawPayload: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+}
+export interface HubChatProcessResult {
+    processedRequest?: ProcessedRequest;
+    nodeResult: HubProcessNodeResult;
+}
+export interface HubProcessNodeResult {
+    success: boolean;
+    metadata: {
+        node: string;
+        executionTime: number;
+        startTime: number;
+        endTime: number;
+        dataProcessed?: {
+            messages: number;
+            tools: number;
+        };
+    };
+    error?: {
+        code?: string;
+        message: string;
+        details?: JsonObject;
+    };
+}
+export declare function runHubChatProcess(options: HubChatProcessOptions): Promise<HubChatProcessResult>;

package/dist/conversion/hub/registry.d.ts

@@ -0,0 +1,28 @@
+import type { InboundPlan, InboundPassthroughConfig, InboundStage } from './pipelines/inbound.js';
+import type { OutboundPlan, OutboundPassthroughConfig, OutboundStage } from './pipelines/outbound.js';
+import type { FormatAdapter, SemanticMapper } from './format-adapters/index.js';
+interface InboundPlanFactory {
+    protocol: string;
+    stages: InboundStage[];
+    passthrough?: InboundPassthroughConfig;
+    createFormatAdapter?: () => FormatAdapter;
+    createSemanticMapper?: () => SemanticMapper;
+}
+interface OutboundPlanFactory {
+    protocol: string;
+    stages: OutboundStage[];
+    passthrough?: OutboundPassthroughConfig;
+    createFormatAdapter?: () => FormatAdapter;
+    createSemanticMapper?: () => SemanticMapper;
+}
+export interface HubProtocolDefinition {
+    protocol: string;
+    inbound: InboundPlanFactory;
+    outbound: OutboundPlanFactory;
+}
+export declare const HUB_PROTOCOL_REGISTRY: Record<string, HubProtocolDefinition>;
+export declare function createProtocolPlans(protocol: string): {
+    inbound: InboundPlan;
+    outbound: OutboundPlan;
+};
+export {};

package/dist/conversion/hub/response/chat-response-utils.d.ts

@@ -0,0 +1,6 @@
+import type { ProcessedRequest } from '../types/standardized.js';
+interface BuildProcessedRequestOptions {
+    stream?: boolean;
+}
+export declare function buildProcessedRequestFromChatResponse(chatResponse: any, options?: BuildProcessedRequestOptions): ProcessedRequest;
+export {};

package/dist/conversion/hub/response/provider-response.js

@@ -1,4 +1,5 @@
 import { recordStage } from '../pipeline/stages/utils.js';
+import { recordHubPolicyObservation } from '../policy/policy-engine.js';
 import { ChatFormatAdapter } from '../format-adapters/chat-format-adapter.js';
 import { ResponsesFormatAdapter } from '../format-adapters/responses-format-adapter.js';
 import { AnthropicFormatAdapter } from '../format-adapters/anthropic-format-adapter.js';
@@ -141,6 +142,21 @@ export async function convertProviderResponse(options) {
         adapterContext: options.context,
         stageRecorder: options.stageRecorder
     });
+    // Phase 0/1: observe provider inbound payload violations (best-effort; no rewrites here).
+    try {
+        if (formatEnvelope.payload && typeof formatEnvelope.payload === 'object' && !Array.isArray(formatEnvelope.payload)) {
+            recordHubPolicyObservation({
+                phase: 'provider_inbound',
+                providerProtocol: options.providerProtocol,
+                payload: formatEnvelope.payload,
+                stageRecorder: options.stageRecorder,
+                requestId: options.context.requestId
+            });
+        }
+    }
+    catch {
+        // never break response conversion
+    }
     const chatResponse = await runRespInboundStage3SemanticMap({
         adapterContext: options.context,
         formatEnvelope,
@@ -218,6 +234,21 @@ export async function convertProviderResponse(options) {
         stageRecorder: options.stageRecorder
     });
     applyModelOverride(clientPayload, displayModel);
+    // Phase 0/1: observe client outbound payload violations (best-effort; no rewrites here).
+    try {
+        if (clientPayload && typeof clientPayload === 'object' && !Array.isArray(clientPayload)) {
+            recordHubPolicyObservation({
+                phase: 'client_outbound',
+                providerProtocol: clientProtocol,
+                payload: clientPayload,
+                stageRecorder: options.stageRecorder,
+                requestId: options.context.requestId
+            });
+        }
+    }
+    catch {
+        // never break response conversion
+    }
     const outbound = await runRespOutboundStage2SseStream({
         clientPayload,
         clientProtocol,

package/dist/conversion/hub/semantic-mappers/chat-mapper.js

@@ -59,6 +59,25 @@ function normalizeToolContent(content) {
         return String(content ?? '');
     }
 }
+function maybeAugmentRouteCodexApplyPatchPrecheck(content) {
+    if (!content || typeof content !== 'string') {
+        return content;
+    }
+    if (content.includes('[RouteCodex precheck]')) {
+        return content;
+    }
+    const lower = content.toLowerCase();
+    if (!lower.includes('failed to parse function arguments')) {
+        return content;
+    }
+    if (content.includes('missing field `input`')) {
+        return `${content}\n\n[RouteCodex precheck] apply_patch 参数解析失败：缺少字段 "input"。当前 RouteCodex 期望 { input, patch } 形态，并且两个字段都应包含完整统一 diff 文本。`;
+    }
+    if (content.includes('invalid type: map, expected a string')) {
+        return `${content}\n\n[RouteCodex precheck] apply_patch 参数类型错误：检测到 JSON 对象（map），但客户端期望字符串。请先对参数做 JSON.stringify 再写入 arguments，或直接提供 { patch: "<统一 diff>" } 形式。`;
+    }
+    return content;
+}
 export function maybeAugmentApplyPatchErrorContent(content, toolName) {
     if (!content)
         return content;
@@ -175,9 +194,21 @@ function normalizeChatMessages(raw) {
                 return;
             }
             const nameValue = typeof value.name === 'string' && value.name.trim().length ? value.name : undefined;
+            const normalizedToolOutput = normalizeToolContent(value.content ?? value.output);
+            const routeCodexPrechecked = maybeAugmentRouteCodexApplyPatchPrecheck(normalizedToolOutput);
+            if (routeCodexPrechecked !== normalizedToolOutput) {
+                // Keep tool role message content aligned with outbound provider requests (e.g. Chat→Responses),
+                // while avoiding double-injection.
+                if (typeof chatMessage.content === 'string' || chatMessage.content === undefined || chatMessage.content === null) {
+                    chatMessage.content = routeCodexPrechecked;
+                }
+                else if (typeof chatMessage.output === 'string') {
+                    chatMessage.output = routeCodexPrechecked;
+                }
+            }
             const outputEntry = {
                 tool_call_id: toolCallId,
-                content: normalizeToolContent(value.content ?? value.output),
+                content: routeCodexPrechecked,
                 name: nameValue
             };
             outputEntry.content = maybeAugmentApplyPatchErrorContent(outputEntry.content, outputEntry.name);

package/dist/conversion/hub/semantic-mappers/gemini-mapper.d.ts

@@ -0,0 +1,7 @@
+import type { SemanticMapper } from '../format-adapters/index.js';
+import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+export declare class GeminiSemanticMapper implements SemanticMapper {
+    toChat(format: FormatEnvelope, ctx: AdapterContext): Promise<ChatEnvelope>;
+    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
+}

package/dist/conversion/hub/semantic-mappers/gemini-mapper.js

@@ -387,6 +387,8 @@ function buildGeminiRequestFromChat(chat, metadata) {
     const omitFunctionCallPartsForCli = providerIdPrefix === 'gemini-cli';
     const semanticsNode = readGeminiSemantics(chat);
     const systemTextBlocksFromSemantics = readSystemTextBlocksFromSemantics(chat);
+    const bridgeDefs = chat.tools && chat.tools.length ? mapChatToolsToBridge(chat.tools) : undefined;
+    const toolSchemaKeys = bridgeDefs ? buildToolSchemaKeyMap(bridgeDefs) : new Map();
     const sourceMessages = chat.messages;
     // 收集当前 ChatEnvelope 中 assistant/tool_calls 的 id，用于过滤孤立的 tool_result：
     // 只有在本轮对话中存在对应 tool_call 的 tool_result 才允许映射为 Gemini functionResponse。
@@ -449,6 +451,7 @@ function buildGeminiRequestFromChat(chat, metadata) {
             else {
                 argsStruct = fn.arguments ?? {};
             }
+            argsStruct = alignToolCallArgsToSchema({ toolName: name, args: argsStruct, schemaKeys: toolSchemaKeys });
             let argsJson = cloneAsJsonValue(argsStruct);
             // Gemini / Antigravity 期望 functionCall.args 为对象（Struct），
             // 若顶层为数组或原始类型，则包装到 value 字段下，避免产生非法的 list 形状。
@@ -514,7 +517,6 @@ function buildGeminiRequestFromChat(chat, metadata) {
         }
     }
     if (chat.tools && chat.tools.length) {
-        const bridgeDefs = mapChatToolsToBridge(chat.tools);
         const geminiTools = buildGeminiToolsFromBridge(bridgeDefs);
         if (geminiTools) {
             request.tools = geminiTools;
@@ -577,6 +579,99 @@ function buildGeminiRequestFromChat(chat, metadata) {
     const compatRequest = applyClaudeThinkingToolSchemaCompat(request, adapterContext);
     return compatRequest;
 }
+function isPlainRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function buildToolSchemaKeyMap(defs) {
+    const map = new Map();
+    for (const def of defs) {
+        const fnNode = def && typeof def === 'object' && def.function && typeof def.function === 'object'
+            ? def.function
+            : undefined;
+        const name = typeof fnNode?.name === 'string'
+            ? fnNode.name
+            : typeof def?.name === 'string'
+                ? String(def.name)
+                : '';
+        if (!name || !name.trim())
+            continue;
+        const parameters = (fnNode && fnNode.parameters) ??
+            (def.parameters);
+        if (!isPlainRecord(parameters))
+            continue;
+        const props = parameters.properties;
+        if (!isPlainRecord(props))
+            continue;
+        const keys = Object.keys(props).filter((k) => typeof k === 'string' && k.trim().length > 0);
+        if (!keys.length)
+            continue;
+        map.set(name, new Set(keys));
+    }
+    return map;
+}
+function alignToolCallArgsToSchema(options) {
+    const name = typeof options.toolName === 'string' ? options.toolName.trim() : '';
+    if (!name)
+        return options.args;
+    const schema = options.schemaKeys.get(name);
+    if (!schema || schema.size === 0) {
+        return options.args;
+    }
+    if (!isPlainRecord(options.args)) {
+        return options.args;
+    }
+    const lowered = name.toLowerCase();
+    const next = { ...options.args };
+    // Align historical Codex tool args to the *declared schema* for Gemini.
+    // Gemini validates historical functionCall.args against tool declarations, so mismatches like:
+    // - exec_command: { cmd } vs schema { command } (or vice-versa)
+    // - apply_patch: { patch/input } vs schema { instructions } (or vice-versa)
+    // can cause MALFORMED_FUNCTION_CALL and empty responses.
+    if (lowered === 'exec_command') {
+        // Prefer the declared schema key; do not delete keys blindly.
+        if (schema.has('cmd') && !Object.prototype.hasOwnProperty.call(next, 'cmd') && Object.prototype.hasOwnProperty.call(next, 'command')) {
+            next.cmd = next.command;
+        }
+        if (schema.has('command') && !Object.prototype.hasOwnProperty.call(next, 'command') && Object.prototype.hasOwnProperty.call(next, 'cmd')) {
+            next.command = next.cmd;
+        }
+    }
+    else if (lowered === 'write_stdin') {
+        if (schema.has('chars') && !Object.prototype.hasOwnProperty.call(next, 'chars') && Object.prototype.hasOwnProperty.call(next, 'text')) {
+            next.chars = next.text;
+        }
+        if (schema.has('text') && !Object.prototype.hasOwnProperty.call(next, 'text') && Object.prototype.hasOwnProperty.call(next, 'chars')) {
+            next.text = next.chars;
+        }
+    }
+    else if (lowered === 'apply_patch') {
+        if (schema.has('instructions') && !Object.prototype.hasOwnProperty.call(next, 'instructions')) {
+            const patch = typeof next.patch === 'string' ? next.patch : undefined;
+            const input = typeof next.input === 'string' ? next.input : undefined;
+            const candidate = patch && patch.trim().length ? patch : input && input.trim().length ? input : undefined;
+            if (candidate) {
+                next.instructions = candidate;
+            }
+        }
+        if (schema.has('patch') && !Object.prototype.hasOwnProperty.call(next, 'patch')) {
+            const input = typeof next.input === 'string' ? next.input : undefined;
+            if (input && input.trim().length) {
+                next.patch = input;
+            }
+        }
+    }
+    // Prune to schema keys for known Codex tools to reduce strict upstream validation failures.
+    if (lowered === 'exec_command' || lowered === 'write_stdin' || lowered === 'apply_patch') {
+        const pruned = {};
+        for (const key of schema) {
+            if (Object.prototype.hasOwnProperty.call(next, key)) {
+                pruned[key] = next[key];
+            }
+        }
+        return pruned;
+    }
+    return next;
+}
 function buildGenerationConfigFromParameters(parameters) {
     const config = {};
     for (const { source, target } of GENERATION_CONFIG_KEYS) {

package/dist/conversion/hub/semantic-mappers/index.d.ts

@@ -0,0 +1,4 @@
+export { ChatSemanticMapper } from './chat-mapper.js';
+export { AnthropicSemanticMapper } from './anthropic-mapper.js';
+export { ResponsesSemanticMapper } from './responses-mapper.js';
+export { GeminiSemanticMapper } from './gemini-mapper.js';

package/dist/conversion/hub/semantic-mappers/responses-mapper.d.ts

@@ -0,0 +1,21 @@
+import type { SemanticMapper } from '../format-adapters/index.js';
+import type { AdapterContext, ChatEnvelope } from '../types/chat-envelope.js';
+import type { FormatEnvelope } from '../types/format-envelope.js';
+import { type JsonObject, type JsonValue } from '../types/json.js';
+interface ResponsesToolOutputEntry extends JsonObject {
+    tool_call_id?: string;
+    call_id?: string;
+    id?: string;
+    output?: JsonValue;
+    name?: string;
+}
+interface ResponsesPayload extends JsonObject {
+    input?: JsonValue[];
+    tools?: JsonValue[];
+    tool_outputs?: ResponsesToolOutputEntry[];
+}
+export declare class ResponsesSemanticMapper implements SemanticMapper {
+    toChat(format: FormatEnvelope<ResponsesPayload>, ctx: AdapterContext): Promise<ChatEnvelope>;
+    fromChat(chat: ChatEnvelope, ctx: AdapterContext): Promise<FormatEnvelope>;
+}
+export {};

package/dist/conversion/hub/standardized-bridge.d.ts

@@ -0,0 +1,12 @@
+import type { StandardizedRequest } from './types/standardized.js';
+import type { AdapterContext, ChatEnvelope } from './types/chat-envelope.js';
+export interface ChatToStandardizedOptions {
+    adapterContext: AdapterContext;
+    endpoint: string;
+    requestId?: string;
+}
+export interface StandardizedToChatOptions {
+    adapterContext: AdapterContext;
+}
+export declare function chatEnvelopeToStandardized(chat: ChatEnvelope, options: ChatToStandardizedOptions): StandardizedRequest;
+export declare function standardizedToChatEnvelope(request: StandardizedRequest, options: StandardizedToChatOptions): ChatEnvelope;

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/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/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/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/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/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;
+        };
+    };
+}