@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/sse/types/anthropic-types.d.ts

@@ -1,11 +1,16 @@
+import type { BaseSseEvent, StreamDirection } from './core-interfaces.js';
+import type { ChatReasoningMode } from './chat-types.js';
 /**
- * Minimal Anthropic SSE/JSON types for v3 SSE converters
- * Only covers text and basic tool_use blocks needed for roundtrip.
+ * Anthropic JSON/SSE 类型定义与转换上下文
  */
 export interface AnthropicContentTextBlock {
     type: 'text';
     text: string;
 }
+export interface AnthropicContentThinkingBlock {
+    type: 'thinking';
+    text: string;
+}
 export interface AnthropicContentToolUseBlock {
     type: 'tool_use';
     id: string;
@@ -18,7 +23,7 @@ export interface AnthropicContentToolResultBlock {
     content: unknown;
     is_error?: boolean;
 }
-export type AnthropicContentBlock = AnthropicContentTextBlock | AnthropicContentToolUseBlock | AnthropicContentToolResultBlock;
+export type AnthropicContentBlock = AnthropicContentTextBlock | AnthropicContentThinkingBlock | AnthropicContentToolUseBlock | AnthropicContentToolResultBlock;
 export interface AnthropicMessageResponse {
     id: string;
     type: 'message';
@@ -31,57 +36,135 @@ export interface AnthropicMessageResponse {
     };
     stop_reason?: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use';
 }
+export interface AnthropicEventStats {
+    totalEvents: number;
+    contentBlocks: number;
+    toolUseBlocks: number;
+    thinkingBlocks: number;
+    textBlocks: number;
+    errors: number;
+    startTime: number;
+    endTime?: number;
+}
+export interface AnthropicJsonToSseContext {
+    requestId: string;
+    model: string;
+    response: AnthropicMessageResponse;
+    options: AnthropicJsonToSseOptions;
+    startTime: number;
+    eventStats: AnthropicEventStats;
+}
+export interface SseToAnthropicJsonContext {
+    requestId: string;
+    model?: string;
+    startTime: number;
+    eventStats: AnthropicEventStats;
+    isCompleted: boolean;
+    startTimestamp?: number;
+    endTimestamp?: number;
+}
+export interface AnthropicJsonToSseOptions {
+    requestId: string;
+    model: string;
+    chunkSize?: number;
+    chunkDelayMs?: number;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export interface SseToAnthropicJsonOptions {
+    requestId: string;
+    model?: string;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export declare const DEFAULT_ANTHROPIC_CONVERSION_CONFIG: {
+    defaultChunkSize: number;
+    defaultDelayMs: number;
+    enableEventValidation: boolean;
+    strictMode: boolean;
+    reasoningMode: ChatReasoningMode;
+    reasoningTextPrefix: string | undefined;
+};
 export type AnthropicSseEventType = 'message_start' | 'content_block_start' | 'content_block_delta' | 'content_block_stop' | 'message_delta' | 'message_stop';
-export interface AnthropicSseEventBase<T extends AnthropicSseEventType = AnthropicSseEventType> {
+export interface AnthropicSseEventBase<T extends AnthropicSseEventType = AnthropicSseEventType> extends BaseSseEvent {
     type: T;
+    event?: T;
+    protocol: 'anthropic-messages';
+    direction: StreamDirection;
+    data: unknown;
 }
 export interface AnthropicSseEventMessageStart extends AnthropicSseEventBase<'message_start'> {
-    message: {
-        id: string;
-        type: 'message';
-        role: 'assistant';
-        model: string;
+    data: {
+        type: 'message_start';
+        message: {
+            id: string;
+            type: 'message';
+            role: 'assistant';
+            model: string;
+        };
     };
 }
 export interface AnthropicSseEventContentBlockStart extends AnthropicSseEventBase<'content_block_start'> {
-    index: number;
-    content_block: {
-        type: 'text';
-        text?: string;
-    } | {
-        type: 'tool_use';
-        id: string;
-        name: string;
-        input?: Record<string, unknown>;
+    data: {
+        type: 'content_block_start';
+        index: number;
+        content_block: {
+            type: 'text';
+            text?: string;
+        } | {
+            type: 'thinking';
+            text?: string;
+        } | {
+            type: 'tool_use';
+            id: string;
+            name: string;
+            input?: Record<string, unknown>;
+        } | {
+            type: 'tool_result';
+            tool_use_id: string;
+            content?: unknown;
+            is_error?: boolean;
+        };
     };
 }
 export interface AnthropicSseEventContentBlockDelta extends AnthropicSseEventBase<'content_block_delta'> {
-    index: number;
-    delta: {
-        type: 'text_delta';
-        text: string;
-    } | {
-        type: 'input_json_delta';
-        partial_json: string;
+    data: {
+        type: 'content_block_delta';
+        index: number;
+        delta: {
+            type: 'text_delta';
+            text: string;
+        } | {
+            type: 'thinking_delta';
+            text: string;
+        } | {
+            type: 'input_json_delta';
+            partial_json: string;
+        } | {
+            type: 'output_json_delta';
+            partial_json: string;
+        };
     };
 }
 export interface AnthropicSseEventContentBlockStop extends AnthropicSseEventBase<'content_block_stop'> {
-    index: number;
+    data: {
+        type: 'content_block_stop';
+        index: number;
+    };
 }
 export interface AnthropicSseEventMessageDelta extends AnthropicSseEventBase<'message_delta'> {
-    delta?: {
-        stop_reason?: AnthropicMessageResponse['stop_reason'];
+    data: {
+        type: 'message_delta';
+        delta?: {
+            stop_reason?: AnthropicMessageResponse['stop_reason'];
+            usage?: AnthropicMessageResponse['usage'];
+        };
     };
 }
 export interface AnthropicSseEventMessageStop extends AnthropicSseEventBase<'message_stop'> {
+    data: {
+        type: 'message_stop';
+    };
 }
 export type AnthropicSseEvent = AnthropicSseEventMessageStart | AnthropicSseEventContentBlockStart | AnthropicSseEventContentBlockDelta | AnthropicSseEventContentBlockStop | AnthropicSseEventMessageDelta | AnthropicSseEventMessageStop;
 export type AnthropicSseEventStream = AsyncIterable<string> | AsyncIterable<Buffer>;
-export interface AnthropicJsonToSseOptions {
-    requestId: string;
-    model: string;
-    chunkSize?: number;
-}
-export interface SseToAnthropicJsonOptions {
-    requestId: string;
-}

package/dist/sse/types/anthropic-types.js

@@ -1,5 +1,8 @@
-/**
- * Minimal Anthropic SSE/JSON types for v3 SSE converters
- * Only covers text and basic tool_use blocks needed for roundtrip.
- */
-export {};
+export const DEFAULT_ANTHROPIC_CONVERSION_CONFIG = {
+    defaultChunkSize: 1024,
+    defaultDelayMs: 0,
+    enableEventValidation: true,
+    strictMode: false,
+    reasoningMode: 'channel',
+    reasoningTextPrefix: undefined
+};

package/dist/sse/types/chat-types.d.ts

@@ -3,6 +3,7 @@
  * 支持OpenAI Chat Completions的JSON↔SSE双向转换
  */
 import { BaseSseEvent, StreamDirection } from './core-interfaces.js';
+type JsonObject = Record<string, unknown>;
 export type ChatSseEventType = 'chat_chunk' | 'chat.done' | 'error' | 'ping';
 export interface ChatSseEvent extends BaseSseEvent {
     /** 事件类型（SSE标准wire格式） */
@@ -46,6 +47,7 @@ export interface ChatChoiceChunk {
 export interface ChatDelta {
     role?: 'system' | 'user' | 'assistant' | 'tool';
     content?: string | null;
+    reasoning?: string;
     function_call?: ChatFunctionCall;
     tool_calls?: ChatToolCallChunk[];
 }
@@ -114,6 +116,8 @@ export interface ChatMessage {
     role: 'system' | 'user' | 'assistant' | 'tool';
     content?: string | null;
     name?: string;
+    reasoning_content?: string;
+    reasoning?: string;
     function_call?: ChatFunctionCall;
     tool_calls?: ChatToolCall[];
     tool_call_id?: string;
@@ -121,7 +125,7 @@ export interface ChatMessage {
 export interface ChatFunction {
     name: string;
     description?: string;
-    parameters?: Record<string, any>;
+    parameters?: Record<string, unknown>;
 }
 export interface ChatTool {
     type: 'function';
@@ -160,8 +164,8 @@ export interface ChatJsonToSseContext {
     currentChunk: Partial<ChatCompletionChunk>;
     eventStats: ChatEventStats;
     contentIndexCounter?: Map<string, number>;
-    currentRequest?: any;
-    currentResponse?: any;
+    currentRequest?: ChatCompletionRequest;
+    currentResponse?: ChatCompletionResponse;
     chatResponse?: ChatCompletionResponse;
 }
 export interface SseToChatJsonContext {
@@ -189,6 +193,7 @@ export interface ChatChoiceBuilder {
 export interface ChatMessageBuilder {
     role?: 'system' | 'user' | 'assistant' | 'tool';
     content?: string;
+    reasoningContent?: string;
     name?: string;
     functionCall?: ChatFunctionCall;
     toolCalls?: ChatToolCall[];
@@ -206,6 +211,7 @@ export interface ChatToolCallBuilder {
     isCompleted: boolean;
     accumulatedArguments: string;
 }
+export type ChatReasoningMode = 'channel' | 'text' | 'drop';
 export interface ChatJsonToSseOptions {
     requestId: string;
     model: string;
@@ -217,6 +223,8 @@ export interface ChatJsonToSseOptions {
     includeLogprobs?: boolean;
     maxTokensPerChunk?: number;
     validationMode?: 'none' | 'basic' | 'strict';
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
     onChunk?: (chunk: ChatCompletionChunk) => void;
     onError?: (error: Error) => void;
     onComplete?: () => void;
@@ -228,6 +236,8 @@ export interface SseToChatJsonOptions {
     validateChunks?: boolean;
     enableSequenceValidation?: boolean;
     accumulateToolCalls?: boolean;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
     onPartialResponse?: (partial: Partial<ChatCompletionResponse>) => void;
     onEvent?: (event: ChatSseEvent) => void;
     onChunk?: (chunk: ChatCompletionChunk) => void;
@@ -257,7 +267,7 @@ export interface ChatConversionError extends Error {
     chunkId?: string;
     choiceIndex?: number;
     toolCallIndex?: number;
-    context?: any;
+    context?: JsonObject;
 }
 export declare const CHAT_CONVERSION_ERROR_CODES: {
     readonly TIMEOUT: "CHAT_TIMEOUT";
@@ -273,8 +283,8 @@ export interface ChatEventValidationRule {
     requiredFields: string[];
     optionalFields: string[];
     dataValidation?: {
-        schema?: any;
-        customValidator?: (data: any) => boolean;
+        schema?: JsonObject;
+        customValidator?: (data: JsonObject) => boolean;
     };
 }
 export interface ChatConversionConfig {
@@ -293,6 +303,8 @@ export interface ChatConversionConfig {
     debugMode: boolean;
     logLevel: 'debug' | 'info' | 'warn' | 'error';
     enableMetrics: boolean;
+    reasoningMode: ChatReasoningMode;
+    reasoningTextPrefix?: string;
 }
 export declare const DEFAULT_CHAT_CONVERSION_CONFIG: ChatConversionConfig;
 export interface ChatSseEventStream extends AsyncIterable<ChatSseEvent> {
@@ -306,3 +318,4 @@ export interface ChatSseEventStream extends AsyncIterable<ChatSseEvent> {
     on(event: 'chunk', handler: (chunk: ChatCompletionChunk) => void): this;
     on(event: 'stats', handler: (stats: ChatEventStats) => void): this;
 }
+export {};

package/dist/sse/types/chat-types.js

@@ -28,5 +28,6 @@ export const DEFAULT_CHAT_CONVERSION_CONFIG = {
     eventBufferSize: 1000,
     debugMode: false,
     logLevel: 'info',
-    enableMetrics: true
+    enableMetrics: true,
+    reasoningMode: 'channel'
 };

package/dist/sse/types/conversion-context.d.ts

@@ -2,6 +2,7 @@
  * 转换上下文类型定义
  * 定义JSON<>SSE双向转换过程中的上下文信息
  */
+import type { JsonObject, JsonValue } from './core-interfaces.js';
 import type { SseEvent, SseEventStats, SseEventType } from './sse-events.js';
 export interface BaseConversionContext {
     requestId: string;
@@ -36,6 +37,7 @@ export interface SseToJsonContext extends BaseConversionContext {
     isResponseCreated: boolean;
     isInProgress: boolean;
 }
+type ConversionContextUnion = JsonToSseContext | SseToJsonContext;
 export interface JsonToSseOptions {
     requestId: string;
     model: string;
@@ -104,12 +106,13 @@ export interface OutputItemBuilder {
     hasContentPartAdded: boolean;
     isTextInProgress: boolean;
 }
+type LoggerMetadata = Record<string, unknown>;
 export interface ConversionLogger {
-    debug(message: string, meta?: any): void;
-    info(message: string, meta?: any): void;
-    warn(message: string, meta?: any): void;
-    error(message: string, error?: Error, meta?: any): void;
-    event(eventType: string, data?: any): void;
+    debug(message: string, meta?: LoggerMetadata): void;
+    info(message: string, meta?: LoggerMetadata): void;
+    warn(message: string, meta?: LoggerMetadata): void;
+    error(message: string, error?: Error, meta?: LoggerMetadata): void;
+    event(eventType: string, data?: LoggerMetadata): void;
     metric(name: string, value: number, tags?: Record<string, string>): void;
 }
 export interface ConversionError extends Error {
@@ -117,7 +120,7 @@ export interface ConversionError extends Error {
     requestId: string;
     eventType?: string;
     sequenceNumber?: number;
-    context?: any;
+    context?: JsonObject;
 }
 export interface StreamState {
     isStarted: boolean;
@@ -156,20 +159,20 @@ export interface ConversionConfig {
 export declare const DEFAULT_CONVERSION_CONFIG: ConversionConfig;
 export interface EventHandler {
     canHandle(eventType: SseEventType): boolean;
-    handle(event: SseEvent, context: any): Promise<void>;
+    handle(event: SseEvent, context: ConversionContextUnion): Promise<void>;
 }
 export interface ConversionMiddleware {
     name: string;
-    beforeConversion?: (context: any) => Promise<void>;
-    afterConversion?: (context: any, result: any) => Promise<void>;
-    onError?: (context: any, error: Error) => Promise<void>;
+    beforeConversion?: (context: ConversionContextUnion) => Promise<void>;
+    afterConversion?: (context: ConversionContextUnion, result: unknown) => Promise<void>;
+    onError?: (context: ConversionContextUnion, error: Error) => Promise<void>;
 }
 interface OutputItem {
     id: string;
     type: 'reasoning' | 'message' | 'function_call' | 'system_message';
     status?: 'in_progress' | 'completed';
     content?: ContentPart[];
-    summary?: any[];
+    summary?: JsonValue[];
     role?: string;
     arguments?: string;
     call_id?: string;

package/dist/sse/types/core-interfaces.d.ts

@@ -2,13 +2,17 @@
  * 核心接口定义
  * 统一的SSE事件最小接口，供writer.ts等共享模块使用
  */
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export type JsonValue = string | number | boolean | null | JsonObject | JsonValue[];
 export interface BaseSseEvent {
     /** 事件类型 */
     type: string;
     /** 事件时间戳 */
     timestamp: number;
     /** 事件数据 */
-    data: any;
+    data: unknown;
     /** 序列号（可选） */
     sequenceNumber?: number;
     /** 协议标识 */
@@ -16,7 +20,7 @@ export interface BaseSseEvent {
     /** 方向标识 */
     direction?: StreamDirection;
 }
-export type StreamProtocol = 'chat' | 'responses';
+export type StreamProtocol = 'chat' | 'responses' | 'anthropic-messages' | 'gemini-chat';
 export type StreamDirection = 'json_to_sse' | 'sse_to_json';
 export type SseProtocol = StreamProtocol;
 export type SseDirection = StreamDirection;
@@ -56,7 +60,7 @@ export interface BaseConversionContext {
     /** 模型名称 */
     model: string;
     /** 转换选项 */
-    options: any;
+    options: JsonObject;
     /** 开始时间 */
     startTime: number;
 }

package/dist/sse/types/gemini-types.d.ts

@@ -0,0 +1,116 @@
+import type { BaseSseEvent, StreamDirection } from './core-interfaces.js';
+import type { ChatReasoningMode } from './chat-types.js';
+export interface GeminiContentTextPart {
+    text: string;
+}
+export interface GeminiContentFunctionCallPart {
+    functionCall: {
+        name: string;
+        args?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+}
+export interface GeminiContentFunctionResponsePart {
+    functionResponse: {
+        name?: string;
+        response?: unknown;
+        [key: string]: unknown;
+    };
+}
+export interface GeminiContentInlineDataPart {
+    inlineData: {
+        mimeType: string;
+        data: string;
+    };
+}
+export type GeminiContentPart = GeminiContentTextPart | GeminiContentFunctionCallPart | GeminiContentFunctionResponsePart | GeminiContentInlineDataPart | Record<string, unknown>;
+export interface GeminiCandidate {
+    content?: {
+        role?: string;
+        parts?: GeminiContentPart[];
+    };
+    finishReason?: string;
+    safetyRatings?: unknown[];
+}
+export interface GeminiUsageMetadata {
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    totalTokenCount?: number;
+}
+export interface GeminiResponse {
+    candidates?: GeminiCandidate[];
+    promptFeedback?: Record<string, unknown>;
+    usageMetadata?: GeminiUsageMetadata;
+    modelVersion?: string;
+}
+export interface GeminiEventStats {
+    totalEvents: number;
+    chunkEvents: number;
+    doneEvents: number;
+    errors: number;
+    startTime: number;
+    endTime?: number;
+}
+export interface GeminiJsonToSseOptions {
+    requestId: string;
+    model?: string;
+    chunkDelayMs?: number;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export interface GeminiJsonToSseContext {
+    requestId: string;
+    model?: string;
+    response: GeminiResponse;
+    options: GeminiJsonToSseOptions;
+    startTime: number;
+    eventStats: GeminiEventStats;
+}
+export interface SseToGeminiJsonOptions {
+    requestId: string;
+    model?: string;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export interface SseToGeminiJsonContext {
+    requestId: string;
+    model?: string;
+    options: {
+        reasoningMode?: ChatReasoningMode;
+        reasoningTextPrefix?: string;
+    };
+    startTime: number;
+    eventStats: GeminiEventStats;
+    isCompleted: boolean;
+}
+export type GeminiSseEventType = 'gemini.data' | 'gemini.done' | 'gemini.error';
+export interface GeminiSseEvent extends BaseSseEvent {
+    type: GeminiSseEventType;
+    event?: GeminiSseEventType;
+    protocol: 'gemini-chat';
+    direction: StreamDirection;
+    data: unknown;
+}
+export interface GeminiChunkEventData {
+    kind: 'part';
+    candidateIndex: number;
+    partIndex: number;
+    role: string;
+    part: GeminiContentPart;
+}
+export interface GeminiDoneEventData {
+    kind: 'done';
+    usageMetadata?: GeminiUsageMetadata;
+    promptFeedback?: Record<string, unknown>;
+    modelVersion?: string;
+    candidates?: Array<{
+        index: number;
+        finishReason?: string;
+        safetyRatings?: unknown[];
+    }>;
+}
+export declare const DEFAULT_GEMINI_CONVERSION_CONFIG: {
+    chunkDelayMs: number;
+    reasoningMode: ChatReasoningMode;
+    reasoningTextPrefix: string | undefined;
+};

package/dist/sse/types/gemini-types.js

@@ -0,0 +1,5 @@
+export const DEFAULT_GEMINI_CONVERSION_CONFIG = {
+    chunkDelayMs: 0,
+    reasoningMode: 'channel',
+    reasoningTextPrefix: undefined
+};

package/dist/sse/types/index.d.ts

@@ -3,11 +3,14 @@
  * 支持Responses和Chat协议的JSON↔SSE双向转换
  */
 export type { BaseSseEvent, BaseSseEventStream, StreamProtocol, StreamDirection, SseProtocol, SseDirection } from './core-interfaces.js';
-export type { ChatSseEvent, ChatSseEventType, ChatSseEventStream, ChatEventStats, ChatJsonToSseContext, SseToChatJsonContext, ChatCompletionRequest, ChatCompletionResponse, ChatCompletionChunk, ChatJsonToSseOptions, SseToChatJsonOptions, ChatConversionError, ChatToolCall, ChatChoiceBuilder, ChatMessageBuilder, ChatToolCallBuilder } from './chat-types.js';
+export type { ChatSseEvent, ChatSseEventType, ChatSseEventStream, ChatEventStats, ChatJsonToSseContext, SseToChatJsonContext, ChatCompletionRequest, ChatCompletionResponse, ChatCompletionChunk, ChatMessage, ChatJsonToSseOptions, SseToChatJsonOptions, ChatConversionError, ChatToolCall, ChatToolCallChunk, ChatChoiceBuilder, ChatMessageBuilder, ChatToolCallBuilder, ChatReasoningMode } from './chat-types.js';
 export type { ChatJsonToSseConverter } from '../json-to-sse/chat-json-to-sse-converter.js';
 export type { ResponsesJsonToSseConverter } from '../json-to-sse/responses-json-to-sse-converter.js';
 export type { ResponsesSseEvent, ResponsesSseEventType, ResponsesSseEventStream, ResponsesEventStats, ResponsesJsonToSseContext, SseToResponsesJsonContext, ResponsesJsonToSseOptions, SseToResponsesJsonOptions, ResponsesResponse, ResponsesRequest, ResponsesOutputItem, ResponsesMessageItem, ResponsesFunctionCallItem, ResponsesFunctionCallOutputItem, ResponsesReasoningItem, ResponsesContent, ResponsesTool, ResponsesToolCall, ResponsesUsage, OutputItemBuilder, OutputItemProcessingState } from './responses-types.js';
-export type { AnthropicMessageResponse } from './anthropic-types.js';
+export type { AnthropicMessageResponse, AnthropicContentBlock, AnthropicJsonToSseContext, AnthropicJsonToSseOptions, AnthropicEventStats, SseToAnthropicJsonContext, SseToAnthropicJsonOptions, AnthropicSseEvent, AnthropicSseEventStream } from './anthropic-types.js';
+export { DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from './anthropic-types.js';
+export type { GeminiResponse, GeminiCandidate, GeminiContentPart, GeminiUsageMetadata, GeminiJsonToSseOptions, GeminiJsonToSseContext, SseToGeminiJsonOptions, SseToGeminiJsonContext, GeminiEventStats, GeminiSseEvent, GeminiChunkEventData, GeminiDoneEventData } from './gemini-types.js';
+export { DEFAULT_GEMINI_CONVERSION_CONFIG } from './gemini-types.js';
 export type { ChatSseToJsonConverter } from '../sse-to-json/chat-sse-to-json-converter.js';
 export type { ResponsesSseToJsonConverterRefactored as ResponsesSseToJsonConverter } from '../sse-to-json/responses-sse-to-json-converter.js';
 export { DEFAULT_CHAT_CONVERSION_CONFIG, CHAT_CONVERSION_ERROR_CODES } from './chat-types.js';

package/dist/sse/types/index.js

@@ -2,6 +2,8 @@
  * SSE双向转换模块类型定义统一导出
  * 支持Responses和Chat协议的JSON↔SSE双向转换
  */
+export { DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from './anthropic-types.js';
+export { DEFAULT_GEMINI_CONVERSION_CONFIG } from './gemini-types.js';
 // 常量
 export { DEFAULT_CHAT_CONVERSION_CONFIG, CHAT_CONVERSION_ERROR_CODES } from './chat-types.js';
 export { DEFAULT_RESPONSES_CONVERSION_CONFIG, RESPONSES_CONVERSION_ERROR_CODES } from './responses-types.js';