@tyvm/knowhow 0.0.156 → 0.0.158

package/src/clients/openai.ts

@@ -1,5 +1,6 @@
 import OpenAI from "openai";
 import { getConfigSync } from "../config";
+import { emitResponseMetadata } from "./responseMetadata";
 import { OpenAiTextPricing } from "./pricing";
 import { ContextLimits } from "./contextLimits";
 import {
@@ -59,10 +60,39 @@ export class GenericOpenAiClient implements GenericClient {
     this.setKey(apiKey);
   }
 
+  private emitErrorMetadata(
+    options:
+      | CompletionOptions
+      | EmbeddingOptions
+      | AudioTranscriptionOptions
+      | AudioGenerationOptions,
+    error: unknown
+  ) {
+    if (!error || typeof error !== "object") return;
+    const apiError = error as {
+      status?: number;
+      headers?: Headers | Record<string, unknown>;
+      request_id?: string;
+      requestID?: string;
+      response?: Response;
+    };
+    const statusCode = apiError.status ?? apiError.response?.status;
+    const headers = apiError.headers ?? apiError.response?.headers;
+    if (typeof statusCode === "number" || headers) {
+      emitResponseMetadata(options, {
+        statusCode,
+        headers,
+        requestId: apiError.request_id ?? apiError.requestID,
+      });
+    }
+  }
+
   setKey(apiKey: string) {
     this.apiKey = apiKey;
     this.client = new OpenAI({
       apiKey,
+      // SDK retries hide individual responses, which breaks response-scoped telemetry.
+      maxRetries: 0,
       ...(config?.openaiBaseUrl && { baseURL: config.openaiBaseUrl }),
     });
   }
@@ -77,7 +107,9 @@ export class GenericOpenAiClient implements GenericClient {
     return this.detectReasoningEffort(messages);
   }
 
-  detectReasoningEffort(messages: CompletionOptions["messages"]): "low" | "medium" | "high" {
+  detectReasoningEffort(
+    messages: CompletionOptions["messages"]
+  ): "low" | "medium" | "high" {
     const effortMap: Record<string, "low" | "medium" | "high"> = {
       ultrathink: "high",
       "think hard": "high",
@@ -110,8 +142,11 @@ export class GenericOpenAiClient implements GenericClient {
     return "medium"; // Default to medium if no specific effort is mentioned
   }
 
-  resolveReasoningEffort(options: CompletionOptions): "low" | "medium" | "high" {
-    const effort = options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
+  resolveReasoningEffort(
+    options: CompletionOptions
+  ): "low" | "medium" | "high" {
+    const effort =
+      options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
     // Chat Completions only accepts low/medium/high. Preserve newer values on
     // the Responses API, but map them to the nearest legacy level here.
     if (effort === "none" || effort === "minimal") return "low";
@@ -125,7 +160,8 @@ export class GenericOpenAiClient implements GenericClient {
    * If the requested level is not supported, picks the lowest supported level.
    */
   resolveReasoningEffortForModel(options: CompletionOptions): string {
-    const raw = options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
+    const raw =
+      options.reasoning_effort ?? this.detectReasoningEffort(options.messages);
     // Anthropic calls its highest level `max`; OpenAI calls it `xhigh`.
     // Accept both provider-neutral CLI spellings.
     const requested = raw === "max" ? "xhigh" : raw;
@@ -175,10 +211,12 @@ export class GenericOpenAiClient implements GenericClient {
         content: Array.isArray(msg.content)
           ? textParts.length
             ? textParts
-            : [{
-                type: "text",
-                text: "Image output attached in the following user message.",
-              }]
+            : [
+                {
+                  type: "text",
+                  text: "Image output attached in the following user message.",
+                },
+              ]
           : msg.content || "",
       };
 
@@ -199,15 +237,13 @@ export class GenericOpenAiClient implements GenericClient {
     for (const part of content) {
       if (part.type === "text") {
         result.push({ type: "input_text", text: part.text });
-      }
-      else if (part.type === "image_url") {
+      } else if (part.type === "image_url") {
         result.push({
           type: "input_image",
           image_url: part.image_url.url,
           detail: part.image_url.detail || "auto",
         });
-      }
-      else {
+      } else {
         throw new Error(
           `OpenAI Responses API conversion does not support ${part.type} content.`
         );
@@ -226,20 +262,41 @@ export class GenericOpenAiClient implements GenericClient {
 
     const openaiMessages = this.toChatCompletionMessages(options.messages);
 
-    const response = await this.client.chat.completions.create({
-      model: options.model,
-      messages: openaiMessages,
-      max_tokens: options.max_tokens,
-      ...(OpenAiReasoningModels.includes(options.model) && !this.isReasoningDisabled(options) && {
-        max_tokens: undefined,
-        max_completion_tokens: Math.max(options.max_tokens ?? 0, 16_000),
-        reasoning_effort: this.resolveReasoningEffort(options),
-      }),
-      ...(options.tools?.length && {
-        tools: options.tools,
-        tool_choice: options.tool_choice ?? "auto",
-      }),
-    }, { signal: options.signal });
+    let result;
+    try {
+      result = await this.client.chat.completions
+        .create(
+          {
+            model: options.model,
+            messages: openaiMessages,
+            max_tokens: options.max_tokens,
+            ...(OpenAiReasoningModels.includes(options.model) &&
+              !this.isReasoningDisabled(options) && {
+                max_tokens: undefined,
+                max_completion_tokens: Math.max(
+                  options.max_tokens ?? 0,
+                  16_000
+                ),
+                reasoning_effort: this.resolveReasoningEffort(options),
+              }),
+            ...(options.tools?.length && {
+              tools: options.tools,
+              tool_choice: options.tool_choice ?? "auto",
+            }),
+          },
+          { signal: options.signal }
+        )
+        .withResponse();
+    } catch (error) {
+      this.emitErrorMetadata(options, error);
+      throw error;
+    }
+    const { data: response, response: nativeResponse, request_id } = result;
+    emitResponseMetadata(options, {
+      statusCode: nativeResponse.status,
+      headers: nativeResponse.headers,
+      requestId: request_id,
+    });
 
     const usdCost = this.calculateCost(options.model, response.usage);
 
@@ -255,19 +312,24 @@ export class GenericOpenAiClient implements GenericClient {
       })),
 
       model: options.model,
-      usage: response.usage ? {
-        prompt_tokens: response.usage.prompt_tokens ?? 0,
-        completion_tokens: response.usage.completion_tokens ?? 0,
-        total_tokens: response.usage.total_tokens,
-        prompt_tokens_details: {
-          cached_tokens: response.usage.prompt_tokens_details?.cached_tokens ?? 0,
-        },
-        ...(response.usage.completion_tokens_details?.reasoning_tokens != null && {
-          output_tokens_details: {
-            reasoning_tokens: response.usage.completion_tokens_details.reasoning_tokens,
-          },
-        }),
-      } : undefined,
+      usage: response.usage
+        ? {
+            prompt_tokens: response.usage.prompt_tokens ?? 0,
+            completion_tokens: response.usage.completion_tokens ?? 0,
+            total_tokens: response.usage.total_tokens,
+            prompt_tokens_details: {
+              cached_tokens:
+                response.usage.prompt_tokens_details?.cached_tokens ?? 0,
+            },
+            ...(response.usage.completion_tokens_details?.reasoning_tokens !=
+              null && {
+              output_tokens_details: {
+                reasoning_tokens:
+                  response.usage.completion_tokens_details.reasoning_tokens,
+              },
+            }),
+          }
+        : undefined,
       usd_cost: usdCost,
     };
   }
@@ -279,7 +341,12 @@ export class GenericOpenAiClient implements GenericClient {
    */
   async *createChatCompletionStream(
     options: CompletionOptions
-  ): AsyncGenerator<{ delta?: string; done: boolean; usage?: CompletionResponse['usage']; usd_cost?: number }> {
+  ): AsyncGenerator<{
+    delta?: string;
+    done: boolean;
+    usage?: CompletionResponse["usage"];
+    usd_cost?: number;
+  }> {
     if (OpenAiResponsesOnlyModels.includes(options.model)) {
       // Fallback: non-streaming for Responses-only models
       const result = await this.createChatCompletion(options);
@@ -290,19 +357,36 @@ export class GenericOpenAiClient implements GenericClient {
 
     const openaiMessages = this.toChatCompletionMessages(options.messages);
 
-    const stream = await this.client.chat.completions.create({
-      model: options.model,
-      messages: openaiMessages,
-      max_tokens: options.max_tokens,
-      stream: true,
-      stream_options: { include_usage: true },
-      ...(options.tools?.length && {
-        tools: options.tools,
-        tool_choice: options.tool_choice ?? "auto",
-      }),
-    }, { signal: options.signal });
-
-    let usage: CompletionResponse['usage'] | undefined;
+    let result;
+    try {
+      result = await this.client.chat.completions
+        .create(
+          {
+            model: options.model,
+            messages: openaiMessages,
+            max_tokens: options.max_tokens,
+            stream: true,
+            stream_options: { include_usage: true },
+            ...(options.tools?.length && {
+              tools: options.tools,
+              tool_choice: options.tool_choice ?? "auto",
+            }),
+          },
+          { signal: options.signal }
+        )
+        .withResponse();
+    } catch (error) {
+      this.emitErrorMetadata(options, error);
+      throw error;
+    }
+    const { data: stream, response: nativeResponse, request_id } = result;
+    emitResponseMetadata(options, {
+      statusCode: nativeResponse.status,
+      headers: nativeResponse.headers,
+      requestId: request_id,
+    });
+
+    let usage: CompletionResponse["usage"] | undefined;
     for await (const chunk of stream) {
       const delta = chunk.choices[0]?.delta?.content;
       if (delta) {
@@ -317,7 +401,10 @@ export class GenericOpenAiClient implements GenericClient {
       }
     }
     const usdCost = usage
-      ? this.calculateCost(options.model, usage as OpenAI.ChatCompletion["usage"])
+      ? this.calculateCost(
+          options.model,
+          usage as OpenAI.ChatCompletion["usage"]
+        )
       : undefined;
     yield { done: true, usage, usd_cost: usdCost };
   }
@@ -345,18 +432,27 @@ export class GenericOpenAiClient implements GenericClient {
       let inString = false;
       let escaped = false;
       for (const ch of repaired) {
-        if (escaped) { escaped = false; continue; }
-        if (ch === '\\' && inString) { escaped = true; continue; }
-        if (ch === '"') { inString = !inString; continue; }
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\" && inString) {
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          inString = !inString;
+          continue;
+        }
         if (!inString) {
-          if (ch === '{' || ch === '[') depth++;
-          else if (ch === '}' || ch === ']') depth--;
+          if (ch === "{" || ch === "[") depth++;
+          else if (ch === "}" || ch === "]") depth--;
         }
       }
       // If we're inside a string, close it
       if (inString) repaired += '"';
       // Close any open objects/arrays
-      for (let i = 0; i < depth; i++) repaired += '}';
+      for (let i = 0; i < depth; i++) repaired += "}";
       try {
         JSON.parse(repaired);
         return repaired;
@@ -374,7 +470,11 @@ export class GenericOpenAiClient implements GenericClient {
    */
   private getReasoningItems(msg: any): any[] {
     const details = (msg as any)._reasoning_details;
-    if (details && details.provider === "openai" && Array.isArray(details.items)) {
+    if (
+      details &&
+      details.provider === "openai" &&
+      Array.isArray(details.items)
+    ) {
       return details.items;
     }
     return (msg as any)._reasoning_items ?? [];
@@ -384,16 +484,15 @@ export class GenericOpenAiClient implements GenericClient {
     options: CompletionOptions
   ): Promise<CompletionResponse> {
     // Extract system message to use as instructions
-    const systemMessages = options.messages.filter(
-      (m) => m.role === "system"
-    );
+    const systemMessages = options.messages.filter((m) => m.role === "system");
     const nonSystemMessages = options.messages.filter(
       (m) => m.role !== "system"
     );
-    const instructions = systemMessages
-      .map((m) => (typeof m.content === "string" ? m.content : ""))
-      .join("\n")
-      .trim() || undefined;
+    const instructions =
+      systemMessages
+        .map((m) => (typeof m.content === "string" ? m.content : ""))
+        .join("\n")
+        .trim() || undefined;
 
     // Convert chat messages to Responses API input items
     // The Responses API accepts: user/assistant/system messages and function_call_output items
@@ -401,66 +500,71 @@ export class GenericOpenAiClient implements GenericClient {
     const MAX_TOOL_OUTPUT = 10_485_000;
     const truncateToolOutput = (s: string) =>
       s.length > MAX_TOOL_OUTPUT
-        ? s.slice(0, MAX_TOOL_OUTPUT) + "\n\n[TRUNCATED: output exceeded 10MB API limit]"
+        ? s.slice(0, MAX_TOOL_OUTPUT) +
+          "\n\n[TRUNCATED: output exceeded 10MB API limit]"
         : s;
-    const input: any[] = nonSystemMessages.map((msg) => {
-      if (msg.role === "tool") {
-        // OpenAI function outputs cannot directly contain image content. Send
-        // the required function output, then attach images as a user message.
-        const parts = Array.isArray(msg.content) ? msg.content : [];
-        const imageParts = parts.filter((part) => part.type === "image_url");
-        const text = parts
-          .filter((part) => part.type === "text")
-          .map((part: any) => part.text)
-          .join("\n");
-        const toolOutput = {
-          type: "function_call_output",
-          call_id: msg.tool_call_id,
-          output: truncateToolOutput(typeof msg.content === "string"
-            ? msg.content
-            : text || "Image output attached in the following user message."),
+    const input: any[] = nonSystemMessages
+      .map((msg) => {
+        if (msg.role === "tool") {
+          // OpenAI function outputs cannot directly contain image content. Send
+          // the required function output, then attach images as a user message.
+          const parts = Array.isArray(msg.content) ? msg.content : [];
+          const imageParts = parts.filter((part) => part.type === "image_url");
+          const text = parts
+            .filter((part) => part.type === "text")
+            .map((part: any) => part.text)
+            .join("\n");
+          const toolOutput = {
+            type: "function_call_output",
+            call_id: msg.tool_call_id,
+            output: truncateToolOutput(
+              typeof msg.content === "string"
+                ? msg.content
+                : text || "Image output attached in the following user message."
+            ),
+          };
+          if (!imageParts.length) return toolOutput;
+          return [
+            toolOutput,
+            { role: "user", content: this.toResponseContent(imageParts) },
+          ];
+        }
+        if (msg.role === "assistant" && msg.tool_calls?.length) {
+          // assistant message with tool calls → function_call items.
+          // If the prior turn captured reasoning items (encrypted_content path),
+          // re-inject them *before* the function_call items so the model keeps its
+          // chain-of-thought instead of re-deriving it from scratch.
+          const reasoningItems = this.getReasoningItems(msg);
+          return [
+            ...reasoningItems,
+            ...msg.tool_calls.map((tc) => ({
+              type: "function_call",
+              // id must start with 'fc_'; call_id is the original call_ ID used for function_call_output matching
+              id: tc.id.startsWith("fc") ? tc.id : `fc_${tc.id}`,
+              call_id: tc.id,
+              name: tc.function.name,
+              arguments: tc.function.arguments,
+            })),
+          ];
+        }
+        if (msg.role === "assistant" && this.getReasoningItems(msg).length) {
+          // assistant message (no tool calls) that carried reasoning items →
+          // re-inject reasoning items, then the visible message content.
+          return [
+            ...this.getReasoningItems(msg),
+            {
+              role: msg.role,
+              content: this.toResponseContent(msg.content),
+            },
+          ];
+        }
+        // Regular user/assistant message
+        return {
+          role: msg.role,
+          content: this.toResponseContent(msg.content),
         };
-        if (!imageParts.length) return toolOutput;
-        return [
-          toolOutput,
-          { role: "user", content: this.toResponseContent(imageParts) },
-        ];
-      }
-      if (msg.role === "assistant" && msg.tool_calls?.length) {
-        // assistant message with tool calls → function_call items.
-        // If the prior turn captured reasoning items (encrypted_content path),
-        // re-inject them *before* the function_call items so the model keeps its
-        // chain-of-thought instead of re-deriving it from scratch.
-        const reasoningItems = this.getReasoningItems(msg);
-        return [
-          ...reasoningItems,
-          ...msg.tool_calls.map((tc) => ({
-          type: "function_call",
-          // id must start with 'fc_'; call_id is the original call_ ID used for function_call_output matching
-          id: tc.id.startsWith("fc") ? tc.id : `fc_${tc.id}`,
-          call_id: tc.id,
-          name: tc.function.name,
-          arguments: tc.function.arguments,
-          })),
-        ];
-      }
-      if (msg.role === "assistant" && this.getReasoningItems(msg).length) {
-        // assistant message (no tool calls) that carried reasoning items →
-        // re-inject reasoning items, then the visible message content.
-        return [
-          ...this.getReasoningItems(msg),
-          {
-            role: msg.role,
-            content: this.toResponseContent(msg.content),
-          },
-        ];
-      }
-      // Regular user/assistant message
-      return {
-        role: msg.role,
-        content: this.toResponseContent(msg.content),
-      };
-    }).flat();
+      })
+      .flat();
 
     // Convert Chat Completions tool definitions to Responses API FunctionTool format
     const tools = options.tools?.map((tool) => ({
@@ -481,38 +585,53 @@ export class GenericOpenAiClient implements GenericClient {
       OpenAiReasoningModels.includes(options.model) &&
       !this.isReasoningDisabled(options);
 
-    const response = await this.client.responses.create({
-      model: options.model as any,
-      input,
-      ...(instructions && { instructions }),
-      ...(store && { store: true }),
-      ...(!store && { store: false }),
-      ...(options.previous_response_id && {
-        previous_response_id: options.previous_response_id,
-      }),
-      // When stateless, request encrypted reasoning so we can re-inject it next turn.
-      ...(!store && wantsReasoning && {
-        include: ["reasoning.encrypted_content"],
-      }),
-      // Don't limit max_output_tokens for Responses API - codex truncates tool call arguments when limited
-      ...(OpenAiReasoningModels.includes(options.model) && {
-        reasoning: {
-          ...(this.isReasoningDisabled(options)
-            ? { effort: "none" }
-            : {
-                effort: this.resolveReasoningEffortForModel(options),
-                ...(options.reasoning_summary && { summary: "auto" }),
-              }),
-        },
-      }),
-      ...(wantsReasoning && {
-        max_output_tokens: Math.max(options.max_tokens || 0, 16000),
-      }),
-      ...(tools?.length && {
-        tools,
-        tool_choice: options.tool_choice ?? "auto",
-      }),
-    } as any);
+    let result;
+    try {
+      result = await this.client.responses
+        .create({
+          model: options.model as any,
+          input,
+          ...(instructions && { instructions }),
+          ...(store && { store: true }),
+          ...(!store && { store: false }),
+          ...(options.previous_response_id && {
+            previous_response_id: options.previous_response_id,
+          }),
+          // When stateless, request encrypted reasoning so we can re-inject it next turn.
+          ...(!store &&
+            wantsReasoning && {
+              include: ["reasoning.encrypted_content"],
+            }),
+          // Don't limit max_output_tokens for Responses API - codex truncates tool call arguments when limited
+          ...(OpenAiReasoningModels.includes(options.model) && {
+            reasoning: {
+              ...(this.isReasoningDisabled(options)
+                ? { effort: "none" }
+                : {
+                    effort: this.resolveReasoningEffortForModel(options),
+                    ...(options.reasoning_summary && { summary: "auto" }),
+                  }),
+            },
+          }),
+          ...(wantsReasoning && {
+            max_output_tokens: Math.max(options.max_tokens || 0, 16000),
+          }),
+          ...(tools?.length && {
+            tools,
+            tool_choice: options.tool_choice ?? "auto",
+          }),
+        } as any)
+        .withResponse();
+    } catch (error) {
+      this.emitErrorMetadata(options, error);
+      throw error;
+    }
+    const { data: response, response: nativeResponse, request_id } = result;
+    emitResponseMetadata(options, {
+      statusCode: nativeResponse.status,
+      headers: nativeResponse.headers,
+      requestId: request_id,
+    });
 
     // Map Responses API usage to Chat Completions usage format
     const usage = response.usage
@@ -525,9 +644,11 @@ export class GenericOpenAiClient implements GenericClient {
             cached_tokens:
               response.usage.input_tokens_details?.cached_tokens ?? 0,
           },
-          ...((response.usage as any).output_tokens_details?.reasoning_tokens != null && {
+          ...((response.usage as any).output_tokens_details?.reasoning_tokens !=
+            null && {
             output_tokens_details: {
-              reasoning_tokens: (response.usage as any).output_tokens_details.reasoning_tokens,
+              reasoning_tokens: (response.usage as any).output_tokens_details
+                .reasoning_tokens,
             },
           }),
         }
@@ -574,7 +695,9 @@ export class GenericOpenAiClient implements GenericClient {
         try {
           JSON.parse(repairedArgs);
         } catch (e) {
-          console.warn(`[Responses API] Invalid JSON arguments for ${fc.name} after repair: ${e.message}`);
+          console.warn(
+            `[Responses API] Invalid JSON arguments for ${fc.name} after repair: ${e.message}`
+          );
         }
         toolCalls.push({
           // Store call_id so function_call_output.call_id matches it in subsequent turns
@@ -640,16 +763,25 @@ export class GenericOpenAiClient implements GenericClient {
     };
   }
 
-
   pricesPerMillion() {
     return OpenAiTextPricing;
   }
 
-  getPricing(model?: string): import("./pricing/types").ModelPricing | Record<string, import("./pricing/types").ModelPricing> | undefined {
+  getPricing(
+    model?: string
+  ):
+    | import("./pricing/types").ModelPricing
+    | Record<string, import("./pricing/types").ModelPricing>
+    | undefined {
     if (model !== undefined) {
-      return OpenAiTextPricing[model as keyof typeof OpenAiTextPricing] as import("./pricing/types").ModelPricing | undefined;
+      return OpenAiTextPricing[model as keyof typeof OpenAiTextPricing] as
+        | import("./pricing/types").ModelPricing
+        | undefined;
     }
-    return OpenAiTextPricing as unknown as Record<string, import("./pricing/types").ModelPricing>;
+    return OpenAiTextPricing as unknown as Record<
+      string,
+      import("./pricing/types").ModelPricing
+    >;
   }
 
   calculateCost(
@@ -668,10 +800,12 @@ export class GenericOpenAiClient implements GenericClient {
       ("prompt_tokens_details" in usage &&
         usage.prompt_tokens_details?.cached_tokens) ||
       0;
-    const cachedInputCost = (cachedInputTokens * (pricing.cached_input ?? 0)) / 1e6;
+    const cachedInputCost =
+      (cachedInputTokens * (pricing.cached_input ?? 0)) / 1e6;
 
     const inputTokens = usage.prompt_tokens;
-    const inputCost = ((inputTokens - cachedInputTokens) * (pricing.input ?? 0)) / 1e6;
+    const inputCost =
+      ((inputTokens - cachedInputTokens) * (pricing.input ?? 0)) / 1e6;
 
     const outputTokens =
       ("completion_tokens" in usage && usage?.completion_tokens) || 0;
@@ -684,7 +818,9 @@ export class GenericOpenAiClient implements GenericClient {
   async getModels(modality?: ModelModality): Promise<{ id: string }[]> {
     if (modality) {
       const map: Partial<Record<ModelModality, string[]>> = {
-        completion: [...new Set([...OpenAiChatModels, ...OpenAiResponsesOnlyModels])],
+        completion: [
+          ...new Set([...OpenAiChatModels, ...OpenAiResponsesOnlyModels]),
+        ],
         embedding: OpenAiEmbeddingModelsList,
         image: OpenAiImageModels,
         audio: [...OpenAiTTSModels, ...OpenAiTranscriptionModels],
@@ -701,9 +837,27 @@ export class GenericOpenAiClient implements GenericClient {
   }
 
   async createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse> {
-    const openAiEmbedding = await this.client.embeddings.create({
-      input: options.input,
-      model: options.model,
+    let result;
+    try {
+      result = await this.client.embeddings
+        .create({
+          input: options.input,
+          model: options.model,
+        })
+        .withResponse();
+    } catch (error) {
+      this.emitErrorMetadata(options, error);
+      throw error;
+    }
+    const {
+      data: openAiEmbedding,
+      response: nativeResponse,
+      request_id,
+    } = result;
+    emitResponseMetadata(options, {
+      statusCode: nativeResponse.status,
+      headers: nativeResponse.headers,
+      requestId: request_id,
     });
 
     return {
@@ -724,19 +878,39 @@ export class GenericOpenAiClient implements GenericClient {
       file = await OpenAI.toFile(options.file, fileName);
     }
 
-    const response = await this.client.audio.transcriptions.create({
-      file,
-      model: options.model || "whisper-1",
-      language: options.language,
-      prompt: options.prompt,
-      response_format: options.response_format || "verbose_json",
-      temperature: options.temperature,
-    }, { signal: options.signal });
+    let result;
+    try {
+      result = await this.client.audio.transcriptions
+        .create(
+          {
+            file,
+            model: options.model || "whisper-1",
+            language: options.language,
+            prompt: options.prompt,
+            response_format: options.response_format || "verbose_json",
+            temperature: options.temperature,
+          },
+          { signal: options.signal }
+        )
+        .withResponse();
+    } catch (error) {
+      this.emitErrorMetadata(options, error);
+      throw error;
+    }
+    const { data: response, response: nativeResponse, request_id } = result;
+    emitResponseMetadata(options, {
+      statusCode: nativeResponse.status,
+      headers: nativeResponse.headers,
+      requestId: request_id,
+    });
 
     // Calculate cost: $0.006 per minute for Whisper
-    const duration = typeof response === "object" && "duration" in response && typeof response.duration === "number"
-      ? response.duration
-      : undefined;
+    const duration =
+      typeof response === "object" &&
+      "duration" in response &&
+      typeof response.duration === "number"
+        ? response.duration
+        : undefined;
     const usdCost = duration ? (duration / 60) * 0.006 : undefined;
 
     if (typeof response === "string") {
@@ -761,13 +935,30 @@ export class GenericOpenAiClient implements GenericClient {
   async createAudioGeneration(
     options: AudioGenerationOptions
   ): Promise<AudioGenerationResponse> {
-    const response = await this.client.audio.speech.create({
-      model: options.model,
-      input: options.input,
-      voice: options.voice as any,
-      response_format: options.response_format || "mp3",
-      speed: options.speed,
-    }, { signal: options.signal });
+    let result;
+    try {
+      result = await this.client.audio.speech
+        .create(
+          {
+            model: options.model,
+            input: options.input,
+            voice: options.voice as any,
+            response_format: options.response_format || "mp3",
+            speed: options.speed,
+          },
+          { signal: options.signal }
+        )
+        .withResponse();
+    } catch (error) {
+      this.emitErrorMetadata(options, error);
+      throw error;
+    }
+    const { data: response, response: nativeResponse, request_id } = result;
+    emitResponseMetadata(options, {
+      statusCode: nativeResponse.status,
+      headers: nativeResponse.headers,
+      requestId: request_id,
+    });
 
     const buffer = Buffer.from(await response.arrayBuffer());
 
@@ -787,16 +978,19 @@ export class GenericOpenAiClient implements GenericClient {
   async createImageGeneration(
     options: ImageGenerationOptions
   ): Promise<ImageGenerationResponse> {
-    const response = await this.client.images.generate({
-      model: options.model,
-      prompt: options.prompt,
-      n: options.n,
-      size: options.size,
-      quality: options.quality,
-      style: options.style,
-      response_format: options.response_format,
-      user: options.user,
-    }, { signal: options.signal });
+    const response = await this.client.images.generate(
+      {
+        model: options.model,
+        prompt: options.prompt,
+        n: options.n,
+        size: options.size,
+        quality: options.quality,
+        style: options.style,
+        response_format: options.response_format,
+        user: options.user,
+      },
+      { signal: options.signal }
+    );
 
     // Cost calculation varies by model and settings
     // DALL-E 3: $0.040-$0.120 per image depending on quality/size
@@ -873,16 +1067,23 @@ export class GenericOpenAiClient implements GenericClient {
     };
   }
 
-  async getVideoStatus(options: VideoStatusOptions): Promise<VideoStatusResponse> {
+  async getVideoStatus(
+    options: VideoStatusOptions
+  ): Promise<VideoStatusResponse> {
     const apiKey = this.apiKey || process.env.OPENAI_KEY;
     if (!apiKey) throw new Error("OpenAI API key not set");
-    const response = await fetch(`https://api.openai.com/v1/videos/${options.jobId}`, {
-      method: "GET",
-      headers: { Authorization: `Bearer ${apiKey}` },
-    });
+    const response = await fetch(
+      `https://api.openai.com/v1/videos/${options.jobId}`,
+      {
+        method: "GET",
+        headers: { Authorization: `Bearer ${apiKey}` },
+      }
+    );
     if (!response.ok) {
       const errorText = await response.text();
-      throw new Error(`OpenAI getVideoStatus failed: ${response.status} ${errorText}`);
+      throw new Error(
+        `OpenAI getVideoStatus failed: ${response.status} ${errorText}`
+      );
     }
     const data = await response.json();
     let status: VideoStatusResponse["status"] = "in_progress";
@@ -898,18 +1099,25 @@ export class GenericOpenAiClient implements GenericClient {
     };
   }
 
-  async downloadVideo(options: FileDownloadOptions): Promise<FileDownloadResponse> {
+  async downloadVideo(
+    options: FileDownloadOptions
+  ): Promise<FileDownloadResponse> {
     const apiKey = this.apiKey || process.env.OPENAI_KEY;
     if (!apiKey) throw new Error("OpenAI API key not set");
     const fileId = options.fileId;
     if (!fileId) throw new Error("downloadVideo requires fileId (the jobId)");
-    const response = await fetch(`https://api.openai.com/v1/videos/${fileId}/content`, {
-      method: "GET",
-      headers: { Authorization: `Bearer ${apiKey}` },
-    });
+    const response = await fetch(
+      `https://api.openai.com/v1/videos/${fileId}/content`,
+      {
+        method: "GET",
+        headers: { Authorization: `Bearer ${apiKey}` },
+      }
+    );
     if (!response.ok) {
       const errorText = await response.text();
-      throw new Error(`OpenAI downloadVideo failed: ${response.status} ${errorText}`);
+      throw new Error(
+        `OpenAI downloadVideo failed: ${response.status} ${errorText}`
+      );
     }
     const mimeType = response.headers.get("content-type") || "video/mp4";
     return { data: Buffer.from(await response.arrayBuffer()), mimeType };
@@ -920,7 +1128,9 @@ export class GenericOpenAiClient implements GenericClient {
     if (!apiKey) throw new Error("OpenAI API key not set");
     const formData = new FormData();
     formData.append("purpose", "assistants");
-    const blob = new Blob([new Uint8Array(options.data)], { type: options.mimeType || "application/octet-stream" });
+    const blob = new Blob([new Uint8Array(options.data)], {
+      type: options.mimeType || "application/octet-stream",
+    });
     formData.append("file", blob, options.fileName || "upload");
     const response = await fetch("https://api.openai.com/v1/files", {
       method: "POST",
@@ -929,31 +1139,42 @@ export class GenericOpenAiClient implements GenericClient {
     });
     if (!response.ok) {
       const errorText = await response.text();
-      throw new Error(`OpenAI uploadFile failed: ${response.status} ${errorText}`);
+      throw new Error(
+        `OpenAI uploadFile failed: ${response.status} ${errorText}`
+      );
     }
     const data = await response.json();
     return { fileId: data.id, uri: data.uri };
   }
 
-  async downloadFile(options: FileDownloadOptions): Promise<FileDownloadResponse> {
+  async downloadFile(
+    options: FileDownloadOptions
+  ): Promise<FileDownloadResponse> {
     const apiKey = this.apiKey || process.env.OPENAI_KEY;
     if (!apiKey) throw new Error("OpenAI API key not set");
     const fileId = options.fileId;
     if (!fileId) throw new Error("downloadFile requires fileId");
-    const response = await fetch(`https://api.openai.com/v1/files/${fileId}/content`, {
-      method: "GET",
-      headers: { Authorization: `Bearer ${apiKey}` },
-    });
+    const response = await fetch(
+      `https://api.openai.com/v1/files/${fileId}/content`,
+      {
+        method: "GET",
+        headers: { Authorization: `Bearer ${apiKey}` },
+      }
+    );
     if (!response.ok) {
       const errorText = await response.text();
-      throw new Error(`OpenAI downloadFile failed: ${response.status} ${errorText}`);
+      throw new Error(
+        `OpenAI downloadFile failed: ${response.status} ${errorText}`
+      );
     }
     const mimeType = response.headers.get("content-type") || undefined;
     const data = Buffer.from(await response.arrayBuffer());
     return { data, mimeType };
   }
 
-  getContextLimit(model: string): { contextLimit: number; threshold: number } | undefined {
+  getContextLimit(
+    model: string
+  ): { contextLimit: number; threshold: number } | undefined {
     const contextLimit = ContextLimits[model];
     if (contextLimit === undefined) return undefined;
     const pricing = OpenAiTextPricing[model];