@iqai/adk 0.1.19 → 0.1.20

package/dist/index.mjs

@@ -1362,261 +1362,317 @@ var BaseLlm = class {
 var BaseLLMConnection = class {
 };
 
-// src/models/google-llm.ts
+// src/models/ai-sdk.ts
+init_logger();
 import {
-  FinishReason,
-  GoogleGenAI
-} from "@google/genai";
-var AGENT_ENGINE_TELEMETRY_TAG = "remote_reasoning_engine";
-var AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME = "GOOGLE_CLOUD_AGENT_ENGINE_ID";
-var GoogleLlm = class extends BaseLlm {
-  _apiClient;
-  _liveApiClient;
-  _apiBackend;
-  _trackingHeaders;
+  generateText,
+  jsonSchema,
+  streamText
+} from "ai";
+var AiSdkLlm = class extends BaseLlm {
+  modelInstance;
+  logger = new Logger({ name: "AiSdkLlm" });
   /**
-   * Constructor for Gemini
+   * Constructor accepts a pre-configured LanguageModel instance
+   * @param model - Pre-configured LanguageModel from provider(modelName)
    */
-  constructor(model = "gemini-1.5-flash") {
-    super(model);
+  constructor(modelInstance) {
+    super(modelInstance.modelId || "ai-sdk-model");
+    this.modelInstance = modelInstance;
   }
   /**
-   * Provides the list of supported models.
+   * Returns empty array - following Python ADK pattern
    */
   static supportedModels() {
-    return [
-      "gemini-.*",
-      // fine-tuned vertex endpoint pattern
-      "projects/.+/locations/.+/endpoints/.+",
-      // vertex gemini long name
-      "projects/.+/locations/.+/publishers/google/models/gemini.+"
-    ];
+    return [];
   }
-  /**
-   * Main content generation method - handles both streaming and non-streaming
-   */
-  async *generateContentAsyncImpl(llmRequest, stream = false) {
-    this.preprocessRequest(llmRequest);
-    const model = llmRequest.model || this.model;
-    const contents = this.convertContents(llmRequest.contents || []);
-    const config = llmRequest.config;
-    if (stream) {
-      const responses = await this.apiClient.models.generateContentStream({
-        model,
-        contents,
-        config
-      });
-      let response = null;
-      let thoughtText = "";
-      let text = "";
-      let usageMetadata = null;
-      for await (const resp of responses) {
-        response = resp;
-        const llmResponse = LlmResponse.create(resp);
-        usageMetadata = llmResponse.usageMetadata;
-        if (llmResponse.content?.parts?.[0]?.text) {
-          const part0 = llmResponse.content.parts[0];
-          if (part0.thought) {
-            thoughtText += part0.text;
-          } else {
-            text += part0.text;
-          }
-          llmResponse.partial = true;
-        } else if ((thoughtText || text) && (!llmResponse.content || !llmResponse.content.parts || !this.hasInlineData(resp))) {
-          const parts = [];
-          if (thoughtText) {
-            parts.push({ text: thoughtText, thought: true });
-          }
-          if (text) {
-            parts.push({ text });
-          }
+  async *generateContentAsyncImpl(request, stream = false) {
+    try {
+      const messages = this.convertToAiSdkMessages(request);
+      const systemMessage = request.getSystemInstructionText();
+      const tools = this.convertToAiSdkTools(request);
+      const requestParams = {
+        model: this.modelInstance,
+        messages,
+        system: systemMessage,
+        tools: Object.keys(tools).length > 0 ? tools : void 0,
+        maxTokens: request.config?.maxOutputTokens,
+        temperature: request.config?.temperature,
+        topP: request.config?.topP
+      };
+      if (stream) {
+        const result = streamText(requestParams);
+        let accumulatedText = "";
+        for await (const delta of result.textStream) {
+          accumulatedText += delta;
           yield new LlmResponse({
             content: {
-              parts,
-              role: "model"
+              role: "model",
+              parts: [{ text: accumulatedText }]
             },
-            usageMetadata
+            partial: true
           });
-          thoughtText = "";
-          text = "";
         }
-        yield llmResponse;
-      }
-      if ((text || thoughtText) && response && response.candidates && response.candidates[0]?.finishReason === FinishReason.STOP) {
+        const toolCalls = await result.toolCalls;
         const parts = [];
-        if (thoughtText) {
-          parts.push({ text: thoughtText, thought: true });
+        if (accumulatedText) {
+          parts.push({ text: accumulatedText });
         }
-        if (text) {
-          parts.push({ text });
+        if (toolCalls && toolCalls.length > 0) {
+          for (const toolCall of toolCalls) {
+            parts.push({
+              functionCall: {
+                id: toolCall.toolCallId,
+                name: toolCall.toolName,
+                args: toolCall.args
+              }
+            });
+          }
         }
+        const finalUsage = await result.usage;
+        const finishReason = await result.finishReason;
         yield new LlmResponse({
           content: {
-            parts,
-            role: "model"
+            role: "model",
+            parts: parts.length > 0 ? parts : [{ text: "" }]
           },
-          usageMetadata
+          usageMetadata: finalUsage ? {
+            promptTokenCount: finalUsage.promptTokens,
+            candidatesTokenCount: finalUsage.completionTokens,
+            totalTokenCount: finalUsage.totalTokens
+          } : void 0,
+          finishReason: this.mapFinishReason(finishReason),
+          turnComplete: true
+        });
+      } else {
+        const result = await generateText(requestParams);
+        const parts = [];
+        if (result.text) {
+          parts.push({ text: result.text });
+        }
+        if (result.toolCalls && result.toolCalls.length > 0) {
+          for (const toolCall of result.toolCalls) {
+            parts.push({
+              functionCall: {
+                id: toolCall.toolCallId,
+                name: toolCall.toolName,
+                args: toolCall.args
+              }
+            });
+          }
+        }
+        yield new LlmResponse({
+          content: {
+            role: "model",
+            parts: parts.length > 0 ? parts : [{ text: "" }]
+          },
+          usageMetadata: result.usage ? {
+            promptTokenCount: result.usage.promptTokens,
+            candidatesTokenCount: result.usage.completionTokens,
+            totalTokenCount: result.usage.totalTokens
+          } : void 0,
+          finishReason: this.mapFinishReason(result.finishReason),
+          turnComplete: true
         });
       }
-    } else {
-      const response = await this.apiClient.models.generateContent({
-        model,
-        contents,
-        config
+    } catch (error) {
+      this.logger.error(`AI SDK Error: ${String(error)}`, { error, request });
+      yield LlmResponse.fromError(error, {
+        errorCode: "AI_SDK_ERROR",
+        model: this.model
       });
-      const llmResponse = LlmResponse.create(response);
-      this.logger.debug(
-        `Google response: ${llmResponse.usageMetadata?.candidatesTokenCount || 0} tokens`
-      );
-      yield llmResponse;
     }
   }
   /**
-   * Connects to the Gemini model and returns an llm connection.
-   */
-  connect(_llmRequest) {
-    throw new Error(`Live connection is not supported for ${this.model}.`);
-  }
-  /**
-   * Check if response has inline data
+   * Convert ADK LlmRequest to AI SDK CoreMessage format
    */
-  hasInlineData(response) {
-    const parts = response.candidates?.[0]?.content?.parts;
-    return parts?.some((part) => part?.inlineData) || false;
+  convertToAiSdkMessages(llmRequest) {
+    const messages = [];
+    for (const content of llmRequest.contents || []) {
+      const message = this.contentToAiSdkMessage(content);
+      if (message) {
+        messages.push(message);
+      }
+    }
+    return messages;
   }
   /**
-   * Convert LlmRequest contents to GoogleGenAI format
+   * Transform JSON schema to use lowercase types for AI SDK compatibility
    */
-  convertContents(contents) {
-    return contents.map((content) => ({
-      role: content.role === "assistant" ? "model" : content.role,
-      parts: content.parts || [{ text: content.content || "" }]
-    }));
+  transformSchemaForAiSdk(schema) {
+    if (Array.isArray(schema)) {
+      return schema.map((item) => this.transformSchemaForAiSdk(item));
+    }
+    if (!schema || typeof schema !== "object") {
+      return schema;
+    }
+    const transformedSchema = { ...schema };
+    if (transformedSchema.type && typeof transformedSchema.type === "string") {
+      transformedSchema.type = transformedSchema.type.toLowerCase();
+    }
+    if (transformedSchema.properties) {
+      transformedSchema.properties = Object.fromEntries(
+        Object.entries(transformedSchema.properties).map(([key, value]) => [
+          key,
+          this.transformSchemaForAiSdk(value)
+        ])
+      );
+    }
+    if (transformedSchema.items) {
+      transformedSchema.items = this.transformSchemaForAiSdk(
+        transformedSchema.items
+      );
+    }
+    const arrayKeywords = ["anyOf", "oneOf", "allOf"];
+    for (const keyword of arrayKeywords) {
+      if (transformedSchema[keyword]) {
+        transformedSchema[keyword] = this.transformSchemaForAiSdk(
+          transformedSchema[keyword]
+        );
+      }
+    }
+    return transformedSchema;
   }
   /**
-   * Preprocesses the request based on the API backend.
+   * Convert ADK tools to AI SDK tools format
    */
-  preprocessRequest(llmRequest) {
-    if (this.apiBackend === "GEMINI_API" /* GEMINI_API */) {
-      if (llmRequest.config) {
-        llmRequest.config.labels = void 0;
-      }
-      if (llmRequest.contents) {
-        for (const content of llmRequest.contents) {
-          if (!content.parts) continue;
-          for (const part of content.parts) {
-            this.removeDisplayNameIfPresent(part.inlineData);
-            this.removeDisplayNameIfPresent(part.fileData);
+  convertToAiSdkTools(llmRequest) {
+    const tools = {};
+    if (llmRequest.config?.tools) {
+      for (const toolConfig of llmRequest.config.tools) {
+        if ("functionDeclarations" in toolConfig) {
+          for (const funcDecl of toolConfig.functionDeclarations) {
+            tools[funcDecl.name] = {
+              description: funcDecl.description,
+              parameters: jsonSchema(
+                this.transformSchemaForAiSdk(funcDecl.parameters || {})
+              )
+            };
           }
         }
       }
     }
+    return tools;
   }
   /**
-   * Sets display_name to null for the Gemini API (non-Vertex) backend.
+   * Convert ADK Content to AI SDK CoreMessage
    */
-  removeDisplayNameIfPresent(dataObj) {
-    if (dataObj?.displayName) {
-      dataObj.displayName = null;
+  contentToAiSdkMessage(content) {
+    const role = this.mapRole(content.role);
+    if (!content.parts || content.parts.length === 0) {
+      return null;
     }
-  }
-  /**
-   * Builds function declaration log string.
-   */
-  buildFunctionDeclarationLog(funcDecl) {
-    let paramStr = "{}";
-    if (funcDecl.parameters?.properties) {
-      paramStr = JSON.stringify(funcDecl.parameters.properties);
+    if (content.parts.length === 1 && content.parts[0].text) {
+      const textContent = content.parts[0].text;
+      if (role === "system") {
+        return { role: "system", content: textContent };
+      }
+      if (role === "assistant") {
+        return { role: "assistant", content: textContent };
+      }
+      return { role: "user", content: textContent };
     }
-    return `${funcDecl.name}: ${paramStr}`;
-  }
-  /**
-   * Provides the api client.
-   */
-  get apiClient() {
-    if (!this._apiClient) {
-      const useVertexAI = process.env.GOOGLE_GENAI_USE_VERTEXAI === "true";
-      const apiKey = process.env.GOOGLE_API_KEY;
-      const project = process.env.GOOGLE_CLOUD_PROJECT;
-      const location = process.env.GOOGLE_CLOUD_LOCATION;
-      if (useVertexAI && project && location) {
-        this._apiClient = new GoogleGenAI({
-          vertexai: true,
-          project,
-          location
-        });
-      } else if (apiKey) {
-        this._apiClient = new GoogleGenAI({
-          apiKey
+    if (content.parts?.some((part) => part.functionCall)) {
+      const textParts = content.parts.filter((part) => part.text);
+      const functionCalls = content.parts.filter((part) => part.functionCall);
+      const contentParts2 = [];
+      for (const textPart of textParts) {
+        if (textPart.text) {
+          contentParts2.push({
+            type: "text",
+            text: textPart.text
+          });
+        }
+      }
+      for (const funcPart of functionCalls) {
+        if (funcPart.functionCall) {
+          contentParts2.push({
+            type: "tool-call",
+            toolCallId: funcPart.functionCall.id,
+            toolName: funcPart.functionCall.name,
+            args: funcPart.functionCall.args
+          });
+        }
+      }
+      return {
+        role: "assistant",
+        content: contentParts2
+      };
+    }
+    if (content.parts?.some((part) => part.functionResponse)) {
+      const functionResponses = content.parts.filter(
+        (part) => part.functionResponse
+      );
+      const contentParts2 = functionResponses.map((part) => ({
+        type: "tool-result",
+        toolCallId: part.functionResponse.id,
+        toolName: part.functionResponse.name || "unknown",
+        result: part.functionResponse.response
+      }));
+      return {
+        role: "tool",
+        content: contentParts2
+      };
+    }
+    const contentParts = [];
+    for (const part of content.parts) {
+      if (part.text) {
+        contentParts.push({
+          type: "text",
+          text: part.text
         });
-      } else {
-        throw new Error(
-          "Google API Key or Vertex AI configuration is required. Set GOOGLE_API_KEY or GOOGLE_GENAI_USE_VERTEXAI=true with GOOGLE_CLOUD_PROJECT and GOOGLE_CLOUD_LOCATION."
-        );
       }
     }
-    return this._apiClient;
-  }
-  /**
-   * Gets the API backend type.
-   */
-  get apiBackend() {
-    if (!this._apiBackend) {
-      const useVertexAI = process.env.GOOGLE_GENAI_USE_VERTEXAI === "true";
-      this._apiBackend = useVertexAI ? "VERTEX_AI" /* VERTEX_AI */ : "GEMINI_API" /* GEMINI_API */;
+    if (contentParts.length === 0) {
+      return null;
     }
-    return this._apiBackend;
-  }
-  /**
-   * Gets the tracking headers.
-   */
-  get trackingHeaders() {
-    if (!this._trackingHeaders) {
-      let frameworkLabel = "google-adk/1.0.0";
-      if (process.env[AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME]) {
-        frameworkLabel = `${frameworkLabel}+${AGENT_ENGINE_TELEMETRY_TAG}`;
+    if (contentParts.length === 1) {
+      const textContent = contentParts[0].text;
+      if (role === "system") {
+        return { role: "system", content: textContent };
       }
-      const languageLabel = `gl-node/${process.version}`;
-      const versionHeaderValue = `${frameworkLabel} ${languageLabel}`;
-      this._trackingHeaders = {
-        "x-goog-api-client": versionHeaderValue,
-        "user-agent": versionHeaderValue
-      };
+      if (role === "assistant") {
+        return { role: "assistant", content: textContent };
+      }
+      return { role: "user", content: textContent };
     }
-    return this._trackingHeaders;
+    if (role === "system") {
+      const combinedText = contentParts.map((p) => p.text).join("");
+      return { role: "system", content: combinedText };
+    }
+    if (role === "assistant") {
+      return { role: "assistant", content: contentParts };
+    }
+    return { role: "user", content: contentParts };
   }
   /**
-   * Gets the live API version.
+   * Map ADK role to AI SDK role
    */
-  get liveApiVersion() {
-    return this.apiBackend === "VERTEX_AI" /* VERTEX_AI */ ? "v1beta1" : "v1alpha";
+  mapRole(role) {
+    switch (role) {
+      case "model":
+      case "assistant":
+        return "assistant";
+      case "system":
+        return "system";
+      default:
+        return "user";
+    }
   }
   /**
-   * Gets the live API client.
+   * Map AI SDK finish reason to ADK finish reason
    */
-  get liveApiClient() {
-    if (!this._liveApiClient) {
-      const useVertexAI = process.env.GOOGLE_GENAI_USE_VERTEXAI === "true";
-      const apiKey = process.env.GOOGLE_API_KEY;
-      const project = process.env.GOOGLE_CLOUD_PROJECT;
-      const location = process.env.GOOGLE_CLOUD_LOCATION;
-      if (useVertexAI && project && location) {
-        this._liveApiClient = new GoogleGenAI({
-          vertexai: true,
-          project,
-          location,
-          apiVersion: this.liveApiVersion
-        });
-      } else if (apiKey) {
-        this._liveApiClient = new GoogleGenAI({
-          apiKey,
-          apiVersion: this.liveApiVersion
-        });
-      } else {
-        throw new Error("API configuration required for live client");
-      }
+  mapFinishReason(finishReason) {
+    switch (finishReason) {
+      case "stop":
+      case "end_of_message":
+        return "STOP";
+      case "length":
+      case "max_tokens":
+        return "MAX_TOKENS";
+      default:
+        return "FINISH_REASON_UNSPECIFIED";
     }
-    return this._liveApiClient;
   }
 };
 
@@ -1844,21 +1900,35 @@ var AnthropicLlm = class extends BaseLlm {
   }
 };
 
-// src/models/openai-llm.ts
-import OpenAI from "openai";
-var OpenAiLlm = class extends BaseLlm {
-  _client;
+// src/models/google-llm.ts
+import {
+  FinishReason,
+  GoogleGenAI
+} from "@google/genai";
+var AGENT_ENGINE_TELEMETRY_TAG = "remote_reasoning_engine";
+var AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME = "GOOGLE_CLOUD_AGENT_ENGINE_ID";
+var GoogleLlm = class extends BaseLlm {
+  _apiClient;
+  _liveApiClient;
+  _apiBackend;
+  _trackingHeaders;
   /**
-   * Constructor for OpenAI LLM
+   * Constructor for Gemini
    */
-  constructor(model = "gpt-4o-mini") {
+  constructor(model = "gemini-1.5-flash") {
     super(model);
   }
   /**
-   * Provides the list of supported models
+   * Provides the list of supported models.
    */
   static supportedModels() {
-    return ["gpt-3.5-.*", "gpt-4.*", "gpt-4o.*", "o1-.*", "o3-.*"];
+    return [
+      "gemini-.*",
+      // fine-tuned vertex endpoint pattern
+      "projects/.+/locations/.+/endpoints/.+",
+      // vertex gemini long name
+      "projects/.+/locations/.+/publishers/google/models/gemini.+"
+    ];
   }
   /**
    * Main content generation method - handles both streaming and non-streaming
@@ -1866,59 +1936,31 @@ var OpenAiLlm = class extends BaseLlm {
   async *generateContentAsyncImpl(llmRequest, stream = false) {
     this.preprocessRequest(llmRequest);
     const model = llmRequest.model || this.model;
-    const messages = (llmRequest.contents || []).map(
-      (content) => this.contentToOpenAiMessage(content)
-    );
-    let tools;
-    if (llmRequest.config?.tools?.[0]?.functionDeclarations) {
-      tools = llmRequest.config.tools[0].functionDeclarations.map(
-        (funcDecl) => this.functionDeclarationToOpenAiTool(funcDecl)
-      );
-    }
-    const systemContent = llmRequest.getSystemInstructionText();
-    if (systemContent) {
-      messages.unshift({
-        role: "system",
-        content: systemContent
-      });
-    }
-    const openAiMessages = messages;
-    const requestParams = {
-      model,
-      messages: openAiMessages,
-      tools,
-      tool_choice: tools ? "auto" : void 0,
-      max_tokens: llmRequest.config?.maxOutputTokens,
-      temperature: llmRequest.config?.temperature,
-      top_p: llmRequest.config?.topP,
-      stream
-    };
+    const contents = this.convertContents(llmRequest.contents || []);
+    const config = llmRequest.config;
     if (stream) {
-      const streamResponse = await this.client.chat.completions.create({
-        ...requestParams,
-        stream: true
+      const responses = await this.apiClient.models.generateContentStream({
+        model,
+        contents,
+        config
       });
+      let response = null;
       let thoughtText = "";
       let text = "";
-      let usageMetadata;
-      const accumulatedToolCalls = [];
-      for await (const chunk of streamResponse) {
-        const choice = chunk.choices[0];
-        if (!choice) continue;
-        const delta = choice.delta;
-        const llmResponse = this.createChunkResponse(delta, chunk.usage);
-        if (chunk.usage) {
-          usageMetadata = chunk.usage;
-        }
-        if (llmResponse.content?.parts?.[0]?.text) {
-          const part0 = llmResponse.content.parts[0];
-          if (part0.thought) {
+      let usageMetadata = null;
+      for await (const resp of responses) {
+        response = resp;
+        const llmResponse = LlmResponse.create(resp);
+        usageMetadata = llmResponse.usageMetadata;
+        if (llmResponse.content?.parts?.[0]?.text) {
+          const part0 = llmResponse.content.parts[0];
+          if (part0.thought) {
             thoughtText += part0.text;
           } else {
             text += part0.text;
           }
           llmResponse.partial = true;
-        } else if ((thoughtText || text) && (!llmResponse.content || !llmResponse.content.parts || !this.hasInlineData(llmResponse))) {
+        } else if ((thoughtText || text) && (!llmResponse.content || !llmResponse.content.parts || !this.hasInlineData(resp))) {
           const parts = [];
           if (thoughtText) {
             parts.push({ text: thoughtText, thought: true });
@@ -1931,73 +1973,14 @@ var OpenAiLlm = class extends BaseLlm {
               parts,
               role: "model"
             },
-            usageMetadata: usageMetadata ? {
-              promptTokenCount: usageMetadata.prompt_tokens,
-              candidatesTokenCount: usageMetadata.completion_tokens,
-              totalTokenCount: usageMetadata.total_tokens
-            } : void 0
+            usageMetadata
           });
           thoughtText = "";
           text = "";
         }
-        if (delta.tool_calls) {
-          for (const toolCall of delta.tool_calls) {
-            const index = toolCall.index || 0;
-            if (!accumulatedToolCalls[index]) {
-              accumulatedToolCalls[index] = {
-                index,
-                id: toolCall.id || "",
-                type: "function",
-                function: { name: "", arguments: "" }
-              };
-            }
-            if (toolCall.function?.name) {
-              accumulatedToolCalls[index].function.name += toolCall.function.name;
-            }
-            if (toolCall.function?.arguments) {
-              accumulatedToolCalls[index].function.arguments += toolCall.function.arguments;
-            }
-          }
-        }
-        if (choice.finish_reason) {
-          const parts = [];
-          if (thoughtText) {
-            parts.push({ text: thoughtText, thought: true });
-          }
-          if (text) {
-            parts.push({ text });
-          }
-          if (accumulatedToolCalls.length > 0) {
-            for (const toolCall of accumulatedToolCalls) {
-              if (toolCall.function?.name) {
-                parts.push({
-                  functionCall: {
-                    id: toolCall.id,
-                    name: toolCall.function.name,
-                    args: JSON.parse(toolCall.function.arguments || "{}")
-                  }
-                });
-              }
-            }
-          }
-          const finalResponse = new LlmResponse({
-            content: {
-              role: "model",
-              parts
-            },
-            usageMetadata: usageMetadata ? {
-              promptTokenCount: usageMetadata.prompt_tokens,
-              candidatesTokenCount: usageMetadata.completion_tokens,
-              totalTokenCount: usageMetadata.total_tokens
-            } : void 0,
-            finishReason: this.toAdkFinishReason(choice.finish_reason)
-          });
-          yield finalResponse;
-        } else {
-          yield llmResponse;
-        }
+        yield llmResponse;
       }
-      if ((text || thoughtText) && usageMetadata) {
+      if ((text || thoughtText) && response && response.candidates && response.candidates[0]?.finishReason === FinishReason.STOP) {
         const parts = [];
         if (thoughtText) {
           parts.push({ text: thoughtText, thought: true });
@@ -2010,560 +1993,655 @@ var OpenAiLlm = class extends BaseLlm {
             parts,
             role: "model"
           },
-          usageMetadata: {
-            promptTokenCount: usageMetadata.prompt_tokens,
-            candidatesTokenCount: usageMetadata.completion_tokens,
-            totalTokenCount: usageMetadata.total_tokens
-          }
+          usageMetadata
         });
       }
     } else {
-      const response = await this.client.chat.completions.create({
-        ...requestParams,
-        stream: false
+      const response = await this.apiClient.models.generateContent({
+        model,
+        contents,
+        config
       });
-      const choice = response.choices[0];
-      if (choice) {
-        const llmResponse = this.openAiMessageToLlmResponse(
-          choice,
-          response.usage
-        );
-        this.logger.debug(
-          `OpenAI response: ${response.usage?.completion_tokens || 0} tokens`
-        );
-        yield llmResponse;
-      }
+      const llmResponse = LlmResponse.create(response);
+      this.logger.debug(
+        `Google response: ${llmResponse.usageMetadata?.candidatesTokenCount || 0} tokens`
+      );
+      yield llmResponse;
     }
   }
   /**
-   * Live connection is not supported for OpenAI models
+   * Connects to the Gemini model and returns an llm connection.
    */
   connect(_llmRequest) {
     throw new Error(`Live connection is not supported for ${this.model}.`);
   }
   /**
-   * Create LlmResponse from streaming chunk - similar to Google's LlmResponse.create
+   * Check if response has inline data
    */
-  createChunkResponse(delta, usage) {
-    const parts = [];
-    if (delta.content) {
-      const contentType = this.getContentType(delta.content);
-      if (contentType === "thought") {
-        parts.push({ text: delta.content, thought: true });
-      } else {
-        parts.push({ text: delta.content });
+  hasInlineData(response) {
+    const parts = response.candidates?.[0]?.content?.parts;
+    return parts?.some((part) => part?.inlineData) || false;
+  }
+  /**
+   * Convert LlmRequest contents to GoogleGenAI format
+   */
+  convertContents(contents) {
+    return contents.map((content) => ({
+      role: content.role === "assistant" ? "model" : content.role,
+      parts: content.parts || [{ text: content.content || "" }]
+    }));
+  }
+  /**
+   * Preprocesses the request based on the API backend.
+   */
+  preprocessRequest(llmRequest) {
+    if (this.apiBackend === "GEMINI_API" /* GEMINI_API */) {
+      if (llmRequest.config) {
+        llmRequest.config.labels = void 0;
       }
-    }
-    if (delta.tool_calls) {
-      for (const toolCall of delta.tool_calls) {
-        if (toolCall.type === "function" && toolCall.function?.name) {
-          parts.push({
-            functionCall: {
-              id: toolCall.id || "",
-              name: toolCall.function.name,
-              args: JSON.parse(toolCall.function.arguments || "{}")
-            }
-          });
+      if (llmRequest.contents) {
+        for (const content of llmRequest.contents) {
+          if (!content.parts) continue;
+          for (const part of content.parts) {
+            this.removeDisplayNameIfPresent(part.inlineData);
+            this.removeDisplayNameIfPresent(part.fileData);
+          }
         }
       }
     }
-    return new LlmResponse({
-      content: parts.length > 0 ? {
-        role: "model",
-        parts
-      } : void 0,
-      usageMetadata: usage ? {
-        promptTokenCount: usage.prompt_tokens,
-        candidatesTokenCount: usage.completion_tokens,
-        totalTokenCount: usage.total_tokens
-      } : void 0
-    });
   }
   /**
-   * Convert OpenAI message to ADK LlmResponse
+   * Sets display_name to null for the Gemini API (non-Vertex) backend.
    */
-  openAiMessageToLlmResponse(choice, usage) {
-    const message = choice.message;
-    const parts = [];
-    if (message.content) {
-      parts.push({ text: message.content });
+  removeDisplayNameIfPresent(dataObj) {
+    if (dataObj?.displayName) {
+      dataObj.displayName = null;
     }
-    if (message.tool_calls) {
-      for (const toolCall of message.tool_calls) {
-        if (toolCall.type === "function") {
-          parts.push({
-            functionCall: {
-              id: toolCall.id,
-              name: toolCall.function.name,
-              args: JSON.parse(toolCall.function.arguments || "{}")
-            }
-          });
-        }
+  }
+  /**
+   * Builds function declaration log string.
+   */
+  buildFunctionDeclarationLog(funcDecl) {
+    let paramStr = "{}";
+    if (funcDecl.parameters?.properties) {
+      paramStr = JSON.stringify(funcDecl.parameters.properties);
+    }
+    return `${funcDecl.name}: ${paramStr}`;
+  }
+  /**
+   * Provides the api client.
+   */
+  get apiClient() {
+    if (!this._apiClient) {
+      const useVertexAI = process.env.GOOGLE_GENAI_USE_VERTEXAI === "true";
+      const apiKey = process.env.GOOGLE_API_KEY;
+      const project = process.env.GOOGLE_CLOUD_PROJECT;
+      const location = process.env.GOOGLE_CLOUD_LOCATION;
+      if (useVertexAI && project && location) {
+        this._apiClient = new GoogleGenAI({
+          vertexai: true,
+          project,
+          location
+        });
+      } else if (apiKey) {
+        this._apiClient = new GoogleGenAI({
+          apiKey
+        });
+      } else {
+        throw new Error(
+          "Google API Key or Vertex AI configuration is required. Set GOOGLE_API_KEY or GOOGLE_GENAI_USE_VERTEXAI=true with GOOGLE_CLOUD_PROJECT and GOOGLE_CLOUD_LOCATION."
+        );
       }
     }
-    return new LlmResponse({
-      content: {
-        role: "model",
-        parts
-      },
-      usageMetadata: usage ? {
-        promptTokenCount: usage.prompt_tokens,
-        candidatesTokenCount: usage.completion_tokens,
-        totalTokenCount: usage.total_tokens
-      } : void 0,
-      finishReason: this.toAdkFinishReason(choice.finish_reason)
-    });
+    return this._apiClient;
   }
   /**
-   * Convert ADK Content to OpenAI ChatCompletionMessage
+   * Gets the API backend type.
    */
-  contentToOpenAiMessage(content) {
-    const role = this.toOpenAiRole(content.role);
-    if (role === "system") {
-      return {
-        role: "system",
-        content: content.parts?.[0]?.text || ""
-      };
+  get apiBackend() {
+    if (!this._apiBackend) {
+      const useVertexAI = process.env.GOOGLE_GENAI_USE_VERTEXAI === "true";
+      this._apiBackend = useVertexAI ? "VERTEX_AI" /* VERTEX_AI */ : "GEMINI_API" /* GEMINI_API */;
     }
-    if (content.parts?.some((part) => part.functionCall)) {
-      const functionCallPart = content.parts.find(
-        (part) => part.functionCall
-      );
-      return {
-        role: "assistant",
-        tool_calls: [
-          {
-            id: functionCallPart.functionCall.id || "",
-            type: "function",
-            function: {
-              name: functionCallPart.functionCall.name,
-              arguments: JSON.stringify(
-                functionCallPart.functionCall.args || {}
-              )
-            }
-          }
-        ]
-      };
-    }
-    if (content.parts?.some((part) => part.functionResponse)) {
-      const functionResponsePart = content.parts.find(
-        (part) => part.functionResponse
-      );
-      return {
-        role: "tool",
-        tool_call_id: functionResponsePart.functionResponse.id || "",
-        content: JSON.stringify(
-          functionResponsePart.functionResponse.response || {}
-        )
-      };
-    }
-    if (content.parts?.length === 1 && content.parts[0].text) {
-      return {
-        role,
-        content: content.parts[0].text
-      };
-    }
-    return {
-      role,
-      content: (content.parts || []).map(
-        (part) => this.partToOpenAiContent(part)
-      )
-    };
-  }
-  /**
-   * Convert ADK Part to OpenAI message content
-   */
-  partToOpenAiContent(part) {
-    if (part.text) {
-      return {
-        type: "text",
-        text: part.text
-      };
-    }
-    if (part.inline_data?.mime_type && part.inline_data?.data) {
-      return {
-        type: "image_url",
-        image_url: {
-          url: `data:${part.inline_data.mime_type};base64,${part.inline_data.data}`
-        }
-      };
-    }
-    throw new Error("Unsupported part type for OpenAI conversion");
+    return this._apiBackend;
   }
   /**
-   * Convert ADK function declaration to OpenAI tool
+   * Gets the tracking headers.
    */
-  functionDeclarationToOpenAiTool(functionDeclaration) {
-    return {
-      type: "function",
-      function: {
-        name: functionDeclaration.name,
-        description: functionDeclaration.description || "",
-        parameters: functionDeclaration.parameters || {}
+  get trackingHeaders() {
+    if (!this._trackingHeaders) {
+      let frameworkLabel = "google-adk/1.0.0";
+      if (process.env[AGENT_ENGINE_TELEMETRY_ENV_VARIABLE_NAME]) {
+        frameworkLabel = `${frameworkLabel}+${AGENT_ENGINE_TELEMETRY_TAG}`;
       }
-    };
-  }
-  /**
-   * Convert ADK role to OpenAI role format
-   */
-  toOpenAiRole(role) {
-    if (role === "model") {
-      return "assistant";
-    }
-    if (role === "system") {
-      return "system";
-    }
-    return "user";
-  }
-  /**
-   * Convert OpenAI finish reason to ADK finish reason
-   */
-  toAdkFinishReason(openaiFinishReason) {
-    switch (openaiFinishReason) {
-      case "stop":
-      case "tool_calls":
-        return "STOP";
-      case "length":
-        return "MAX_TOKENS";
-      default:
-        return "FINISH_REASON_UNSPECIFIED";
+      const languageLabel = `gl-node/${process.version}`;
+      const versionHeaderValue = `${frameworkLabel} ${languageLabel}`;
+      this._trackingHeaders = {
+        "x-goog-api-client": versionHeaderValue,
+        "user-agent": versionHeaderValue
+      };
     }
+    return this._trackingHeaders;
   }
   /**
-   * Preprocess request similar to Google LLM
+   * Gets the live API version.
    */
-  preprocessRequest(llmRequest) {
-    if (llmRequest.config) {
-      llmRequest.config.labels = void 0;
-      if (llmRequest.contents) {
-        for (const content of llmRequest.contents) {
-          if (!content.parts) continue;
-          for (const part of content.parts) {
-            this.preprocessPart(part);
-          }
-        }
-      }
-    }
+  get liveApiVersion() {
+    return this.apiBackend === "VERTEX_AI" /* VERTEX_AI */ ? "v1beta1" : "v1alpha";
   }
   /**
-   * Preprocess individual parts for OpenAI compatibility
+   * Gets the live API client.
    */
-  preprocessPart(part) {
-    if (part.inline_data) {
-      if (!part.inline_data.mime_type || !part.inline_data.data) {
-        delete part.inline_data;
+  get liveApiClient() {
+    if (!this._liveApiClient) {
+      const useVertexAI = process.env.GOOGLE_GENAI_USE_VERTEXAI === "true";
+      const apiKey = process.env.GOOGLE_API_KEY;
+      const project = process.env.GOOGLE_CLOUD_PROJECT;
+      const location = process.env.GOOGLE_CLOUD_LOCATION;
+      if (useVertexAI && project && location) {
+        this._liveApiClient = new GoogleGenAI({
+          vertexai: true,
+          project,
+          location,
+          apiVersion: this.liveApiVersion
+        });
+      } else if (apiKey) {
+        this._liveApiClient = new GoogleGenAI({
+          apiKey,
+          apiVersion: this.liveApiVersion
+        });
+      } else {
+        throw new Error("API configuration required for live client");
       }
     }
+    return this._liveApiClient;
   }
+};
+
+// src/models/openai-llm.ts
+import OpenAI from "openai";
+var OpenAiLlm = class extends BaseLlm {
+  _client;
   /**
-   * Detect content type for flow control
-   * This is a simplified implementation - you may need to adjust based on your specific requirements
+   * Constructor for OpenAI LLM
    */
-  getContentType(content) {
-    if (content.includes("<thinking>") || content.includes("[thinking]")) {
-      return "thought";
-    }
-    return "regular";
+  constructor(model = "gpt-4o-mini") {
+    super(model);
   }
   /**
-   * Check if response has inline data (similar to Google LLM)
+   * Provides the list of supported models
    */
-  hasInlineData(response) {
-    const parts = response.content?.parts;
-    return parts?.some((part) => part.inlineData) || false;
+  static supportedModels() {
+    return ["gpt-3.5-.*", "gpt-4.*", "gpt-4o.*", "o1-.*", "o3-.*"];
   }
   /**
-   * Gets the OpenAI client
+   * Main content generation method - handles both streaming and non-streaming
    */
-  get client() {
-    if (!this._client) {
-      const apiKey = process.env.OPENAI_API_KEY;
-      if (!apiKey) {
-        throw new Error(
-          "OPENAI_API_KEY environment variable is required for OpenAI models"
-        );
-      }
-      this._client = new OpenAI({
-        apiKey
+  async *generateContentAsyncImpl(llmRequest, stream = false) {
+    this.preprocessRequest(llmRequest);
+    const model = llmRequest.model || this.model;
+    const messages = (llmRequest.contents || []).map(
+      (content) => this.contentToOpenAiMessage(content)
+    );
+    let tools;
+    if (llmRequest.config?.tools?.[0]?.functionDeclarations) {
+      tools = llmRequest.config.tools[0].functionDeclarations.map(
+        (funcDecl) => this.functionDeclarationToOpenAiTool(funcDecl)
+      );
+    }
+    const systemContent = llmRequest.getSystemInstructionText();
+    if (systemContent) {
+      messages.unshift({
+        role: "system",
+        content: systemContent
       });
     }
-    return this._client;
-  }
-};
-
-// src/models/ai-sdk.ts
-init_logger();
-import {
-  generateText,
-  jsonSchema,
-  streamText
-} from "ai";
-var AiSdkLlm = class extends BaseLlm {
-  modelInstance;
-  logger = new Logger({ name: "AiSdkLlm" });
-  /**
-   * Constructor accepts a pre-configured LanguageModel instance
-   * @param model - Pre-configured LanguageModel from provider(modelName)
-   */
-  constructor(modelInstance) {
-    super(modelInstance.modelId || "ai-sdk-model");
-    this.modelInstance = modelInstance;
-  }
-  /**
-   * Returns empty array - following Python ADK pattern
-   */
-  static supportedModels() {
-    return [];
-  }
-  async *generateContentAsyncImpl(request, stream = false) {
-    try {
-      const messages = this.convertToAiSdkMessages(request);
-      const systemMessage = request.getSystemInstructionText();
-      const tools = this.convertToAiSdkTools(request);
-      const requestParams = {
-        model: this.modelInstance,
-        messages,
-        system: systemMessage,
-        tools: Object.keys(tools).length > 0 ? tools : void 0,
-        maxTokens: request.config?.maxOutputTokens,
-        temperature: request.config?.temperature,
-        topP: request.config?.topP
-      };
-      if (stream) {
-        const result = streamText(requestParams);
-        let accumulatedText = "";
-        for await (const delta of result.textStream) {
-          accumulatedText += delta;
+    const openAiMessages = messages;
+    const requestParams = {
+      model,
+      messages: openAiMessages,
+      tools,
+      tool_choice: tools ? "auto" : void 0,
+      max_tokens: llmRequest.config?.maxOutputTokens,
+      temperature: llmRequest.config?.temperature,
+      top_p: llmRequest.config?.topP,
+      stream
+    };
+    if (stream) {
+      const streamResponse = await this.client.chat.completions.create({
+        ...requestParams,
+        stream: true
+      });
+      let thoughtText = "";
+      let text = "";
+      let usageMetadata;
+      const accumulatedToolCalls = [];
+      for await (const chunk of streamResponse) {
+        const choice = chunk.choices[0];
+        if (!choice) continue;
+        const delta = choice.delta;
+        const llmResponse = this.createChunkResponse(delta, chunk.usage);
+        if (chunk.usage) {
+          usageMetadata = chunk.usage;
+        }
+        if (llmResponse.content?.parts?.[0]?.text) {
+          const part0 = llmResponse.content.parts[0];
+          if (part0.thought) {
+            thoughtText += part0.text;
+          } else {
+            text += part0.text;
+          }
+          llmResponse.partial = true;
+        } else if ((thoughtText || text) && (!llmResponse.content || !llmResponse.content.parts || !this.hasInlineData(llmResponse))) {
+          const parts = [];
+          if (thoughtText) {
+            parts.push({ text: thoughtText, thought: true });
+          }
+          if (text) {
+            parts.push({ text });
+          }
           yield new LlmResponse({
             content: {
-              role: "model",
-              parts: [{ text: accumulatedText }]
+              parts,
+              role: "model"
             },
-            partial: true
+            usageMetadata: usageMetadata ? {
+              promptTokenCount: usageMetadata.prompt_tokens,
+              candidatesTokenCount: usageMetadata.completion_tokens,
+              totalTokenCount: usageMetadata.total_tokens
+            } : void 0
           });
+          thoughtText = "";
+          text = "";
         }
-        const toolCalls = await result.toolCalls;
-        const parts = [];
-        if (accumulatedText) {
-          parts.push({ text: accumulatedText });
+        if (delta.tool_calls) {
+          for (const toolCall of delta.tool_calls) {
+            const index = toolCall.index || 0;
+            if (!accumulatedToolCalls[index]) {
+              accumulatedToolCalls[index] = {
+                index,
+                id: toolCall.id || "",
+                type: "function",
+                function: { name: "", arguments: "" }
+              };
+            }
+            if (toolCall.function?.name) {
+              accumulatedToolCalls[index].function.name += toolCall.function.name;
+            }
+            if (toolCall.function?.arguments) {
+              accumulatedToolCalls[index].function.arguments += toolCall.function.arguments;
+            }
+          }
         }
-        if (toolCalls && toolCalls.length > 0) {
-          for (const toolCall of toolCalls) {
-            parts.push({
-              functionCall: {
-                id: toolCall.toolCallId,
-                name: toolCall.toolName,
-                args: toolCall.args
+        if (choice.finish_reason) {
+          const parts = [];
+          if (thoughtText) {
+            parts.push({ text: thoughtText, thought: true });
+          }
+          if (text) {
+            parts.push({ text });
+          }
+          if (accumulatedToolCalls.length > 0) {
+            for (const toolCall of accumulatedToolCalls) {
+              if (toolCall.function?.name) {
+                parts.push({
+                  functionCall: {
+                    id: toolCall.id,
+                    name: toolCall.function.name,
+                    args: JSON.parse(toolCall.function.arguments || "{}")
+                  }
+                });
               }
-            });
+            }
           }
+          const finalResponse = new LlmResponse({
+            content: {
+              role: "model",
+              parts
+            },
+            usageMetadata: usageMetadata ? {
+              promptTokenCount: usageMetadata.prompt_tokens,
+              candidatesTokenCount: usageMetadata.completion_tokens,
+              totalTokenCount: usageMetadata.total_tokens
+            } : void 0,
+            finishReason: this.toAdkFinishReason(choice.finish_reason)
+          });
+          yield finalResponse;
+        } else {
+          yield llmResponse;
         }
-        const finalUsage = await result.usage;
-        const finishReason = await result.finishReason;
-        yield new LlmResponse({
-          content: {
-            role: "model",
-            parts: parts.length > 0 ? parts : [{ text: "" }]
-          },
-          usageMetadata: finalUsage ? {
-            promptTokenCount: finalUsage.promptTokens,
-            candidatesTokenCount: finalUsage.completionTokens,
-            totalTokenCount: finalUsage.totalTokens
-          } : void 0,
-          finishReason: this.mapFinishReason(finishReason),
-          turnComplete: true
-        });
-      } else {
-        const result = await generateText(requestParams);
+      }
+      if ((text || thoughtText) && usageMetadata) {
         const parts = [];
-        if (result.text) {
-          parts.push({ text: result.text });
+        if (thoughtText) {
+          parts.push({ text: thoughtText, thought: true });
         }
-        if (result.toolCalls && result.toolCalls.length > 0) {
-          for (const toolCall of result.toolCalls) {
-            parts.push({
-              functionCall: {
-                id: toolCall.toolCallId,
-                name: toolCall.toolName,
-                args: toolCall.args
-              }
-            });
-          }
+        if (text) {
+          parts.push({ text });
         }
         yield new LlmResponse({
           content: {
-            role: "model",
-            parts: parts.length > 0 ? parts : [{ text: "" }]
+            parts,
+            role: "model"
           },
-          usageMetadata: result.usage ? {
-            promptTokenCount: result.usage.promptTokens,
-            candidatesTokenCount: result.usage.completionTokens,
-            totalTokenCount: result.usage.totalTokens
-          } : void 0,
-          finishReason: this.mapFinishReason(result.finishReason),
-          turnComplete: true
+          usageMetadata: {
+            promptTokenCount: usageMetadata.prompt_tokens,
+            candidatesTokenCount: usageMetadata.completion_tokens,
+            totalTokenCount: usageMetadata.total_tokens
+          }
         });
       }
-    } catch (error) {
-      this.logger.error(`AI SDK Error: ${String(error)}`, { error, request });
-      yield LlmResponse.fromError(error, {
-        errorCode: "AI_SDK_ERROR",
-        model: this.model
+    } else {
+      const response = await this.client.chat.completions.create({
+        ...requestParams,
+        stream: false
       });
+      const choice = response.choices[0];
+      if (choice) {
+        const llmResponse = this.openAiMessageToLlmResponse(
+          choice,
+          response.usage
+        );
+        this.logger.debug(
+          `OpenAI response: ${response.usage?.completion_tokens || 0} tokens`
+        );
+        yield llmResponse;
+      }
     }
   }
   /**
-   * Convert ADK LlmRequest to AI SDK CoreMessage format
+   * Live connection is not supported for OpenAI models
    */
-  convertToAiSdkMessages(llmRequest) {
-    const messages = [];
-    for (const content of llmRequest.contents || []) {
-      const message = this.contentToAiSdkMessage(content);
-      if (message) {
-        messages.push(message);
-      }
-    }
-    return messages;
+  connect(_llmRequest) {
+    throw new Error(`Live connection is not supported for ${this.model}.`);
   }
   /**
-   * Convert ADK tools to AI SDK tools format
+   * Create LlmResponse from streaming chunk - similar to Google's LlmResponse.create
    */
-  convertToAiSdkTools(llmRequest) {
-    const tools = {};
-    if (llmRequest.config?.tools) {
-      for (const toolConfig of llmRequest.config.tools) {
-        if ("functionDeclarations" in toolConfig) {
-          for (const funcDecl of toolConfig.functionDeclarations) {
-            tools[funcDecl.name] = {
-              description: funcDecl.description,
-              parameters: jsonSchema(funcDecl.parameters || {})
-            };
-          }
+  createChunkResponse(delta, usage) {
+    const parts = [];
+    if (delta.content) {
+      const contentType = this.getContentType(delta.content);
+      if (contentType === "thought") {
+        parts.push({ text: delta.content, thought: true });
+      } else {
+        parts.push({ text: delta.content });
+      }
+    }
+    if (delta.tool_calls) {
+      for (const toolCall of delta.tool_calls) {
+        if (toolCall.type === "function" && toolCall.function?.name) {
+          parts.push({
+            functionCall: {
+              id: toolCall.id || "",
+              name: toolCall.function.name,
+              args: JSON.parse(toolCall.function.arguments || "{}")
+            }
+          });
         }
       }
     }
-    return tools;
+    return new LlmResponse({
+      content: parts.length > 0 ? {
+        role: "model",
+        parts
+      } : void 0,
+      usageMetadata: usage ? {
+        promptTokenCount: usage.prompt_tokens,
+        candidatesTokenCount: usage.completion_tokens,
+        totalTokenCount: usage.total_tokens
+      } : void 0
+    });
   }
   /**
-   * Convert ADK Content to AI SDK CoreMessage
+   * Convert OpenAI message to ADK LlmResponse
    */
-  contentToAiSdkMessage(content) {
-    const role = this.mapRole(content.role);
-    if (!content.parts || content.parts.length === 0) {
-      return null;
+  openAiMessageToLlmResponse(choice, usage) {
+    const message = choice.message;
+    const parts = [];
+    if (message.content) {
+      parts.push({ text: message.content });
     }
-    if (content.parts.length === 1 && content.parts[0].text) {
-      const textContent = content.parts[0].text;
-      if (role === "system") {
-        return { role: "system", content: textContent };
-      }
-      if (role === "assistant") {
-        return { role: "assistant", content: textContent };
+    if (message.tool_calls) {
+      for (const toolCall of message.tool_calls) {
+        if (toolCall.type === "function") {
+          parts.push({
+            functionCall: {
+              id: toolCall.id,
+              name: toolCall.function.name,
+              args: JSON.parse(toolCall.function.arguments || "{}")
+            }
+          });
+        }
       }
-      return { role: "user", content: textContent };
+    }
+    return new LlmResponse({
+      content: {
+        role: "model",
+        parts
+      },
+      usageMetadata: usage ? {
+        promptTokenCount: usage.prompt_tokens,
+        candidatesTokenCount: usage.completion_tokens,
+        totalTokenCount: usage.total_tokens
+      } : void 0,
+      finishReason: this.toAdkFinishReason(choice.finish_reason)
+    });
+  }
+  /**
+   * Convert ADK Content to OpenAI ChatCompletionMessage
+   */
+  contentToOpenAiMessage(content) {
+    const role = this.toOpenAiRole(content.role);
+    if (role === "system") {
+      return {
+        role: "system",
+        content: content.parts?.[0]?.text || ""
+      };
     }
     if (content.parts?.some((part) => part.functionCall)) {
-      const textParts = content.parts.filter((part) => part.text);
-      const functionCalls = content.parts.filter((part) => part.functionCall);
-      const contentParts2 = [];
-      for (const textPart of textParts) {
-        if (textPart.text) {
-          contentParts2.push({
-            type: "text",
-            text: textPart.text
-          });
-        }
-      }
-      for (const funcPart of functionCalls) {
-        if (funcPart.functionCall) {
-          contentParts2.push({
-            type: "tool-call",
-            toolCallId: funcPart.functionCall.id,
-            toolName: funcPart.functionCall.name,
-            args: funcPart.functionCall.args
-          });
-        }
-      }
+      const functionCallPart = content.parts.find(
+        (part) => part.functionCall
+      );
       return {
         role: "assistant",
-        content: contentParts2
+        tool_calls: [
+          {
+            id: functionCallPart.functionCall.id || "",
+            type: "function",
+            function: {
+              name: functionCallPart.functionCall.name,
+              arguments: JSON.stringify(
+                functionCallPart.functionCall.args || {}
+              )
+            }
+          }
+        ]
       };
     }
     if (content.parts?.some((part) => part.functionResponse)) {
-      const functionResponses = content.parts.filter(
+      const functionResponsePart = content.parts.find(
         (part) => part.functionResponse
       );
-      const contentParts2 = functionResponses.map((part) => ({
-        type: "tool-result",
-        toolCallId: part.functionResponse.id,
-        toolName: part.functionResponse.name || "unknown",
-        result: part.functionResponse.response
-      }));
       return {
         role: "tool",
-        content: contentParts2
+        tool_call_id: functionResponsePart.functionResponse.id || "",
+        content: JSON.stringify(
+          functionResponsePart.functionResponse.response || {}
+        )
       };
     }
-    const contentParts = [];
-    for (const part of content.parts) {
-      if (part.text) {
-        contentParts.push({
-          type: "text",
-          text: part.text
-        });
-      }
+    if (content.parts?.length === 1 && content.parts[0].text) {
+      return {
+        role,
+        content: content.parts[0].text
+      };
     }
-    if (contentParts.length === 0) {
-      return null;
+    return {
+      role,
+      content: (content.parts || []).map(
+        (part) => this.partToOpenAiContent(part)
+      )
+    };
+  }
+  /**
+   * Convert ADK Part to OpenAI message content
+   */
+  partToOpenAiContent(part) {
+    if (part.text) {
+      return {
+        type: "text",
+        text: part.text
+      };
     }
-    if (contentParts.length === 1) {
-      const textContent = contentParts[0].text;
-      if (role === "system") {
-        return { role: "system", content: textContent };
-      }
-      if (role === "assistant") {
-        return { role: "assistant", content: textContent };
-      }
-      return { role: "user", content: textContent };
+    if (part.inline_data?.mime_type && part.inline_data?.data) {
+      return {
+        type: "image_url",
+        image_url: {
+          url: `data:${part.inline_data.mime_type};base64,${part.inline_data.data}`
+        }
+      };
     }
-    if (role === "system") {
-      const combinedText = contentParts.map((p) => p.text).join("");
-      return { role: "system", content: combinedText };
+    throw new Error("Unsupported part type for OpenAI conversion");
+  }
+  /**
+   * Transform JSON schema to use lowercase types for OpenAI compatibility
+   */
+  transformSchemaForOpenAi(schema) {
+    if (Array.isArray(schema)) {
+      return schema.map((item) => this.transformSchemaForOpenAi(item));
     }
-    if (role === "assistant") {
-      return { role: "assistant", content: contentParts };
+    if (!schema || typeof schema !== "object") {
+      return schema;
     }
-    return { role: "user", content: contentParts };
+    const transformedSchema = { ...schema };
+    if (transformedSchema.type && typeof transformedSchema.type === "string") {
+      transformedSchema.type = transformedSchema.type.toLowerCase();
+    }
+    if (transformedSchema.properties) {
+      transformedSchema.properties = Object.fromEntries(
+        Object.entries(transformedSchema.properties).map(([key, value]) => [
+          key,
+          this.transformSchemaForOpenAi(value)
+        ])
+      );
+    }
+    if (transformedSchema.items) {
+      transformedSchema.items = this.transformSchemaForOpenAi(
+        transformedSchema.items
+      );
+    }
+    const arrayKeywords = ["anyOf", "oneOf", "allOf"];
+    for (const keyword of arrayKeywords) {
+      if (transformedSchema[keyword]) {
+        transformedSchema[keyword] = this.transformSchemaForOpenAi(
+          transformedSchema[keyword]
+        );
+      }
+    }
+    return transformedSchema;
   }
   /**
-   * Map ADK role to AI SDK role
+   * Convert ADK function declaration to OpenAI tool
    */
-  mapRole(role) {
-    switch (role) {
-      case "model":
-      case "assistant":
-        return "assistant";
-      case "system":
-        return "system";
-      default:
-        return "user";
+  functionDeclarationToOpenAiTool(functionDeclaration) {
+    return {
+      type: "function",
+      function: {
+        name: functionDeclaration.name,
+        description: functionDeclaration.description || "",
+        parameters: this.transformSchemaForOpenAi(
+          functionDeclaration.parameters || {}
+        )
+      }
+    };
+  }
+  /**
+   * Convert ADK role to OpenAI role format
+   */
+  toOpenAiRole(role) {
+    if (role === "model") {
+      return "assistant";
+    }
+    if (role === "system") {
+      return "system";
     }
+    return "user";
   }
   /**
-   * Map AI SDK finish reason to ADK finish reason
+   * Convert OpenAI finish reason to ADK finish reason
    */
-  mapFinishReason(finishReason) {
-    switch (finishReason) {
+  toAdkFinishReason(openaiFinishReason) {
+    switch (openaiFinishReason) {
       case "stop":
-      case "end_of_message":
+      case "tool_calls":
         return "STOP";
       case "length":
-      case "max_tokens":
         return "MAX_TOKENS";
       default:
         return "FINISH_REASON_UNSPECIFIED";
     }
   }
+  /**
+   * Preprocess request similar to Google LLM
+   */
+  preprocessRequest(llmRequest) {
+    if (llmRequest.config) {
+      llmRequest.config.labels = void 0;
+      if (llmRequest.contents) {
+        for (const content of llmRequest.contents) {
+          if (!content.parts) continue;
+          for (const part of content.parts) {
+            this.preprocessPart(part);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Preprocess individual parts for OpenAI compatibility
+   */
+  preprocessPart(part) {
+    if (part.inline_data) {
+      if (!part.inline_data.mime_type || !part.inline_data.data) {
+        delete part.inline_data;
+      }
+    }
+  }
+  /**
+   * Detect content type for flow control
+   * This is a simplified implementation - you may need to adjust based on your specific requirements
+   */
+  getContentType(content) {
+    if (content.includes("<thinking>") || content.includes("[thinking]")) {
+      return "thought";
+    }
+    return "regular";
+  }
+  /**
+   * Check if response has inline data (similar to Google LLM)
+   */
+  hasInlineData(response) {
+    const parts = response.content?.parts;
+    return parts?.some((part) => part.inlineData) || false;
+  }
+  /**
+   * Gets the OpenAI client
+   */
+  get client() {
+    if (!this._client) {
+      const apiKey = process.env.OPENAI_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          "OPENAI_API_KEY environment variable is required for OpenAI models"
+        );
+      }
+      this._client = new OpenAI({
+        apiKey
+      });
+    }
+    return this._client;
+  }
 };
 
 // src/models/llm-registry.ts
@@ -2640,6 +2718,25 @@ function registerProviders() {
 }
 registerProviders();
 
+// src/auth/auth-config.ts
+var AuthConfig = class {
+  /**
+   * The authentication scheme
+   */
+  authScheme;
+  /**
+   * Additional context properties
+   */
+  context;
+  /**
+   * Constructor for AuthConfig
+   */
+  constructor(config) {
+    this.authScheme = config.authScheme;
+    this.context = config.context;
+  }
+};
+
 // src/auth/auth-credential.ts
 var AuthCredentialType = /* @__PURE__ */ ((AuthCredentialType2) => {
   AuthCredentialType2["API_KEY"] = "api_key";
@@ -2842,25 +2939,6 @@ var OAuth2Credential = class extends AuthCredential {
   }
 };
 
-// src/auth/auth-config.ts
-var AuthConfig = class {
-  /**
-   * The authentication scheme
-   */
-  authScheme;
-  /**
-   * Additional context properties
-   */
-  context;
-  /**
-   * Constructor for AuthConfig
-   */
-  constructor(config) {
-    this.authScheme = config.authScheme;
-    this.context = config.context;
-  }
-};
-
 // src/auth/auth-handler.ts
 var AuthHandler = class {
   /**