aiexecode 1.0.94 → 1.0.96

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

@@ -0,0 +1,608 @@
+/**
+ * Convert Responses API format to Z.AI (GLM) format
+ * Z.AI uses Anthropic Messages API compatible interface
+ * Base URL: https://api.z.ai/api/anthropic
+ */
+
+import { getMaxTokens } from '../../config/ai_models.js';
+import { createDebugLogger } from '../../util/debug_log.js';
+
+const debugLog = createDebugLogger('zai_converter.log', 'zai_converter');
+
+/**
+ * Convert Responses API request to Z.AI format
+ * @param {Object} responsesRequest - Responses API format request
+ * @returns {Object} Z.AI (Anthropic-compatible) format request
+ */
+export function convertResponsesRequestToZaiFormat(responsesRequest) {
+  const startTime = Date.now();
+  debugLog(`[convertRequest] START: model=${responsesRequest.model}, input_items=${responsesRequest.input?.length || 0}`);
+
+  const model = responsesRequest.model;
+  if (!model) {
+    throw new Error('Model name is required');
+  }
+
+  const defaultMaxTokens = getMaxTokens(model);
+
+  const zaiRequest = {
+    model: model,
+    max_tokens: responsesRequest.max_output_tokens || defaultMaxTokens
+  };
+
+  // Convert input to messages
+  const messages = [];
+
+  if (typeof responsesRequest.input === 'string') {
+    messages.push({
+      role: 'user',
+      content: responsesRequest.input
+    });
+  } else if (Array.isArray(responsesRequest.input)) {
+    for (const item of responsesRequest.input) {
+      // Handle output items (no role, has type)
+      if (!item.role && item.type) {
+        if (item.type === 'message') {
+          const textBlocks = [];
+          if (item.content && Array.isArray(item.content)) {
+            for (const contentBlock of item.content) {
+              if (contentBlock.type === 'output_text' && contentBlock.text) {
+                textBlocks.push({
+                  type: 'text',
+                  text: contentBlock.text
+                });
+              }
+            }
+          }
+          if (textBlocks.length > 0) {
+            messages.push({
+              role: 'assistant',
+              content: textBlocks
+            });
+          }
+          // Note: If message has no text content, it will be handled by the
+          // subsequent function_call items which create their own assistant messages
+        } else if (item.type === 'function_call') {
+          // Add placeholder text with tool_use for Z.AI/Anthropic API compatibility
+          messages.push({
+            role: 'assistant',
+            content: [
+              {
+                type: 'text',
+                text: '(no content)'
+              },
+              {
+                type: 'tool_use',
+                id: item.call_id || item.id,
+                name: item.name,
+                input: JSON.parse(item.arguments || '{}')
+              }
+            ]
+          });
+        } else if (item.type === 'function_call_output') {
+          // Build tool_result object with proper 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
+          // Check for common error patterns in the output
+          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: [toolResult]
+          });
+        }
+        continue;
+      }
+
+      if (item.role && item.content) {
+        if (item.role === 'system') {
+          // Z.AI는 Anthropic API와 호환 - system을 배열로 지원 (캐시 제어 포함)
+          if (Array.isArray(item.content)) {
+            // 배열인 경우: 캐시 제어가 있는 블록들을 처리
+            const systemBlocks = item.content.map(c => {
+              const block = {
+                type: 'text',
+                text: c.type === 'input_text' || c.type === 'text' ? c.text : (typeof c === 'string' ? c : '')
+              };
+              // cache_control이 있으면 유지 (Claude Code 스타일)
+              if (c.cache_control) {
+                block.cache_control = c.cache_control;
+              }
+              return block;
+            }).filter(b => b.text);
+
+            // 캐시 제어가 있는 블록이 있으면 배열로, 없으면 단순 문자열로
+            const hasCacheControl = systemBlocks.some(b => b.cache_control);
+            if (hasCacheControl) {
+              zaiRequest.system = systemBlocks;
+              debugLog(`[convertRequest] System message with cache_control: ${systemBlocks.length} blocks`);
+            } else {
+              zaiRequest.system = systemBlocks.map(b => b.text).join('\n');
+            }
+          } else {
+            zaiRequest.system = item.content;
+          }
+        } else if (item.role === 'tool') {
+          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: [toolResult]
+          });
+        } else if (item.role === 'assistant' && Array.isArray(item.content)) {
+          const textBlocks = [];
+          const toolUseBlocks = [];
+
+          for (const outputItem of item.content) {
+            if (outputItem.type === 'message' && outputItem.content) {
+              for (const contentBlock of outputItem.content) {
+                if (contentBlock.type === 'output_text' && contentBlock.text) {
+                  textBlocks.push({
+                    type: 'text',
+                    text: contentBlock.text
+                  });
+                }
+              }
+            } else if (outputItem.type === 'function_call') {
+              toolUseBlocks.push({
+                type: 'tool_use',
+                id: outputItem.call_id || outputItem.id,
+                name: outputItem.name,
+                input: JSON.parse(outputItem.arguments || '{}')
+              });
+            }
+          }
+
+          // If we have tool_use blocks but no text, add a placeholder text
+          // Z.AI/Anthropic API recommends having text content with tool calls
+          if (toolUseBlocks.length > 0 && textBlocks.length === 0) {
+            textBlocks.push({
+              type: 'text',
+              text: '(no content)'
+            });
+          }
+
+          const zaiContent = [...textBlocks, ...toolUseBlocks];
+
+          if (zaiContent.length > 0) {
+            messages.push({
+              role: 'assistant',
+              content: zaiContent
+            });
+          }
+        } else {
+          // 일반 user/assistant 메시지 처리
+          if (Array.isArray(item.content)) {
+            // 캐시 제어가 있는 content 블록 확인
+            const hasCacheControl = item.content.some(c => c.cache_control);
+
+            if (hasCacheControl) {
+              // 캐시 제어가 있는 경우: 블록 배열로 유지
+              const contentBlocks = item.content.map(c => {
+                const block = {
+                  type: 'text',
+                  text: c.type === 'input_text' || c.type === 'text' ? c.text : (typeof c === 'string' ? c : '')
+                };
+                if (c.cache_control) {
+                  block.cache_control = c.cache_control;
+                }
+                return block;
+              }).filter(b => b.text);
+
+              messages.push({
+                role: item.role === 'assistant' ? 'assistant' : 'user',
+                content: contentBlocks
+              });
+              debugLog(`[convertRequest] User message with cache_control: ${contentBlocks.length} blocks`);
+            } else {
+              // 캐시 제어 없음: 단순 텍스트로 합침
+              const content = item.content.map(c => c.type === 'input_text' || c.type === 'text' ? c.text : c).filter(Boolean).join('\n');
+              messages.push({
+                role: item.role === 'assistant' ? 'assistant' : 'user',
+                content: content
+              });
+            }
+          } else {
+            messages.push({
+              role: item.role === 'assistant' ? 'assistant' : 'user',
+              content: item.content
+            });
+          }
+        }
+      }
+    }
+  }
+
+  // Merge consecutive messages with the same role
+  const mergedMessages = [];
+  for (let i = 0; i < messages.length; i++) {
+    const currentMsg = messages[i];
+
+    if (i < messages.length - 1 && messages[i + 1].role === currentMsg.role) {
+      const mergedContent = Array.isArray(currentMsg.content) ? [...currentMsg.content] : [currentMsg.content];
+
+      while (i < messages.length - 1 && messages[i + 1].role === currentMsg.role) {
+        i++;
+        const nextContent = messages[i].content;
+        if (Array.isArray(nextContent)) {
+          mergedContent.push(...nextContent);
+        } else {
+          mergedContent.push(nextContent);
+        }
+      }
+
+      mergedMessages.push({
+        role: currentMsg.role,
+        content: mergedContent
+      });
+    } else {
+      mergedMessages.push(currentMsg);
+    }
+  }
+
+  // Normalize content format for Z.AI/Anthropic API
+  // Content arrays must contain objects with {type: "text", text: "..."} format
+  for (const msg of mergedMessages) {
+    if (Array.isArray(msg.content)) {
+      msg.content = msg.content.map(item => {
+        // If item is already in correct format, keep it
+        if (typeof item === 'object' && item !== null && item.type) {
+          return item;
+        }
+        // Convert plain string to text block format
+        if (typeof item === 'string') {
+          return { type: 'text', text: item };
+        }
+        // Fallback: convert to string
+        return { type: 'text', text: String(item) };
+      });
+    }
+  }
+
+  zaiRequest.messages = mergedMessages;
+
+  // Handle instructions (system message)
+  if (responsesRequest.instructions) {
+    zaiRequest.system = responsesRequest.instructions;
+  }
+
+  // Convert tools from Responses API format to Z.AI (Anthropic) format
+  if (responsesRequest.tools && Array.isArray(responsesRequest.tools)) {
+    zaiRequest.tools = responsesRequest.tools.map(tool => {
+      if (tool.type === 'function') {
+        if (tool.function) {
+          return {
+            name: tool.function.name,
+            description: tool.function.description || `Function: ${tool.function.name}`,
+            input_schema: tool.function.parameters || {
+              type: 'object',
+              properties: {}
+            }
+          };
+        } else {
+          return {
+            name: tool.name,
+            description: tool.description || `Function: ${tool.name}`,
+            input_schema: tool.parameters || {
+              type: 'object',
+              properties: {}
+            }
+          };
+        }
+      } else if (tool.type === 'custom') {
+        return {
+          name: tool.name,
+          description: tool.description || `Tool: ${tool.name}`,
+          input_schema: tool.input_schema || {
+            type: 'object',
+            properties: {}
+          }
+        };
+      }
+      return {
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.input_schema
+      };
+    });
+  }
+
+  // Temperature - always set to 0 for consistent results
+  zaiRequest.temperature = 0;
+
+  // Stream - Z.AI requires this field (will be overridden by SDK if using stream method)
+  zaiRequest.stream = responsesRequest.stream || false;
+
+  // Tool choice
+  if (responsesRequest.tool_choice !== undefined) {
+    if (typeof responsesRequest.tool_choice === 'string') {
+      if (responsesRequest.tool_choice === 'auto') {
+        zaiRequest.tool_choice = { type: 'auto' };
+      } else if (responsesRequest.tool_choice === 'required') {
+        zaiRequest.tool_choice = { type: 'any' };
+      }
+    } else if (responsesRequest.tool_choice?.type === 'function' || responsesRequest.tool_choice?.type === 'custom') {
+      const toolName = responsesRequest.tool_choice.function?.name || responsesRequest.tool_choice.name;
+      zaiRequest.tool_choice = {
+        type: 'tool',
+        name: toolName
+      };
+    }
+  }
+
+  // Metadata
+  if (responsesRequest.metadata) {
+    zaiRequest.metadata = responsesRequest.metadata;
+  }
+
+  // Assistant Prefill 지원
+  // Z.AI/GLM에서 JSON 응답을 유도하기 위해 assistant 메시지를 미리 추가
+  if (responsesRequest.assistant_prefill) {
+    zaiRequest.messages.push({
+      role: 'assistant',
+      content: [
+        {
+          type: 'text',
+          text: responsesRequest.assistant_prefill
+        }
+      ]
+    });
+    debugLog(`[convertRequest] Assistant prefill added: ${responsesRequest.assistant_prefill}`);
+  }
+
+  // Handle json_schema format by converting to tool use
+  if (responsesRequest.text?.format?.type === 'json_schema') {
+    const schemaName = responsesRequest.text.format.name || 'output';
+    const schema = responsesRequest.text.format.schema;
+
+    const syntheticTool = {
+      name: schemaName,
+      description: `Generate structured output matching the ${schemaName} schema`,
+      input_schema: schema
+    };
+
+    zaiRequest.tools = [syntheticTool];
+
+    zaiRequest.tool_choice = {
+      type: 'tool',
+      name: schemaName
+    };
+
+    if (zaiRequest.messages.length > 0 && zaiRequest.messages[zaiRequest.messages.length - 1].role === 'assistant') {
+      zaiRequest.messages.push({
+        role: 'user',
+        content: [{ type: 'text', text: 'Please provide the structured output.' }]
+      });
+    }
+  }
+
+  const elapsed = Date.now() - startTime;
+  debugLog(`[convertRequest] END: ${elapsed}ms, messages=${zaiRequest.messages?.length}, system_len=${zaiRequest.system?.length || 0}, tools=${zaiRequest.tools?.length || 0}`);
+
+  return zaiRequest;
+}
+
+/**
+ * Convert Z.AI response to Responses API format
+ * @param {Object} zaiResponse - Z.AI (Anthropic-compatible) format response
+ * @param {string} model - Model name
+ * @param {Object} originalRequest - Original request for context
+ * @returns {Object} Responses API format response
+ */
+export function convertZaiResponseToResponsesFormat(zaiResponse, model = 'glm-4.7', originalRequest = {}) {
+  const startTime = Date.now();
+  debugLog(`[convertResponse] START: id=${zaiResponse.id}, content_blocks=${zaiResponse.content?.length || 0}`);
+
+  const output = [];
+  let outputText = '';
+
+  const wasJsonSchemaRequest = originalRequest.text?.format?.type === 'json_schema';
+  const schemaName = originalRequest.text?.format?.name;
+
+  // Process content blocks
+  if (zaiResponse.content && Array.isArray(zaiResponse.content)) {
+    const messageContent = [];
+    let jsonSchemaOutput = null; // json_schema 요청 시 tool_use의 input 저장
+
+    // 먼저 tool_use 블록에서 json_schema 출력 확인
+    if (wasJsonSchemaRequest) {
+      for (const block of zaiResponse.content) {
+        if (block.type === 'tool_use' && block.name === schemaName) {
+          jsonSchemaOutput = JSON.stringify(block.input);
+          debugLog(`[convertResponse] Found json_schema tool_use: ${jsonSchemaOutput}`);
+          break;
+        }
+      }
+    }
+
+    for (const block of zaiResponse.content) {
+      if (block.type === 'thinking') {
+        // Z.AI/GLM thinking 블록 → Responses API reasoning 타입으로 변환
+        output.push({
+          id: `reasoning_${zaiResponse.id}_${output.length}`,
+          type: 'reasoning',
+          status: 'completed',
+          content: [
+            {
+              type: 'thinking',
+              thinking: block.thinking || ''
+            }
+          ]
+        });
+        debugLog(`[convertResponse] Converted thinking block: ${(block.thinking || '').length} chars`);
+      } else if (block.type === 'text') {
+        // json_schema 요청이고 tool_use가 있으면, text 블록은 output_text에 포함하지 않음
+        // (GLM 모델이 text + tool_use를 둘 다 반환하는 경우 대응)
+        if (wasJsonSchemaRequest && jsonSchemaOutput) {
+          debugLog(`[convertResponse] Skipping text block for json_schema request (tool_use found)`);
+          // text 블록은 messageContent에만 추가 (참고용)
+          messageContent.push({
+            type: 'output_text',
+            text: block.text,
+            annotations: []
+          });
+          // outputText에는 추가하지 않음!
+        } else {
+          messageContent.push({
+            type: 'output_text',
+            text: block.text,
+            annotations: []
+          });
+          outputText += block.text;
+        }
+      } else if (block.type === 'tool_use') {
+        if (wasJsonSchemaRequest && block.name === schemaName) {
+          // json_schema 요청의 tool_use는 outputText로만 변환
+          const jsonOutput = JSON.stringify(block.input);
+          messageContent.push({
+            type: 'output_text',
+            text: jsonOutput,
+            annotations: []
+          });
+          outputText = jsonOutput; // outputText를 JSON만으로 설정 (덮어쓰기)
+        } else {
+          // Z.AI uses 'call_' prefix for tool IDs
+          output.push({
+            id: `fc_${block.id}`,
+            type: 'function_call',
+            status: 'completed',
+            arguments: JSON.stringify(block.input),
+            call_id: block.id,
+            name: block.name
+          });
+        }
+      }
+    }
+
+    if (messageContent.length > 0) {
+      output.push({
+        id: `msg_${zaiResponse.id}`,
+        type: 'message',
+        status: 'completed',
+        role: 'assistant',
+        content: messageContent
+      });
+    }
+  }
+
+  if (output.length === 0) {
+    output.push({
+      id: `msg_${zaiResponse.id}`,
+      type: 'message',
+      status: 'completed',
+      role: 'assistant',
+      content: [
+        {
+          type: 'output_text',
+          text: outputText || ' ',
+          annotations: []
+        }
+      ]
+    });
+  }
+
+  // Determine status and incomplete_details based on stop_reason
+  const stopReason = zaiResponse.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'
+    };
+    debugLog(`[convertResponse] WARNING: Response truncated due to max_tokens`);
+  } else if (!isCompleted && stopReason) {
+    incompleteDetails = {
+      reason: stopReason,
+      message: `Response stopped with reason: ${stopReason}`
+    };
+  }
+
+  const responsesResponse = {
+    id: `resp_${zaiResponse.id}`,
+    object: 'response',
+    created_at: Math.floor(Date.now() / 1000),
+    status: isCompleted ? 'completed' : 'incomplete',
+    background: false,
+    billing: {
+      payer: 'developer'
+    },
+    error: null,
+    incomplete_details: incompleteDetails,
+    instructions: originalRequest.instructions || null,
+    max_output_tokens: originalRequest.max_output_tokens || null,
+    max_tool_calls: null,
+    model: model,
+    output: output,
+    parallel_tool_calls: true,
+    previous_response_id: null,
+    prompt_cache_key: null,
+    prompt_cache_retention: null,
+    reasoning: {
+      effort: originalRequest.reasoning?.effort || null,
+      summary: originalRequest.reasoning?.summary || null
+    },
+    safety_identifier: null,
+    service_tier: zaiResponse.usage?.service_tier || 'standard',
+    store: originalRequest.store !== undefined ? originalRequest.store : true,
+    temperature: originalRequest.temperature !== undefined ? originalRequest.temperature : 1,
+    text: {
+      format: {
+        type: 'text'
+      },
+      verbosity: 'medium'
+    },
+    tool_choice: originalRequest.tool_choice || 'auto',
+    tools: originalRequest.tools || [],
+    top_logprobs: 0,
+    top_p: originalRequest.top_p !== undefined ? originalRequest.top_p : 1,
+    truncation: 'disabled',
+    usage: {
+      input_tokens: zaiResponse.usage?.input_tokens || 0,
+      input_tokens_details: {
+        cached_tokens: zaiResponse.usage?.cache_read_input_tokens || 0
+      },
+      output_tokens: zaiResponse.usage?.output_tokens || 0,
+      output_tokens_details: {
+        reasoning_tokens: 0
+      },
+      total_tokens: (zaiResponse.usage?.input_tokens || 0) + (zaiResponse.usage?.output_tokens || 0),
+      // Z.AI 추가 정보
+      cache_read_input_tokens: zaiResponse.usage?.cache_read_input_tokens || 0,
+      server_tool_use: zaiResponse.usage?.server_tool_use || null
+    },
+    user: null,
+    metadata: {},
+    output_text: outputText
+  };
+
+  const elapsed = Date.now() - startTime;
+  debugLog(`[convertResponse] END: ${elapsed}ms, output_items=${output.length}, output_text_len=${outputText.length}`);
+
+  return responsesResponse;
+}

