feat(request-details): implement observability settings and enhance request detail tracking

- Added new observability settings in the dashboard for max records, batch size, flush interval, and max JSON size.
- Introduced `extractRequestConfig` function to capture full request configurations.
- Enhanced error handling by saving detailed request information on failures.
- Updated usage tracking to include new token metrics.
- Modified streaming functions to support detailed content and reasoning tracking.

open-sse/handlers/chatCore.js

@@ -10,7 +10,7 @@ import { getModelTargetFormat, PROVIDER_ID_TO_ALIAS } from "../config/providerMo
 import { createErrorResult, parseUpstreamError, formatProviderError } from "../utils/error.js";
 import { HTTP_STATUS } from "../config/constants.js";
 import { handleBypassRequest } from "../utils/bypassHandler.js";
-import { saveRequestUsage, trackPendingRequest, appendRequestLog } from "@/lib/usageDb.js";
+import { saveRequestUsage, trackPendingRequest, appendRequestLog, saveRequestDetail } from "@/lib/usageDb.js";
 import { getExecutor } from "../executors/index.js";
 
 /**
@@ -225,6 +225,38 @@ function extractUsageFromResponse(responseBody, provider) {
   return null;
 }
 
+/**
+ * Extract full request configuration from body
+ * Captures all relevant parameters for request details
+ */
+function extractRequestConfig(body, stream) {
+  const config = {
+    messages: body.messages || [],
+    model: body.model,
+    stream: stream
+  };
+  
+  // Add all optional configuration parameters
+  const optionalParams = [
+    'temperature', 'top_p', 'top_k',
+    'max_tokens', 'max_completion_tokens',
+    'thinking', 'reasoning', 'enable_thinking',
+    'presence_penalty', 'frequency_penalty',
+    'seed', 'stop', 'tools', 'tool_choice',
+    'response_format', 'prediction', 'store', 'metadata',
+    'n', 'logprobs', 'top_logprobs', 'logit_bias',
+    'user', 'parallel_tool_calls'
+  ];
+  
+  for (const param of optionalParams) {
+    if (body[param] !== undefined) {
+      config[param] = body[param];
+    }
+  }
+  
+  return config;
+}
+
 /**
  * Convert OpenAI-style SSE chunks into a single non-streaming JSON response.
  * Used as a fallback when upstream returns text/event-stream for stream=false.
@@ -315,6 +347,7 @@ function parseSSEToOpenAIResponse(rawSSE, fallbackModel) {
  */
 export async function handleChatCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, clientRawRequest, connectionId, userAgent }) {
   const { provider, model } = modelInfo;
+  const requestStartTime = Date.now();
 
   const sourceFormat = detectFormat(body);
 
@@ -407,6 +440,26 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
   } catch (error) {
     trackPendingRequest(model, provider, connectionId, false);
     appendRequestLog({ model, provider, connectionId, status: `FAILED ${error.name === "AbortError" ? 499 : HTTP_STATUS.BAD_GATEWAY}` }).catch(() => { });
+
+    const errorDetail = {
+      provider: provider || "unknown",
+      model: model || "unknown",
+      connectionId: connectionId || undefined,
+      timestamp: new Date().toISOString(),
+      latency: { ttft: 0, total: Date.now() - requestStartTime },
+      tokens: { prompt_tokens: 0, completion_tokens: 0 },
+      request: extractRequestConfig(body, stream),
+      providerRequest: translatedBody || null,
+      providerResponse: null,
+      response: {
+        error: error.message || String(error),
+        status: error.name === "AbortError" ? 499 : 502,
+        thinking: null
+      },
+      status: "error"
+    };
+    saveRequestDetail(errorDetail).catch(() => {});
+
     if (error.name === "AbortError") {
       streamController.handleError(error);
       return createErrorResult(499, "Request aborted");
@@ -463,6 +516,26 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
     trackPendingRequest(model, provider, connectionId, false);
     const { statusCode, message, retryAfterMs } = await parseUpstreamError(providerResponse, provider);
     appendRequestLog({ model, provider, connectionId, status: `FAILED ${statusCode}` }).catch(() => { });
+
+    const errorDetail = {
+      provider: provider || "unknown",
+      model: model || "unknown",
+      connectionId: connectionId || undefined,
+      timestamp: new Date().toISOString(),
+      latency: { ttft: 0, total: Date.now() - requestStartTime },
+      tokens: { prompt_tokens: 0, completion_tokens: 0 },
+      request: extractRequestConfig(body, stream),
+      providerRequest: finalBody || translatedBody || null,
+      providerResponse: null,
+      response: {
+        error: message,
+        status: statusCode,
+        thinking: null
+      },
+      status: "error"
+    };
+    saveRequestDetail(errorDetail).catch(() => {});
+
     const errMsg = formatProviderError(new Error(message), provider, model, statusCode);
     console.log(`${COLORS.red}[ERROR] ${errMsg}${COLORS.reset}`);
 
@@ -531,6 +604,37 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
       translatedResponse.usage = filterUsageForFormat(buffered, sourceFormat);
     }
 
+    const totalLatency = Date.now() - requestStartTime;
+    const requestDetail = {
+      provider: provider || "unknown",
+      model: model || "unknown",
+      connectionId: connectionId || undefined,
+      timestamp: new Date().toISOString(),
+      latency: {
+        ttft: totalLatency,
+        total: totalLatency
+      },
+      tokens: usage || { prompt_tokens: 0, completion_tokens: 0 },
+      request: extractRequestConfig(body, stream),
+      providerRequest: finalBody || translatedBody || null,
+      providerResponse: responseBody || null,
+      response: {
+        content: translatedResponse?.choices?.[0]?.message?.content ||
+                 translatedResponse?.content ||
+                 null,
+        thinking: translatedResponse?.choices?.[0]?.message?.reasoning_content ||
+                  translatedResponse?.reasoning_content ||
+                  null,
+        finish_reason: translatedResponse?.choices?.[0]?.finish_reason || "unknown"
+      },
+      status: "success"
+    };
+
+    // Async save (don't block response)
+    saveRequestDetail(requestDetail).catch(err => {
+      console.error("[RequestDetail] Failed to save:", err.message);
+    });
+
     return {
       success: true,
       response: new Response(JSON.stringify(translatedResponse), {
@@ -556,31 +660,103 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
     "Access-Control-Allow-Origin": "*"
   };
 
-  // Create transform stream with logger for streaming response
+  let streamContent = "";
+  let streamUsage = null;
+  const streamDetailId = `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+  
+  const onStreamComplete = (contentObj, usage, ttftAt) => {
+    // contentObj is object { content, thinking }
+    streamUsage = usage;
+    
+    const updatedDetail = {
+      provider: provider || "unknown",
+      model: model || "unknown",
+      connectionId: connectionId || undefined,
+      timestamp: new Date().toISOString(),
+      latency: {
+        ttft: ttftAt ? ttftAt - requestStartTime : Date.now() - requestStartTime,
+        total: Date.now() - requestStartTime
+      },
+      tokens: usage || { prompt_tokens: 0, completion_tokens: 0 },
+      request: extractRequestConfig(body, stream),
+      providerRequest: finalBody || translatedBody || null,
+      providerResponse: contentObj.content || "[Empty streaming response]",
+      response: {
+        content: contentObj.content || "[Empty streaming response]",
+        thinking: contentObj.thinking || null,
+        type: "streaming"
+      },
+      status: "success",
+      id: streamDetailId
+    };
+    
+    saveRequestDetail(updatedDetail).catch(err => {
+      console.error("[RequestDetail] Failed to update streaming content:", err.message);
+    });
+
+    // Save usage stats for dashboard
+    if (usage && typeof usage === 'object') {
+      const msg = `[${new Date().toLocaleTimeString("en-US", { hour12: false, hour: "2-digit", minute: "2-digit" })}] 📊 [STREAM USAGE] ${provider.toUpperCase()} | in=${usage?.prompt_tokens || 0} | out=${usage?.completion_tokens || 0}${connectionId ? ` | account=${connectionId.slice(0, 8)}...` : ""}`;
+      console.log(`${COLORS.green}${msg}${COLORS.reset}`);
+
+      saveRequestUsage({
+        provider: provider || "unknown",
+        model: model || "unknown",
+        tokens: usage,
+        timestamp: new Date().toISOString(),
+        connectionId: connectionId || undefined
+      }).catch(err => {
+        console.error("Failed to save streaming usage stats:", err.message);
+      });
+    }
+  };
+
   let transformStream;
-  // For Codex provider, translate response from openai-responses to openai (Chat Completions) format
-  // UNLESS client is Droid CLI which expects openai-responses format back
   const isDroidCLI = userAgent?.toLowerCase().includes('droid') || userAgent?.toLowerCase().includes('codex-cli');
   const needsCodexTranslation = provider === 'codex'
     && targetFormat === 'openai-responses'
     && !isDroidCLI;
 
   if (needsCodexTranslation) {
-    // Codex returns openai-responses, translate to openai (Chat Completions) that clients expect
     log?.debug?.("STREAM", `Codex translation mode: openai-responses → openai`);
-    transformStream = createSSETransformStreamWithLogger('openai-responses', 'openai', provider, reqLogger, toolNameMap, model, connectionId, body);
+    transformStream = createSSETransformStreamWithLogger('openai-responses', 'openai', provider, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete);
   } else if (needsTranslation(targetFormat, sourceFormat)) {
-    // Standard translation for other providers
     log?.debug?.("STREAM", `Translation mode: ${targetFormat} → ${sourceFormat}`);
-    transformStream = createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider, reqLogger, toolNameMap, model, connectionId, body);
+    transformStream = createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider, reqLogger, toolNameMap, model, connectionId, body, onStreamComplete);
   } else {
     log?.debug?.("STREAM", `Standard passthrough mode`);
-    transformStream = createPassthroughStreamWithLogger(provider, reqLogger, model, connectionId, body);
+    transformStream = createPassthroughStreamWithLogger(provider, reqLogger, model, connectionId, body, onStreamComplete);
   }
 
-  // Pipe response through transform with disconnect detection
   const transformedBody = pipeWithDisconnect(providerResponse, transformStream, streamController);
 
+  const totalLatency = Date.now() - requestStartTime;
+  const streamingDetail = {
+    provider: provider || "unknown",
+    model: model || "unknown",
+    connectionId: connectionId || undefined,
+    timestamp: new Date().toISOString(),
+    latency: {
+      ttft: 0,
+      total: Date.now() - requestStartTime
+    },
+    tokens: { prompt_tokens: 0, completion_tokens: 0 },
+    request: extractRequestConfig(body, stream),
+    providerRequest: finalBody || translatedBody || null,
+    providerResponse: "[Streaming - raw response not captured]",
+    response: {
+      content: "[Streaming in progress...]",
+      thinking: null,
+      type: "streaming"
+    },
+    status: "success",
+    id: streamDetailId
+  };
+
+  saveRequestDetail(streamingDetail).catch(err => {
+    console.error("[RequestDetail] Failed to save streaming request:", err.message);
+  });
+
   return {
     success: true,
     response: new Response(transformedBody, {

open-sse/translator/response/claude-to-openai.js

@@ -64,7 +64,7 @@ export function claudeToOpenAIResponse(chunk, state) {
       if (delta?.type === "text_delta" && delta.text) {
         results.push(createChunk(state, { content: delta.text }));
       } else if (delta?.type === "thinking_delta" && delta.thinking) {
-        results.push(createChunk(state, { content: delta.thinking }));
+        results.push(createChunk(state, { reasoning_content: delta.thinking }));
       } else if (delta?.type === "input_json_delta" && delta.partial_json) {
         const toolCall = state.toolCalls.get(chunk.index);
         if (toolCall) {
@@ -83,7 +83,7 @@ export function claudeToOpenAIResponse(chunk, state) {
 
     case "content_block_stop": {
       if (state.inThinkingBlock && chunk.index === state.currentBlockIndex) {
-        results.push(createChunk(state, { content: "</think>" }));
+        results.push(createChunk(state, { reasoning_content: "" }));
         state.inThinkingBlock = false;
       }
       state.textBlockStarted = false;

open-sse/utils/stream.js

@@ -28,6 +28,7 @@ const STREAM_MODE = {
  * @param {string} options.model - Model name
  * @param {string} options.connectionId - Connection ID for usage tracking
  * @param {object} options.body - Request body (for input token estimation)
+ * @param {function} options.onStreamComplete - Callback when stream completes (content, usage)
  */
 export function createSSEStream(options = {}) {
   const {
@@ -39,20 +40,25 @@ export function createSSEStream(options = {}) {
     toolNameMap = null,
     model = null,
     connectionId = null,
-    body = null
+    body = null,
+    onStreamComplete = null
   } = options;
 
   let buffer = "";
   let usage = null;
 
-  // State for translate mode
   const state = mode === STREAM_MODE.TRANSLATE ? { ...initState(sourceFormat), provider, toolNameMap } : null;
 
-  // Track content length for usage estimation (both modes)
   let totalContentLength = 0;
+  let accumulatedContent = "";
+  let accumulatedThinking = "";
+  let ttftAt = null;
 
   return new TransformStream({
     transform(chunk, controller) {
+      if (!ttftAt) {
+        ttftAt = Date.now();
+      }
       const text = sharedDecoder.decode(chunk, { stream: true });
       buffer += text;
       reqLogger?.appendProviderChunk?.(text);
@@ -79,9 +85,15 @@ export function createSSEStream(options = {}) {
               }
 
               const delta = parsed.choices?.[0]?.delta;
-              const content = delta?.content || delta?.reasoning_content;
+              const content = delta?.content;
+              const reasoning = delta?.reasoning_content;
               if (content && typeof content === "string") {
                 totalContentLength += content.length;
+                accumulatedContent += content;
+              }
+              if (reasoning && typeof reasoning === "string") {
+                totalContentLength += reasoning.length;
+                accumulatedThinking += reasoning;
               }
 
               const extracted = extractUsage(parsed);
@@ -134,30 +146,39 @@ export function createSSEStream(options = {}) {
           continue;
         }
 
-        // Track content length for estimation (from various formats)
-        // Include both regular content and reasoning/thinking content
-        
-        // Claude format
+        // Claude format - content
         if (parsed.delta?.text) {
           totalContentLength += parsed.delta.text.length;
+          accumulatedContent += parsed.delta.text;
         }
+        // Claude format - thinking
         if (parsed.delta?.thinking) {
           totalContentLength += parsed.delta.thinking.length;
+          accumulatedThinking += parsed.delta.thinking;
         }
         
-        // OpenAI format
+        // OpenAI format - content
         if (parsed.choices?.[0]?.delta?.content) {
           totalContentLength += parsed.choices[0].delta.content.length;
+          accumulatedContent += parsed.choices[0].delta.content;
         }
+        // OpenAI format - reasoning
         if (parsed.choices?.[0]?.delta?.reasoning_content) {
           totalContentLength += parsed.choices[0].delta.reasoning_content.length;
+          accumulatedThinking += parsed.choices[0].delta.reasoning_content;
         }
         
-        // Gemini format - may have multiple parts
+        // Gemini format
         if (parsed.candidates?.[0]?.content?.parts) {
           for (const part of parsed.candidates[0].content.parts) {
             if (part.text && typeof part.text === "string") {
               totalContentLength += part.text.length;
+              // Check if this is thinking content
+              if (part.thought === true) {
+                accumulatedThinking += part.text;
+              } else {
+                accumulatedContent += part.text;
+              }
             }
           }
         }
@@ -220,7 +241,6 @@ export function createSSEStream(options = {}) {
             controller.enqueue(sharedEncoder.encode(output));
           }
 
-          // Estimate usage if provider didn't return valid usage (PASSTHROUGH is always OpenAI format)
           if (!hasValidUsage(usage) && totalContentLength > 0) {
             usage = estimateUsage(body, totalContentLength, FORMATS.OPENAI);
           }
@@ -230,16 +250,21 @@ export function createSSEStream(options = {}) {
           } else {
             appendRequestLog({ model, provider, connectionId, tokens: null, status: "200 OK" }).catch(() => { });
           }
+          
+          if (onStreamComplete) {
+            onStreamComplete({
+              content: accumulatedContent,
+              thinking: accumulatedThinking
+            }, usage, ttftAt);
+          }
           return;
         }
 
-        // Translate mode: process remaining buffer
         if (buffer.trim()) {
           const parsed = parseSSELine(buffer.trim());
           if (parsed && !parsed.done) {
             const translated = translateResponse(targetFormat, sourceFormat, parsed, state);
 
-            // Log OpenAI intermediate chunks
             if (translated?._openaiIntermediate) {
               for (const item of translated._openaiIntermediate) {
                 const openaiOutput = formatSSE(item, FORMATS.OPENAI);
@@ -257,10 +282,8 @@ export function createSSEStream(options = {}) {
           }
         }
 
-        // Flush remaining events (only once at stream end)
         const flushed = translateResponse(targetFormat, sourceFormat, null, state);
 
-        // Log OpenAI intermediate chunks for flushed events
         if (flushed?._openaiIntermediate) {
           for (const item of flushed._openaiIntermediate) {
             const openaiOutput = formatSSE(item, FORMATS.OPENAI);
@@ -276,12 +299,10 @@ export function createSSEStream(options = {}) {
           }
         }
 
-        // Send [DONE] and log usage
         const doneOutput = "data: [DONE]\n\n";
         reqLogger?.appendConvertedChunk?.(doneOutput);
         controller.enqueue(sharedEncoder.encode(doneOutput));
 
-        // Estimate usage if provider didn't return valid usage (for translate mode)
         if (!hasValidUsage(state?.usage) && totalContentLength > 0) {
           state.usage = estimateUsage(body, totalContentLength, sourceFormat);
         }
@@ -291,6 +312,13 @@ export function createSSEStream(options = {}) {
         } else {
           appendRequestLog({ model, provider, connectionId, tokens: null, status: "200 OK" }).catch(() => { });
         }
+        
+        if (onStreamComplete) {
+          onStreamComplete({
+            content: accumulatedContent,
+            thinking: accumulatedThinking
+          }, state?.usage, ttftAt);
+        }
       } catch (error) {
         console.log("Error in flush:", error);
       }
@@ -298,8 +326,7 @@ export function createSSEStream(options = {}) {
   });
 }
 
-// Convenience functions for backward compatibility
-export function createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider = null, reqLogger = null, toolNameMap = null, model = null, connectionId = null, body = null) {
+export function createSSETransformStreamWithLogger(targetFormat, sourceFormat, provider = null, reqLogger = null, toolNameMap = null, model = null, connectionId = null, body = null, onStreamComplete = null) {
   return createSSEStream({
     mode: STREAM_MODE.TRANSLATE,
     targetFormat,
@@ -309,17 +336,19 @@ export function createSSETransformStreamWithLogger(targetFormat, sourceFormat, p
     toolNameMap,
     model,
     connectionId,
-    body
+    body,
+    onStreamComplete
   });
 }
 
-export function createPassthroughStreamWithLogger(provider = null, reqLogger = null, model = null, connectionId = null, body = null) {
+export function createPassthroughStreamWithLogger(provider = null, reqLogger = null, model = null, connectionId = null, body = null, onStreamComplete = null) {
   return createSSEStream({
     mode: STREAM_MODE.PASSTHROUGH,
     provider,
     reqLogger,
     model,
     connectionId,
-    body
+    body,
+    onStreamComplete
   });
 }

open-sse/utils/usageTracking.js

@@ -312,11 +312,11 @@ export function logUsage(provider, usage, model = null, connectionId = null) {
 
   // Save to usage DB
   const tokens = {
-    input: inTokens,
-    output: outTokens,
-    cacheRead: cacheRead || 0,
-    cacheCreation: cacheCreation || 0,
-    reasoning: reasoning || 0
+    prompt_tokens: inTokens,
+    completion_tokens: outTokens,
+    cache_read_input_tokens: cacheRead || 0,
+    cache_creation_input_tokens: cacheCreation || 0,
+    reasoning_tokens: reasoning || 0
   };
   saveRequestUsage({ model, provider, connectionId, tokens }).catch(() => { });
   appendRequestLog({ model, provider, connectionId, tokens, status: "200 OK" }).catch(() => { });