aiexecode 1.0.94 → 1.0.96

package/src/LLMClient/client.js

@@ -12,8 +12,12 @@ import { GoogleGenerativeAI } from '@google/generative-ai';
 import { convertResponsesRequestToClaudeFormat, convertClaudeResponseToResponsesFormat } from './converters/responses-to-claude.js';
 import { convertResponsesRequestToGeminiFormat, convertGeminiResponseToResponsesFormat } from './converters/responses-to-gemini.js';
 import { convertResponsesRequestToOllamaFormat, convertOllamaResponseToResponsesFormat } from './converters/responses-to-ollama.js';
+import { convertResponsesRequestToZaiFormat, convertZaiResponseToResponsesFormat } from './converters/responses-to-zai.js';
 import { normalizeInput } from './converters/input-normalizer.js';
 import { normalizeError, createErrorFromResponse } from './errors.js';
+import { createDebugLogger } from '../util/debug_log.js';
+
+const debugLog = createDebugLogger('llm_client.log', 'llm_client');
 
 export class UnifiedLLMClient {
   /**
@@ -41,17 +45,9 @@ export class UnifiedLLMClient {
     // Default to openai if still no provider
     this.provider = this.provider || 'openai';
 
-    // Create log directory if specified and doesn't exist
-    if (this.logDir) {
-      try {
-        if (!fs.existsSync(this.logDir)) {
-          fs.mkdirSync(this.logDir, { recursive: true });
-        }
-      } catch (error) {
-        console.error(`Failed to create log directory: ${error.message}`);
-        this.logDir = null; // Disable logging if directory creation fails
-      }
-    }
+    // 로그 디렉토리는 비동기로 생성 (초기화 시점에서는 동기 연산 사용하지 않음)
+    this._logDirInitialized = false;
+    this._initializeLogDir();
 
     this._initializeClient();
   }
@@ -66,6 +62,8 @@ export class UnifiedLLMClient {
       return 'claude';
     } else if (model.startsWith('gemini-')) {
       return 'gemini';
+    } else if (model.startsWith('glm-')) {
+      return 'zai';
     } else if (model.includes('llama') || model.includes('mistral') || model.includes('codellama')) {
       return 'ollama';
     }
@@ -80,6 +78,21 @@ export class UnifiedLLMClient {
            model === 'o3' || model === 'o3-mini';
   }
 
+  /**
+   * 로그 디렉토리를 비동기로 초기화합니다.
+   */
+  async _initializeLogDir() {
+    if (!this.logDir || this._logDirInitialized) return;
+
+    try {
+      await fs.promises.mkdir(this.logDir, { recursive: true });
+      this._logDirInitialized = true;
+    } catch (error) {
+      console.error(`Failed to create log directory: ${error.message}`);
+      this.logDir = null; // Disable logging if directory creation fails
+    }
+  }
+
   _initializeClient() {
     switch (this.provider) {
       case 'openai':
@@ -90,6 +103,18 @@ export class UnifiedLLMClient {
         this.client = new Anthropic({ apiKey: this.apiKey });
         break;
 
+      case 'zai':
+        // Z.AI uses Anthropic-compatible API with custom baseURL
+        // interleaved-thinking 헤더 추가로 thinking 블록 활성화
+        this.client = new Anthropic({
+          apiKey: this.apiKey,
+          baseURL: this.baseUrl || 'https://api.z.ai/api/anthropic',
+          defaultHeaders: {
+            'anthropic-beta': 'interleaved-thinking-2025-05-14'
+          }
+        });
+        break;
+
       case 'gemini':
         this.client = new GoogleGenerativeAI(this.apiKey);
         break;
@@ -110,9 +135,15 @@ export class UnifiedLLMClient {
    * @param {string} type - 'REQ' or 'RES'
    * @param {string} providerName - Provider name
    */
-  _logPayload(payload, type, providerName) {
+  async _logPayload(payload, type, providerName) {
     if (!this.logDir) return;
 
+    // 로그 디렉토리가 초기화되지 않았으면 먼저 초기화
+    if (!this._logDirInitialized) {
+      await this._initializeLogDir();
+      if (!this.logDir) return; // 초기화 실패 시 리턴
+    }
+
     try {
       const now = new Date();
       const year = now.getFullYear();
@@ -141,6 +172,9 @@ export class UnifiedLLMClient {
    * @returns {Promise<Object>|AsyncGenerator} Responses API format response or stream
    */
   async response(request, options = {}) {
+    const responseStartTime = Date.now();
+    debugLog(`[response] >>>>>>>>>> ENTRY: model=${request.model || this.defaultModel}, input_length=${request.input?.length || 0}`);
+
     // Set default model if not provided
     if (!request.model && this.defaultModel) {
       request.model = this.defaultModel;
@@ -204,22 +238,37 @@ export class UnifiedLLMClient {
     // Check if streaming is requested
     const isStreaming = request.stream === true;
 
+    debugLog(`[response] Provider: ${effectiveProvider}, streaming: ${isStreaming}, prep_time: ${Date.now() - responseStartTime}ms`);
+
+    let result;
     switch (effectiveProvider) {
       case 'openai':
-        return isStreaming ? this._responseOpenAIStream(request, options) : await this._responseOpenAI(request, options);
+        result = isStreaming ? this._responseOpenAIStream(request, options) : await this._responseOpenAI(request, options);
+        break;
 
       case 'claude':
-        return isStreaming ? this._responseClaudeStream(request, options) : await this._responseClaude(request, options);
+        result = isStreaming ? this._responseClaudeStream(request, options) : await this._responseClaude(request, options);
+        break;
+
+      case 'zai':
+        result = isStreaming ? this._responseZaiStream(request, options) : await this._responseZai(request, options);
+        break;
 
       case 'gemini':
-        return isStreaming ? this._responseGeminiStream(request, options) : await this._responseGemini(request, options);
+        result = isStreaming ? this._responseGeminiStream(request, options) : await this._responseGemini(request, options);
+        break;
 
       case 'ollama':
-        return isStreaming ? this._responseOllamaStream(request, options) : await this._responseOllama(request, options);
+        result = isStreaming ? this._responseOllamaStream(request, options) : await this._responseOllama(request, options);
+        break;
 
       default:
         throw new Error(`Unsupported provider: ${this.provider}`);
     }
+
+    const totalTime = Date.now() - responseStartTime;
+    debugLog(`[response] <<<<<<<<<< EXIT: ${totalTime}ms total, provider=${effectiveProvider}`);
+    return result;
   }
 
   async _responseOpenAI(request, options = {}) {
@@ -805,6 +854,333 @@ export class UnifiedLLMClient {
     }
   }
 
+  // ============================================
+  // Z.AI (GLM) Methods
+  // ============================================
+
+  async _responseZai(request, options = {}) {
+    const startTime = Date.now();
+    const timings = {};
+
+    debugLog(`[_responseZai] ========== START ==========`);
+    debugLog(`[_responseZai] Model: ${request.model}, System length: ${request.instructions?.length || 0}`);
+
+    try {
+      // Step 1: Convert request format
+      const convertStart = Date.now();
+      const zaiRequest = convertResponsesRequestToZaiFormat(request);
+      // Always use streaming for Z.AI API calls
+      zaiRequest.stream = true;
+      timings.convert_request = Date.now() - convertStart;
+      debugLog(`[_responseZai] [1] Request converted: ${timings.convert_request}ms, messages: ${zaiRequest.messages?.length}, system: ${zaiRequest.system?.length || 0} chars`);
+
+      // Log raw request payload before API call
+      this._logPayload(zaiRequest, 'REQ-ZAI-RAW', 'zai');
+
+      // Step 2: Prepare stream options
+      const streamOptions = {};
+      if (options.signal) {
+        streamOptions.signal = options.signal;
+      }
+
+      // Step 3: Initiate API stream
+      const streamInitStart = Date.now();
+      debugLog(`[_responseZai] [2] Initiating API stream to Z.AI...`);
+      const stream = await this.client.messages.stream(zaiRequest, streamOptions);
+      timings.stream_init = Date.now() - streamInitStart;
+      debugLog(`[_responseZai] [3] Stream initiated: ${timings.stream_init}ms`);
+
+      // Step 4: Accumulate streaming response
+      let messageId = null;
+      let model = request.model || 'glm-4.7';
+      let stopReason = null;
+      let usage = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0 };
+      const contentBlocks = [];
+      let currentTextBlock = null;
+      let currentToolBlock = null;
+      let currentThinkingBlock = null; // thinking 블록 지원
+
+      let eventCount = 0;
+      let firstEventTime = null;
+      let lastEventTime = null;
+      const streamReadStart = Date.now();
+
+      debugLog(`[_responseZai] [4] Reading stream events...`);
+
+      for await (const event of stream) {
+        eventCount++;
+        const eventTime = Date.now();
+        if (!firstEventTime) {
+          firstEventTime = eventTime;
+          timings.first_event = firstEventTime - streamReadStart;
+          debugLog(`[_responseZai] [4.1] First event received: ${timings.first_event}ms, type: ${event.type}`);
+        }
+        lastEventTime = eventTime;
+
+        if (event.type === 'message_start') {
+          messageId = event.message.id;
+          model = event.message.model;
+          usage.input_tokens = event.message.usage?.input_tokens || 0;
+          usage.cache_read_input_tokens = event.message.usage?.cache_read_input_tokens || 0;
+          debugLog(`[_responseZai] [4.2] message_start: id=${messageId}, input_tokens=${usage.input_tokens}`);
+        } else if (event.type === 'content_block_start') {
+          if (event.content_block?.type === 'text') {
+            currentTextBlock = { type: 'text', text: '' };
+          } else if (event.content_block?.type === 'tool_use') {
+            currentToolBlock = {
+              type: 'tool_use',
+              id: event.content_block.id,
+              name: event.content_block.name,
+              input: {}
+            };
+            debugLog(`[_responseZai] [4.3] tool_use started: ${event.content_block.name}`);
+          } else if (event.content_block?.type === 'thinking') {
+            // Z.AI/GLM thinking 블록 지원
+            currentThinkingBlock = { type: 'thinking', thinking: '' };
+            debugLog(`[_responseZai] [4.3] thinking started`);
+          }
+        } else if (event.type === 'content_block_delta') {
+          if (event.delta?.type === 'text_delta') {
+            if (currentTextBlock) {
+              currentTextBlock.text += event.delta.text;
+            }
+          } else if (event.delta?.type === 'input_json_delta') {
+            if (currentToolBlock) {
+              if (!currentToolBlock._inputJson) {
+                currentToolBlock._inputJson = '';
+              }
+              currentToolBlock._inputJson += event.delta.partial_json;
+            }
+          } else if (event.delta?.type === 'thinking_delta') {
+            // Z.AI/GLM thinking delta 처리
+            if (currentThinkingBlock) {
+              currentThinkingBlock.thinking += event.delta.thinking || '';
+            }
+          }
+        } else if (event.type === 'content_block_stop') {
+          if (currentThinkingBlock) {
+            // thinking 블록은 contentBlocks에 추가하지만 output에는 포함하지 않음
+            contentBlocks.push(currentThinkingBlock);
+            debugLog(`[_responseZai] [4.4] thinking completed: ${currentThinkingBlock.thinking.length} chars`);
+            currentThinkingBlock = null;
+          } else if (currentTextBlock) {
+            contentBlocks.push(currentTextBlock);
+            currentTextBlock = null;
+          } else if (currentToolBlock) {
+            if (currentToolBlock._inputJson) {
+              try {
+                currentToolBlock.input = JSON.parse(currentToolBlock._inputJson);
+              } catch (e) {
+                currentToolBlock.input = {};
+              }
+              delete currentToolBlock._inputJson;
+            }
+            contentBlocks.push(currentToolBlock);
+            debugLog(`[_responseZai] [4.4] tool_use completed: ${currentToolBlock.name}`);
+            currentToolBlock = null;
+          }
+        } else if (event.type === 'message_delta') {
+          stopReason = event.delta?.stop_reason || stopReason;
+          usage.output_tokens = event.usage?.output_tokens || usage.output_tokens;
+        }
+      }
+
+      timings.stream_read = Date.now() - streamReadStart;
+      timings.total_stream = lastEventTime ? lastEventTime - streamReadStart : 0;
+      debugLog(`[_responseZai] [5] Stream complete: ${timings.stream_read}ms, events: ${eventCount}, stop_reason: ${stopReason}`);
+
+      // Step 5: Construct response object
+      const constructStart = Date.now();
+      const zaiResponse = {
+        id: messageId || `msg_${Date.now()}`,
+        type: 'message',
+        role: 'assistant',
+        content: contentBlocks,
+        model: model,
+        stop_reason: stopReason || 'end_turn',
+        usage: usage
+      };
+      timings.construct_response = Date.now() - constructStart;
+
+      // 캐시 토큰 정보 로깅
+      if (usage.cache_read_input_tokens > 0) {
+        debugLog(`[_responseZai] Cache tokens used: ${usage.cache_read_input_tokens} (${Math.round(usage.cache_read_input_tokens / usage.input_tokens * 100)}% of input)`);
+      }
+
+      const elapsedTime = Date.now() - startTime;
+      timings.total = elapsedTime;
+
+      debugLog(`[_responseZai] [6] Response constructed: ${timings.construct_response}ms, content blocks: ${contentBlocks.length}`);
+
+      // Log raw Z.AI API response before conversion (with timing)
+      this._logPayload({
+        ...zaiResponse,
+        _timing: { ...timings, elapsed_ms: elapsedTime, start: startTime, end: Date.now() }
+      }, 'RES-ZAI-RAW', 'zai');
+
+      // Step 6: Convert response format
+      const convertResStart = Date.now();
+      const response = convertZaiResponseToResponsesFormat(zaiResponse, request.model, request);
+      timings.convert_response = Date.now() - convertResStart;
+      debugLog(`[_responseZai] [7] Response converted: ${timings.convert_response}ms`);
+
+      // Log response payload
+      this._logPayload(response, 'RES', 'zai');
+
+      debugLog(`[_responseZai] ========== END: ${elapsedTime}ms total ==========`);
+      debugLog(`[_responseZai] Timing breakdown: convert_req=${timings.convert_request}ms, stream_init=${timings.stream_init}ms, first_event=${timings.first_event}ms, stream_read=${timings.stream_read}ms, convert_res=${timings.convert_response}ms`);
+
+      return response;
+    } catch (error) {
+      const elapsedTime = Date.now() - startTime;
+      debugLog(`[_responseZai] ========== ERROR after ${elapsedTime}ms ==========`);
+      debugLog(`[_responseZai] Error: ${error.name} - ${error.message}`);
+      debugLog(`[_responseZai] Timings so far: ${JSON.stringify(timings)}`);
+
+      // Log error for debugging (similar to Gemini)
+      this._logPayload({
+        error_message: error.message,
+        error_stack: error.stack,
+        error_name: error.name,
+        error_status: error.status,
+        _timing: { ...timings, elapsed_ms: elapsedTime, start: startTime, end: Date.now() },
+        full_error: JSON.parse(JSON.stringify(error, Object.getOwnPropertyNames(error)))
+      }, 'ERROR-ZAI', 'zai');
+      throw normalizeError(error, 'zai');
+    }
+  }
+
+  /**
+   * Z.AI streaming response
+   * @param {Object} request - Responses API format request
+   * @param {Object} options - Additional options
+   * @returns {AsyncGenerator} Responses API format stream
+   */
+  async *_responseZaiStream(request, options = {}) {
+    const chunks = [];
+    const startTime = Date.now();
+    const timings = {};
+
+    debugLog(`[_responseZaiStream] ========== START ==========`);
+    debugLog(`[_responseZaiStream] Model: ${request.model}`);
+
+    try {
+      const convertStart = Date.now();
+      const zaiRequest = convertResponsesRequestToZaiFormat(request);
+      // Always use streaming for Z.AI API calls
+      zaiRequest.stream = true;
+      timings.convert_request = Date.now() - convertStart;
+      debugLog(`[_responseZaiStream] [1] Request converted: ${timings.convert_request}ms`);
+
+      // Log raw request payload before API call
+      this._logPayload(zaiRequest, 'REQ-RAW', 'zai');
+
+      const streamOptions = {};
+      if (options.signal) {
+        streamOptions.signal = options.signal;
+      }
+
+      const streamInitStart = Date.now();
+      debugLog(`[_responseZaiStream] [2] Initiating API stream...`);
+      const stream = await this.client.messages.stream(zaiRequest, streamOptions);
+      timings.stream_init = Date.now() - streamInitStart;
+      debugLog(`[_responseZaiStream] [3] Stream initiated: ${timings.stream_init}ms`);
+
+      const streamId = `resp_${Date.now()}`;
+      const created = Math.floor(Date.now() / 1000);
+      let currentMessageId = `msg_${Date.now()}`;
+
+      let eventCount = 0;
+      let firstEventTime = null;
+      const streamReadStart = Date.now();
+
+      debugLog(`[_responseZaiStream] [4] Reading stream events...`);
+
+      let currentThinkingText = '';
+
+      for await (const event of stream) {
+        eventCount++;
+        if (!firstEventTime) {
+          firstEventTime = Date.now();
+          timings.first_event = firstEventTime - streamReadStart;
+          debugLog(`[_responseZaiStream] [4.1] First event: ${timings.first_event}ms, type: ${event.type}`);
+        }
+
+        // Thinking 블록 처리 (Z.AI/GLM interleaved-thinking)
+        if (event.type === 'content_block_start' && event.content_block?.type === 'thinking') {
+          currentThinkingText = '';
+          debugLog(`[_responseZaiStream] [4.2] Thinking block started`);
+        } else if (event.type === 'content_block_delta' && event.delta?.type === 'thinking_delta') {
+          currentThinkingText += event.delta.thinking || '';
+          // Thinking delta를 스트리밍으로 전송
+          const thinkingChunk = {
+            id: streamId,
+            object: 'response.delta',
+            created_at: created,
+            model: request.model || 'glm-4.7',
+            delta: {
+              type: 'thinking',
+              message_id: currentMessageId,
+              thinking: event.delta.thinking || ''
+            }
+          };
+          chunks.push(thinkingChunk);
+          yield thinkingChunk;
+        } else if (event.type === 'content_block_stop' && currentThinkingText) {
+          debugLog(`[_responseZaiStream] [4.3] Thinking block completed: ${currentThinkingText.length} chars`);
+          currentThinkingText = '';
+        } else if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+          const deltaChunk = {
+            id: streamId,
+            object: 'response.delta',
+            created_at: created,
+            model: request.model || 'glm-4.7',
+            delta: {
+              type: 'output_text',
+              message_id: currentMessageId,
+              text: event.delta.text
+            }
+          };
+          chunks.push(deltaChunk);
+          yield deltaChunk;
+        } else if (event.type === 'message_delta' && event.delta?.stop_reason) {
+          timings.stream_read = Date.now() - streamReadStart;
+          debugLog(`[_responseZaiStream] [5] Stream complete: ${timings.stream_read}ms, events: ${eventCount}`);
+
+          const doneChunk = {
+            id: streamId,
+            object: 'response.done',
+            created_at: created,
+            model: request.model || 'glm-4.7',
+            status: 'completed'
+          };
+          chunks.push(doneChunk);
+          this._logPayload(chunks, 'RES', 'zai');
+
+          const elapsedTime = Date.now() - startTime;
+          debugLog(`[_responseZaiStream] ========== END: ${elapsedTime}ms total ==========`);
+
+          yield doneChunk;
+        }
+      }
+    } catch (error) {
+      const elapsedTime = Date.now() - startTime;
+      debugLog(`[_responseZaiStream] ========== ERROR after ${elapsedTime}ms ==========`);
+      debugLog(`[_responseZaiStream] Error: ${error.name} - ${error.message}`);
+
+      // Log error for debugging
+      this._logPayload({
+        error_message: error.message,
+        error_stack: error.stack,
+        error_name: error.name,
+        error_status: error.status,
+        _timing: { ...timings, elapsed_ms: elapsedTime, start: startTime, end: Date.now() },
+        full_error: JSON.parse(JSON.stringify(error, Object.getOwnPropertyNames(error)))
+      }, 'ERROR-ZAI-STREAM', 'zai');
+      throw normalizeError(error, 'zai');
+    }
+  }
+
   /**
    * Gemini streaming response
    * @param {Object} request - Responses API format request

package/src/LLMClient/converters/responses-to-claude.js

@@ -60,9 +60,14 @@ export function convertResponsesRequestToClaudeFormat(responsesRequest) {
           }
         } else if (item.type === 'function_call') {
           // Function call from output - convert to assistant message with tool_use
+          // Add placeholder text for Claude API compatibility
           messages.push({
             role: 'assistant',
             content: [
+              {
+                type: 'text',
+                text: '(no content)'
+              },
               {
                 type: 'tool_use',
                 id: item.call_id || item.id,
@@ -72,16 +77,27 @@ export function convertResponsesRequestToClaudeFormat(responsesRequest) {
             ]
           });
         } else if (item.type === 'function_call_output') {
-          // Function call output - convert to tool_result
+          // Function call output - convert to tool_result with error handling
+          const toolResult = {
+            type: 'tool_result',
+            tool_use_id: item.call_id,
+            content: typeof item.output === 'string' ? item.output : JSON.stringify(item.output)
+          };
+
+          // Add is_error flag if the output indicates an error
+          if (item.is_error === true) {
+            toolResult.is_error = true;
+          } else if (typeof item.output === 'object' && item.output !== null) {
+            // Check for operation_successful: false pattern
+            if (item.output.operation_successful === false ||
+                item.output.stdout?.operation_successful === false) {
+              toolResult.is_error = true;
+            }
+          }
+
           messages.push({
             role: 'user',
-            content: [
-              {
-                type: 'tool_result',
-                tool_use_id: item.call_id,
-                content: item.output
-              }
-            ]
+            content: [toolResult]
           });
         }
         // Skip other types like 'reasoning'
@@ -98,16 +114,21 @@ export function convertResponsesRequestToClaudeFormat(responsesRequest) {
             : item.content;
           claudeRequest.system = content;
         } else if (item.role === 'tool') {
-          // Tool result
+          // Tool result with error handling
+          const toolResult = {
+            type: 'tool_result',
+            tool_use_id: item.tool_call_id || item.id,
+            content: typeof item.content === 'string' ? item.content : JSON.stringify(item.content)
+          };
+
+          // Add is_error flag if present
+          if (item.is_error === true) {
+            toolResult.is_error = true;
+          }
+
           messages.push({
             role: 'user',
-            content: [
-              {
-                type: 'tool_result',
-                tool_use_id: item.tool_call_id || item.id,
-                content: item.content
-              }
-            ]
+            content: [toolResult]
           });
         } else if (item.role === 'assistant' && Array.isArray(item.content)) {
           // Assistant with output array (might contain function_call items)
@@ -136,6 +157,15 @@ export function convertResponsesRequestToClaudeFormat(responsesRequest) {
             }
           }
 
+          // If we have tool_use blocks but no text, add a placeholder text
+          // Claude API recommends having text content with tool calls
+          if (toolUseBlocks.length > 0 && textBlocks.length === 0) {
+            textBlocks.push({
+              type: 'text',
+              text: '(no content)'
+            });
+          }
+
           // Claude requires text blocks to come before tool_use blocks
           const claudeContent = [...textBlocks, ...toolUseBlocks];
 
@@ -394,18 +424,37 @@ export function convertClaudeResponseToResponsesFormat(claudeResponse, model = '
     });
   }
 
+  // Determine status and incomplete_details based on stop_reason
+  const stopReason = claudeResponse.stop_reason;
+  const isCompleted = stopReason === 'end_turn' || stopReason === 'tool_use';
+  const isMaxTokens = stopReason === 'max_tokens';
+
+  // Build incomplete_details if response was truncated
+  let incompleteDetails = null;
+  if (isMaxTokens) {
+    incompleteDetails = {
+      reason: 'max_output_tokens',
+      message: 'Response was truncated because it reached the maximum output token limit'
+    };
+  } else if (!isCompleted && stopReason) {
+    incompleteDetails = {
+      reason: stopReason,
+      message: `Response stopped with reason: ${stopReason}`
+    };
+  }
+
   // Build Responses API response with ALL required fields
   const responsesResponse = {
     id: `resp_${claudeResponse.id}`,
     object: 'response',
     created_at: Math.floor(Date.now() / 1000),
-    status: claudeResponse.stop_reason === 'end_turn' || claudeResponse.stop_reason === 'tool_use' ? 'completed' : 'incomplete',
+    status: isCompleted ? 'completed' : 'incomplete',
     background: false,
     billing: {
       payer: 'developer'
     },
     error: null,
-    incomplete_details: null,
+    incomplete_details: incompleteDetails,
     instructions: originalRequest.instructions || null,
     max_output_tokens: originalRequest.max_output_tokens || null,
     max_tool_calls: null,