wave-agent-sdk 0.0.8 → 0.0.10

package/src/services/aiService.ts

@@ -21,6 +21,41 @@ import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
 
+/**
+ * Interface for debug data saved during 400 errors
+ */
+interface DebugData {
+  originalMessages: ChatCompletionMessageParam[];
+  timestamp: string;
+  model: string;
+  workdir: string;
+  sessionId?: string;
+  gatewayConfig: {
+    baseURL?: string;
+    defaultHeaders?: Record<string, string>;
+  };
+  processedMessages?: OpenAI.Chat.Completions.ChatCompletionMessageParam[];
+  createParams?:
+    | ChatCompletionCreateParamsNonStreaming
+    | ChatCompletionCreateParamsStreaming;
+  tools?: ChatCompletionFunctionTool[];
+}
+
+/**
+ * Interface for error data saved during 400 errors
+ */
+interface ErrorData {
+  error: {
+    message?: string;
+    status?: number;
+    type?: string;
+    code?: string;
+    body?: unknown;
+    stack?: string;
+  };
+  timestamp: string;
+}
+
 /**
  * Use parametersChunk as compact param for better performance
  * Instead of parsing JSON, we use the raw chunk for efficient streaming
@@ -105,11 +140,13 @@ export interface CallAgentOptions {
     parametersChunk?: string;
     stage?: "start" | "streaming" | "running" | "end";
   }) => void;
+  onReasoningUpdate?: (content: string) => void;
 }
 
 export interface CallAgentResult {
   content?: string;
   tool_calls?: ChatCompletionMessageToolCall[];
+  reasoning_content?: string;
   usage?: ClaudeUsage;
   finish_reason?:
     | "stop"
@@ -119,7 +156,7 @@ export interface CallAgentResult {
     | "function_call"
     | null;
   response_headers?: Record<string, string>;
-  metadata?: Record<string, unknown>;
+  additionalFields?: Record<string, unknown>;
 }
 
 export async function callAgent(
@@ -137,13 +174,27 @@ export async function callAgent(
     systemPrompt,
     onContentUpdate,
     onToolUpdate,
+    onReasoningUpdate,
   } = options;
 
+  // Declare variables outside try block for error handling access
+  let openaiMessages:
+    | OpenAI.Chat.Completions.ChatCompletionMessageParam[]
+    | undefined;
+  let createParams:
+    | ChatCompletionCreateParamsNonStreaming
+    | ChatCompletionCreateParamsStreaming
+    | undefined;
+  let processedTools: ChatCompletionFunctionTool[] | undefined;
+
   try {
     // Create OpenAI client with injected configuration
     const openai = new OpenAI({
       apiKey: gatewayConfig.apiKey,
       baseURL: gatewayConfig.baseURL,
+      defaultHeaders: gatewayConfig.defaultHeaders,
+      fetchOptions: gatewayConfig.fetchOptions,
+      fetch: gatewayConfig.fetch,
     });
 
     // Build system prompt content
@@ -183,19 +234,23 @@ Today's date: ${new Date().toISOString().split("T")[0]}
     };
 
     // ChatCompletionMessageParam[] is already in OpenAI format, add system prompt to the beginning
-    let openaiMessages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
-      systemMessage,
-      ...messages,
-    ];
+    openaiMessages = [systemMessage, ...messages];
 
     // Apply cache control for Claude models
     const currentModel = model || modelConfig.agentModel;
 
+    processedTools = tools;
+
     if (isClaudeModel(currentModel)) {
       openaiMessages = transformMessagesForClaudeCache(
         openaiMessages,
         currentModel,
       );
+
+      // Apply cache control to tools separately
+      if (tools && tools.length > 0) {
+        processedTools = addCacheControlToLastTool(tools);
+      }
     }
 
     // Get model configuration - use injected modelConfig with optional override
@@ -204,10 +259,14 @@ Today's date: ${new Date().toISOString().split("T")[0]}
     });
 
     // Determine if streaming is needed
-    const isStreaming = !!(onContentUpdate || onToolUpdate);
+    const isStreaming = !!(
+      onContentUpdate ||
+      onToolUpdate ||
+      onReasoningUpdate
+    );
 
     // Prepare API call parameters
-    const createParams = {
+    createParams = {
       ...openaiModelConfig,
       messages: openaiMessages,
       stream: isStreaming,
@@ -216,13 +275,8 @@ Today's date: ${new Date().toISOString().split("T")[0]}
       | ChatCompletionCreateParamsStreaming;
 
     // Only add tools if they exist
-    if (tools && tools.length > 0) {
-      // Apply cache control to tools for Claude models
-      if (isClaudeModel(currentModel)) {
-        createParams.tools = addCacheControlToLastTool(tools);
-      } else {
-        createParams.tools = tools;
-      }
+    if (processedTools && processedTools.length > 0) {
+      createParams.tools = processedTools;
     }
 
     if (isStreaming) {
@@ -243,6 +297,7 @@ Today's date: ${new Date().toISOString().split("T")[0]}
         stream,
         onContentUpdate,
         onToolUpdate,
+        onReasoningUpdate,
         abortSignal,
         responseHeaders,
         currentModel,
@@ -287,26 +342,39 @@ Today's date: ${new Date().toISOString().split("T")[0]}
         const {
           content: finalContent,
           tool_calls: finalToolCalls,
+          reasoning_content: finalReasoningContent,
           ...otherFields
-        } = finalMessage;
+        } = finalMessage as unknown as {
+          content?: string;
+          tool_calls?: ChatCompletionMessageToolCall[];
+          reasoning_content?: string;
+          [key: string]: unknown;
+        };
 
         if (typeof finalContent === "string" && finalContent.length > 0) {
           result.content = finalContent;
         }
 
+        if (
+          typeof finalReasoningContent === "string" &&
+          finalReasoningContent.length > 0
+        ) {
+          result.reasoning_content = finalReasoningContent;
+        }
+
         if (Array.isArray(finalToolCalls) && finalToolCalls.length > 0) {
           result.tool_calls = finalToolCalls;
         }
 
         if (Object.keys(otherFields).length > 0) {
-          const metadata: Record<string, unknown> = {};
+          const additionalFields: Record<string, unknown> = {};
           for (const [key, value] of Object.entries(otherFields)) {
-            if (value !== undefined) {
-              metadata[key] = value;
+            if (value !== undefined && key !== "role") {
+              additionalFields[key] = value;
             }
           }
-          if (Object.keys(metadata).length > 0) {
-            result.metadata = metadata;
+          if (Object.keys(additionalFields).length > 0) {
+            result.additionalFields = additionalFields;
           }
         }
       }
@@ -329,6 +397,98 @@ Today's date: ${new Date().toISOString().split("T")[0]}
     if ((error as Error).name === "AbortError") {
       throw new Error("Request was aborted");
     }
+
+    // Check if it's a 400 error and save messages to temp directory
+    if (
+      error &&
+      typeof error === "object" &&
+      "status" in error &&
+      error.status === 400
+    ) {
+      try {
+        // Create temp directory for error debugging
+        const tempDir = fs.mkdtempSync(
+          path.join(os.tmpdir(), "callAgent-400-error-"),
+        );
+        const messagesFile = path.join(tempDir, "messages.json");
+        const errorFile = path.join(tempDir, "error.json");
+
+        // Save complete messages to temp file
+        const debugData: DebugData = {
+          originalMessages: messages,
+          timestamp: new Date().toISOString(),
+          model: model || modelConfig.agentModel,
+          workdir,
+          sessionId: options.sessionId,
+          gatewayConfig: {
+            baseURL: gatewayConfig.baseURL,
+            // Don't include apiKey for security
+            defaultHeaders: gatewayConfig.defaultHeaders,
+          },
+        };
+
+        // Add processed messages if they exist
+        if (typeof openaiMessages !== "undefined") {
+          debugData.processedMessages = openaiMessages;
+        }
+
+        // Add create params if they exist
+        if (typeof createParams !== "undefined") {
+          debugData.createParams = createParams;
+        }
+
+        // Add tools if they exist
+        if (processedTools) {
+          debugData.tools = processedTools;
+        }
+
+        fs.writeFileSync(messagesFile, JSON.stringify(debugData, null, 2));
+
+        // Save error details
+        const errorData: ErrorData = {
+          error: {
+            message:
+              error && typeof error === "object" && "message" in error
+                ? String(error.message)
+                : undefined,
+            status:
+              error && typeof error === "object" && "status" in error
+                ? Number(error.status)
+                : undefined,
+            type:
+              error && typeof error === "object" && "type" in error
+                ? String(error.type)
+                : undefined,
+            code:
+              error && typeof error === "object" && "code" in error
+                ? String(error.code)
+                : undefined,
+            body:
+              error && typeof error === "object" && "body" in error
+                ? error.body
+                : undefined,
+            stack:
+              error && typeof error === "object" && "stack" in error
+                ? String(error.stack)
+                : undefined,
+          },
+          timestamp: new Date().toISOString(),
+        };
+
+        fs.writeFileSync(errorFile, JSON.stringify(errorData, null, 2));
+
+        logger.error(
+          "callAgent 400 error occurred. Debug files saved to:",
+          tempDir,
+        );
+        logger.error("Messages file:", messagesFile);
+        logger.error("Error file:", errorFile);
+        logger.error("Error details:", error);
+      } catch (saveError) {
+        logger.error("Failed to save 400 error debug files:", saveError);
+      }
+    }
+
     logger.error("Failed to call OpenAI:", error);
     throw error;
   }
@@ -354,11 +514,13 @@ async function processStreamingResponse(
     parametersChunk?: string;
     stage?: "start" | "streaming" | "running" | "end";
   }) => void,
+  onReasoningUpdate?: (content: string) => void,
   abortSignal?: AbortSignal,
   responseHeaders?: Record<string, string>,
   modelName?: string,
 ): Promise<CallAgentResult> {
   let accumulatedContent = "";
+  let accumulatedReasoningContent = "";
   const toolCalls: {
     id: string;
     type: "function";
@@ -411,10 +573,12 @@ async function processStreamingResponse(
       const {
         content,
         tool_calls: toolCallUpdates,
+        reasoning_content,
         ...deltaMetadata
       } = delta as unknown as {
         content?: string;
         tool_calls?: ChatCompletionChunk.Choice.Delta.ToolCall[];
+        reasoning_content?: string;
         [key: string]: unknown;
       };
 
@@ -431,6 +595,16 @@ async function processStreamingResponse(
         }
       }
 
+      if (
+        typeof reasoning_content === "string" &&
+        reasoning_content.length > 0
+      ) {
+        accumulatedReasoningContent += reasoning_content;
+        if (onReasoningUpdate) {
+          onReasoningUpdate(accumulatedReasoningContent);
+        }
+      }
+
       if (Array.isArray(toolCallUpdates)) {
         for (const rawToolCall of toolCallUpdates) {
           const toolCallDelta =
@@ -516,7 +690,11 @@ async function processStreamingResponse(
   const result: CallAgentResult = {};
 
   if (accumulatedContent) {
-    result.content = accumulatedContent;
+    result.content = accumulatedContent.trim();
+  }
+
+  if (accumulatedReasoningContent) {
+    result.reasoning_content = accumulatedReasoningContent.trim();
   }
 
   if (toolCalls.length > 0) {
@@ -536,14 +714,14 @@ async function processStreamingResponse(
   }
 
   if (Object.keys(additionalDeltaFields).length > 0) {
-    result.metadata = {};
+    result.additionalFields = {};
     for (const [key, value] of Object.entries(additionalDeltaFields)) {
-      if (value !== undefined) {
-        result.metadata[key] = value;
+      if (value !== undefined && key !== "role") {
+        result.additionalFields[key] = value;
       }
     }
-    if (Object.keys(result.metadata).length === 0) {
-      delete result.metadata;
+    if (Object.keys(result.additionalFields).length === 0) {
+      delete result.additionalFields;
     }
   }
 
@@ -578,6 +756,9 @@ export async function compressMessages(
   const openai = new OpenAI({
     apiKey: gatewayConfig.apiKey,
     baseURL: gatewayConfig.baseURL,
+    defaultHeaders: gatewayConfig.defaultHeaders,
+    fetchOptions: gatewayConfig.fetchOptions,
+    fetch: gatewayConfig.fetch,
   });
 
   // Get model configuration - use injected fast model