fix: external aisdk client logging (#1143)

# why
- there was previously no logger parameter in the external aisdk client
# what changed
- added logger param
# test plan
- evals, 
- install from alpha & smoke test

---------

Co-authored-by: Miguel <[email protected]>

Author: seanmcguire12

.changeset/cuddly-owls-battle.md

@@ -0,0 +1,5 @@
+---
+"@browserbasehq/stagehand": patch
+---
+
+add logger param to external aisdk client

examples/external_clients/aisdk.ts

@@ -2,33 +2,128 @@ import {
   CoreAssistantMessage,
   CoreMessage,
   CoreSystemMessage,
-  CoreTool,
   CoreUserMessage,
   generateObject,
   generateText,
   ImagePart,
   LanguageModel,
+  NoObjectGeneratedError,
   TextPart,
+  ToolSet,
 } from "ai";
 import {
   CreateChatCompletionOptions,
   LLMClient,
   AvailableModel,
 } from "@browserbasehq/stagehand";
 import { ChatCompletion } from "openai/resources";
+import { LogLine } from "@/types/log";
+import { LLMCache } from "@/lib/cache/LLMCache";
 
 export class AISdkClient extends LLMClient {
   public type = "aisdk" as const;
   private model: LanguageModel;
+  private logger?: (message: LogLine) => void;
+  private cache: LLMCache | undefined;
+  private enableCaching: boolean;
 
-  constructor({ model }: { model: LanguageModel }) {
+  constructor({
+    model,
+    logger,
+    enableCaching = false,
+    cache,
+  }: {
+    model: LanguageModel;
+    logger?: (message: LogLine) => void;
+    enableCaching?: boolean;
+    cache?: LLMCache;
+  }) {
     super(model.modelId as AvailableModel);
     this.model = model;
+    this.logger = logger;
+    this.cache = cache;
+    this.enableCaching = enableCaching;
+  }
+
+  public getLanguageModel(): LanguageModel {
+    return this.model;
   }
 
   async createChatCompletion<T = ChatCompletion>({
     options,
   }: CreateChatCompletionOptions): Promise<T> {
+    this.logger?.({
+      category: "aisdk",
+      message: "creating chat completion",
+      level: 2,
+      auxiliary: {
+        options: {
+          value: JSON.stringify({
+            ...options,
+            image: undefined,
+            messages: options.messages.map((msg) => ({
+              ...msg,
+              content: Array.isArray(msg.content)
+                ? msg.content.map((c) =>
+                    "image_url" in c
+                      ? { ...c, image_url: { url: "[IMAGE_REDACTED]" } }
+                      : c,
+                  )
+                : msg.content,
+            })),
+          }),
+          type: "object",
+        },
+        modelName: {
+          value: this.model.modelId,
+          type: "string",
+        },
+      },
+    });
+
+    const cacheOptions = {
+      model: this.model.modelId,
+      messages: options.messages,
+      response_model: options.response_model,
+    };
+
+    if (this.enableCaching && this.cache) {
+      const cachedResponse = await this.cache.get<T>(
+        cacheOptions,
+        options.requestId,
+      );
+      if (cachedResponse) {
+        this.logger?.({
+          category: "llm_cache",
+          message: "LLM cache hit - returning cached response",
+          level: 1,
+          auxiliary: {
+            requestId: {
+              value: options.requestId,
+              type: "string",
+            },
+            cachedResponse: {
+              value: JSON.stringify(cachedResponse),
+              type: "object",
+            },
+          },
+        });
+        return cachedResponse;
+      } else {
+        this.logger?.({
+          category: "llm_cache",
+          message: "LLM cache miss - no cached response found",
+          level: 1,
+          auxiliary: {
+            requestId: {
+              value: options.requestId,
+              type: "string",
+            },
+          },
+        });
+      }
+    }
+
     const formattedMessages: CoreMessage[] = options.messages.map((message) => {
       if (Array.isArray(message.content)) {
         if (message.role === "system") {
@@ -82,45 +177,215 @@ export class AISdkClient extends LLMClient {
       };
     });
 
+    let objectResponse: Awaited<ReturnType<typeof generateObject>>;
+    const isGPT5 = this.model.modelId.includes("gpt-5");
     if (options.response_model) {
-      const response = await generateObject({
-        model: this.model,
-        messages: formattedMessages,
-        schema: options.response_model.schema,
-      });
+      try {
+        objectResponse = await generateObject({
+          model: this.model,
+          messages: formattedMessages,
+          schema: options.response_model.schema,
+          temperature: options.temperature,
+          providerOptions: isGPT5
+            ? {
+                openai: {
+                  textVerbosity: "low", // Making these the default for gpt-5 for now
+                  reasoningEffort: "minimal",
+                },
+              }
+            : undefined,
+        });
+      } catch (err) {
+        if (NoObjectGeneratedError.isInstance(err)) {
+          this.logger?.({
+            category: "AISDK error",
+            message: err.message,
+            level: 0,
+            auxiliary: {
+              cause: {
+                value: JSON.stringify(err.cause ?? {}),
+                type: "object",
+              },
+              text: {
+                value: err.text ?? "",
+                type: "string",
+              },
+              response: {
+                value: JSON.stringify(err.response ?? {}),
+                type: "object",
+              },
+              usage: {
+                value: JSON.stringify(err.usage ?? {}),
+                type: "object",
+              },
+              finishReason: {
+                value: err.finishReason ?? "unknown",
+                type: "string",
+              },
+              requestId: {
+                value: options.requestId,
+                type: "string",
+              },
+            },
+          });
 
-      return {
-        data: response.object,
+          throw err;
+        }
+        throw err;
+      }
+
+      const result = {
+        data: objectResponse.object,
         usage: {
-          prompt_tokens: response.usage.promptTokens ?? 0,
-          completion_tokens: response.usage.completionTokens ?? 0,
-          total_tokens: response.usage.totalTokens ?? 0,
+          prompt_tokens: objectResponse.usage.promptTokens ?? 0,
+          completion_tokens: objectResponse.usage.completionTokens ?? 0,
+          total_tokens: objectResponse.usage.totalTokens ?? 0,
         },
       } as T;
-    }
 
-    const tools: Record<string, CoreTool> = {};
+      if (this.enableCaching) {
+        this.logger?.({
+          category: "llm_cache",
+          message: "caching response",
+          level: 1,
+          auxiliary: {
+            requestId: {
+              value: options.requestId,
+              type: "string",
+            },
+            cacheOptions: {
+              value: JSON.stringify({
+                ...cacheOptions,
+                messages: cacheOptions.messages.map((msg) => ({
+                  ...msg,
+                  content: Array.isArray(msg.content)
+                    ? msg.content.map((c) =>
+                        "image_url" in c
+                          ? { ...c, image_url: { url: "[IMAGE_REDACTED]" } }
+                          : c,
+                      )
+                    : msg.content,
+                })),
+              }),
+              type: "object",
+            },
+            response: {
+              value: JSON.stringify(result),
+              type: "object",
+            },
+          },
+        });
+        this.cache.set(cacheOptions, result, options.requestId);
+      }
 
-    for (const rawTool of options.tools) {
-      tools[rawTool.name] = {
-        description: rawTool.description,
-        parameters: rawTool.parameters,
-      };
+      this.logger?.({
+        category: "aisdk",
+        message: "response",
+        level: 1,
+        auxiliary: {
+          response: {
+            value: JSON.stringify({
+              object: objectResponse.object,
+              usage: objectResponse.usage,
+              finishReason: objectResponse.finishReason,
+              // Omit request and response properties that might contain images
+            }),
+            type: "object",
+          },
+          requestId: {
+            value: options.requestId,
+            type: "string",
+          },
+        },
+      });
+
+      return result;
     }
 
-    const response = await generateText({
+    const tools: ToolSet = {};
+    if (options.tools && options.tools.length > 0) {
+      for (const tool of options.tools) {
+        tools[tool.name] = {
+          description: tool.description,
+          parameters: tool.parameters,
+        };
+      }
+    }
+
+    const textResponse = await generateText({
       model: this.model,
       messages: formattedMessages,
-      tools,
+      tools: Object.keys(tools).length > 0 ? tools : undefined,
+      toolChoice:
+        Object.keys(tools).length > 0
+          ? options.tool_choice === "required"
+            ? "required"
+            : options.tool_choice === "none"
+              ? "none"
+              : "auto"
+          : undefined,
+      temperature: options.temperature,
     });
 
-    return {
-      data: response.text,
+    // Transform AI SDK response to match LLMResponse format expected by operator handler
+    const transformedToolCalls = (textResponse.toolCalls || []).map(
+      (toolCall) => ({
+        id:
+          toolCall.toolCallId ||
+          `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        type: "function",
+        function: {
+          name: toolCall.toolName,
+          arguments: JSON.stringify(toolCall.args),
+        },
+      }),
+    );
+
+    const result = {
+      id: `chatcmpl_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1000),
+      model: this.model.modelId,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: textResponse.text || null,
+            tool_calls: transformedToolCalls,
+          },
+          finish_reason: textResponse.finishReason || "stop",
+        },
+      ],
       usage: {
-        prompt_tokens: response.usage.promptTokens ?? 0,
-        completion_tokens: response.usage.completionTokens ?? 0,
-        total_tokens: response.usage.totalTokens ?? 0,
+        prompt_tokens: textResponse.usage.promptTokens ?? 0,
+        completion_tokens: textResponse.usage.completionTokens ?? 0,
+        total_tokens: textResponse.usage.totalTokens ?? 0,
       },
     } as T;
+
+
+    this.logger?.({
+      category: "aisdk",
+      message: "response",
+      level: 2,
+      auxiliary: {
+        response: {
+          value: JSON.stringify({
+            text: textResponse.text,
+            usage: textResponse.usage,
+            finishReason: textResponse.finishReason,
+            // Omit request and response properties that might contain images
+          }),
+          type: "object",
+        },
+        requestId: {
+          value: options.requestId,
+          type: "string",
+        },
+      },
+    });
+
+    return result;
   }
 }