package/src/LLMClient/errors.js

@@ -176,15 +176,29 @@ export function normalizeError(error, provider) {
   }
 
   // Anthropic SDK error (check BEFORE OpenAI SDK error, as both have error.status && error.error)
-  if (provider === 'claude' && error.status) {
+  // Z.AI uses Anthropic SDK so handle similarly
+  if ((provider === 'claude' || provider === 'zai') && error.status) {
     // Parse Claude error from error.error object (Anthropic SDK provides parsed error)
     let errorType = ERROR_TYPE_MAP[error.status] || 'api_error';
     let code = null;
-    let message = error.message || 'Claude API error';
+    let message = error.message || (provider === 'zai' ? 'Z.AI API error' : 'Claude API error');
 
+    // Z.AI specific error format: { detail: [{ type, loc, msg, ... }] }
+    if (error.error && error.error.detail && Array.isArray(error.error.detail)) {
+      const zaiError = error.error.detail[0];
+      if (zaiError) {
+        code = zaiError.type || null;
+        message = zaiError.msg || message;
+
+        // Map Z.AI error types
+        if (zaiError.type === 'json_invalid') {
+          errorType = 'invalid_request_error';
+        }
+      }
+    }
     // Anthropic SDK provides error.error object with structure:
     // { type: 'error', error: { type: 'not_found_error', message: '...' } }
-    if (error.error && error.error.error) {
+    else if (error.error && error.error.error) {
       const claudeError = error.error.error;
 
       if (claudeError.type) {
@@ -220,7 +234,7 @@ export function normalizeError(error, provider) {
         param: null,
         code: code,
         status: error.status,
-        provider: 'claude',
+        provider: provider,
         originalError: error
       }
     );

package/src/LLMClient/index.js

@@ -21,6 +21,11 @@ export {
   convertOllamaResponseToResponsesFormat
 } from './converters/responses-to-ollama.js';
 
+export {
+  convertResponsesRequestToZaiFormat,
+  convertZaiResponseToResponsesFormat
+} from './converters/responses-to-zai.js';
+
 // Export error classes
 export {
   LLMError,