@iqai/adk 0.1.19 → 0.1.20

package/dist/index.js

@@ -1362,276 +1362,332 @@ var BaseLlm = (_class5 = class {
 var BaseLLMConnection = class {
 };
 
-// src/models/google-llm.ts
+// src/models/ai-sdk.ts
+init_logger();
 
 
 
 
-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 {
-  
-  
-  
+var _ai = require('ai');
+var AiSdkLlm = (_class6 = class extends BaseLlm {
   
+  __init12() {this.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");_class6.prototype.__init12.call(this);;
+    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 (_optionalChain([llmResponse, 'access', _45 => _45.content, 'optionalAccess', _46 => _46.parts, 'optionalAccess', _47 => _47[0], 'optionalAccess', _48 => _48.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: _optionalChain([request, 'access', _45 => _45.config, 'optionalAccess', _46 => _46.maxOutputTokens]),
+        temperature: _optionalChain([request, 'access', _47 => _47.config, 'optionalAccess', _48 => _48.temperature]),
+        topP: _optionalChain([request, 'access', _49 => _49.config, 'optionalAccess', _50 => _50.topP])
+      };
+      if (stream) {
+        const result = _ai.streamText.call(void 0, 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 && _optionalChain([response, 'access', _49 => _49.candidates, 'access', _50 => _50[0], 'optionalAccess', _51 => _51.finishReason]) === _genai.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 _ai.generateText.call(void 0, 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: ${_optionalChain([llmResponse, 'access', _52 => _52.usageMetadata, 'optionalAccess', _53 => _53.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 = _optionalChain([response, 'access', _54 => _54.candidates, 'optionalAccess', _55 => _55[0], 'optionalAccess', _56 => _56.content, 'optionalAccess', _57 => _57.parts]);
-    return _optionalChain([parts, 'optionalAccess', _58 => _58.some, 'call', _59 => _59((part) => _optionalChain([part, 'optionalAccess', _60 => _60.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 (_optionalChain([llmRequest, 'access', _51 => _51.config, 'optionalAccess', _52 => _52.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: _ai.jsonSchema.call(void 0, 
+                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 (_optionalChain([dataObj, 'optionalAccess', _61 => _61.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 (_optionalChain([funcDecl, 'access', _62 => _62.parameters, 'optionalAccess', _63 => _63.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 (0, _genai.GoogleGenAI)({
-          vertexai: true,
-          project,
-          location
-        });
-      } else if (apiKey) {
-        this._apiClient = new (0, _genai.GoogleGenAI)({
-          apiKey
+    if (_optionalChain([content, 'access', _53 => _53.parts, 'optionalAccess', _54 => _54.some, 'call', _55 => _55((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 (_optionalChain([content, 'access', _56 => _56.parts, 'optionalAccess', _57 => _57.some, 'call', _58 => _58((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 (0, _genai.GoogleGenAI)({
-          vertexai: true,
-          project,
-          location,
-          apiVersion: this.liveApiVersion
-        });
-      } else if (apiKey) {
-        this._liveApiClient = new (0, _genai.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;
   }
-};
+}, _class6);
 
 // src/models/anthropic-llm.ts
 init_logger();
 var _sdk = require('@anthropic-ai/sdk'); var _sdk2 = _interopRequireDefault(_sdk);
 var MAX_TOKENS = 1024;
-var AnthropicLlm = (_class6 = class extends BaseLlm {
+var AnthropicLlm = (_class7 = class extends BaseLlm {
   
-  __init12() {this.logger = new Logger({ name: "AnthropicLlm" })}
+  __init13() {this.logger = new Logger({ name: "AnthropicLlm" })}
   /**
    * Constructor for Anthropic LLM
    */
   constructor(model = "claude-3-5-sonnet-20241022") {
-    super(model);_class6.prototype.__init12.call(this);;
+    super(model);_class7.prototype.__init13.call(this);;
   }
   /**
    * Provides the list of supported models
@@ -1648,7 +1704,7 @@ var AnthropicLlm = (_class6 = class extends BaseLlm {
       (content) => this.contentToAnthropicMessage(content)
     );
     let tools;
-    if (_optionalChain([llmRequest, 'access', _64 => _64.config, 'optionalAccess', _65 => _65.tools, 'optionalAccess', _66 => _66[0], 'optionalAccess', _67 => _67.functionDeclarations])) {
+    if (_optionalChain([llmRequest, 'access', _59 => _59.config, 'optionalAccess', _60 => _60.tools, 'optionalAccess', _61 => _61[0], 'optionalAccess', _62 => _62.functionDeclarations])) {
       tools = llmRequest.config.tools[0].functionDeclarations.map(
         (decl) => this.functionDeclarationToAnthropicTool(decl)
       );
@@ -1670,9 +1726,9 @@ var AnthropicLlm = (_class6 = class extends BaseLlm {
       messages: anthropicMessages,
       tools,
       tool_choice: tools ? { type: "auto" } : void 0,
-      max_tokens: _optionalChain([llmRequest, 'access', _68 => _68.config, 'optionalAccess', _69 => _69.maxOutputTokens]) || MAX_TOKENS,
-      temperature: _optionalChain([llmRequest, 'access', _70 => _70.config, 'optionalAccess', _71 => _71.temperature]),
-      top_p: _optionalChain([llmRequest, 'access', _72 => _72.config, 'optionalAccess', _73 => _73.topP])
+      max_tokens: _optionalChain([llmRequest, 'access', _63 => _63.config, 'optionalAccess', _64 => _64.maxOutputTokens]) || MAX_TOKENS,
+      temperature: _optionalChain([llmRequest, 'access', _65 => _65.config, 'optionalAccess', _66 => _66.temperature]),
+      top_p: _optionalChain([llmRequest, 'access', _67 => _67.config, 'optionalAccess', _68 => _68.topP])
     });
     yield this.anthropicMessageToLlmResponse(message);
   }
@@ -1733,7 +1789,7 @@ var AnthropicLlm = (_class6 = class extends BaseLlm {
     }
     if (part.function_response) {
       let content = "";
-      if (_optionalChain([part, 'access', _74 => _74.function_response, 'access', _75 => _75.response, 'optionalAccess', _76 => _76.result])) {
+      if (_optionalChain([part, 'access', _69 => _69.function_response, 'access', _70 => _70.response, 'optionalAccess', _71 => _71.result])) {
         content = String(part.function_response.response.result);
       }
       return {
@@ -1768,7 +1824,7 @@ var AnthropicLlm = (_class6 = class extends BaseLlm {
    */
   functionDeclarationToAnthropicTool(functionDeclaration) {
     const properties = {};
-    if (_optionalChain([functionDeclaration, 'access', _77 => _77.parameters, 'optionalAccess', _78 => _78.properties])) {
+    if (_optionalChain([functionDeclaration, 'access', _72 => _72.parameters, 'optionalAccess', _73 => _73.properties])) {
       for (const [key, value] of Object.entries(
         functionDeclaration.parameters.properties
       )) {
@@ -1842,23 +1898,37 @@ var AnthropicLlm = (_class6 = class extends BaseLlm {
     }
     return this._client;
   }
-}, _class6);
+}, _class7);
 
-// src/models/openai-llm.ts
-var _openai = require('openai'); var _openai2 = _interopRequireDefault(_openai);
-var OpenAiLlm = class extends BaseLlm {
+// src/models/google-llm.ts
+
+
+
+
+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 {
+  
+  
+  
   
   /**
-   * 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,51 +1936,23 @@ 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 (_optionalChain([llmRequest, 'access', _79 => _79.config, 'optionalAccess', _80 => _80.tools, 'optionalAccess', _81 => _81[0], 'optionalAccess', _82 => _82.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: _optionalChain([llmRequest, 'access', _83 => _83.config, 'optionalAccess', _84 => _84.maxOutputTokens]),
-      temperature: _optionalChain([llmRequest, 'access', _85 => _85.config, 'optionalAccess', _86 => _86.temperature]),
-      top_p: _optionalChain([llmRequest, 'access', _87 => _87.config, 'optionalAccess', _88 => _88.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 (_optionalChain([llmResponse, 'access', _89 => _89.content, 'optionalAccess', _90 => _90.parts, 'optionalAccess', _91 => _91[0], 'optionalAccess', _92 => _92.text])) {
+      let usageMetadata = null;
+      for await (const resp of responses) {
+        response = resp;
+        const llmResponse = LlmResponse.create(resp);
+        usageMetadata = llmResponse.usageMetadata;
+        if (_optionalChain([llmResponse, 'access', _74 => _74.content, 'optionalAccess', _75 => _75.parts, 'optionalAccess', _76 => _76[0], 'optionalAccess', _77 => _77.text])) {
           const part0 = llmResponse.content.parts[0];
           if (part0.thought) {
             thoughtText += part0.text;
@@ -1918,7 +1960,7 @@ var OpenAiLlm = class extends BaseLlm {
             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 (_optionalChain([toolCall, 'access', _93 => _93.function, 'optionalAccess', _94 => _94.name])) {
-              accumulatedToolCalls[index].function.name += toolCall.function.name;
-            }
-            if (_optionalChain([toolCall, 'access', _95 => _95.function, 'optionalAccess', _96 => _96.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 (_optionalChain([toolCall, 'access', _97 => _97.function, 'optionalAccess', _98 => _98.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 && _optionalChain([response, 'access', _78 => _78.candidates, 'access', _79 => _79[0], 'optionalAccess', _80 => _80.finishReason]) === _genai.FinishReason.STOP) {
         const parts = [];
         if (thoughtText) {
           parts.push({ text: thoughtText, thought: true });
@@ -2010,561 +1993,656 @@ 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: ${_optionalChain([response, 'access', _99 => _99.usage, 'optionalAccess', _100 => _100.completion_tokens]) || 0} tokens`
-        );
-        yield llmResponse;
-      }
+      const llmResponse = LlmResponse.create(response);
+      this.logger.debug(
+        `Google response: ${_optionalChain([llmResponse, 'access', _81 => _81.usageMetadata, 'optionalAccess', _82 => _82.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 });
-      }
-    }
-    if (delta.tool_calls) {
-      for (const toolCall of delta.tool_calls) {
-        if (toolCall.type === "function" && _optionalChain([toolCall, 'access', _101 => _101.function, 'optionalAccess', _102 => _102.name])) {
-          parts.push({
-            functionCall: {
-              id: toolCall.id || "",
-              name: toolCall.function.name,
-              args: JSON.parse(toolCall.function.arguments || "{}")
-            }
-          });
-        }
-      }
-    }
-    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
-    });
+  hasInlineData(response) {
+    const parts = _optionalChain([response, 'access', _83 => _83.candidates, 'optionalAccess', _84 => _84[0], 'optionalAccess', _85 => _85.content, 'optionalAccess', _86 => _86.parts]);
+    return _optionalChain([parts, 'optionalAccess', _87 => _87.some, 'call', _88 => _88((part) => _optionalChain([part, 'optionalAccess', _89 => _89.inlineData]))]) || false;
   }
   /**
-   * Convert OpenAI message to ADK LlmResponse
+   * Convert LlmRequest contents to GoogleGenAI format
    */
-  openAiMessageToLlmResponse(choice, usage) {
-    const message = choice.message;
-    const parts = [];
-    if (message.content) {
-      parts.push({ text: message.content });
-    }
-    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 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)
-    });
+  convertContents(contents) {
+    return contents.map((content) => ({
+      role: content.role === "assistant" ? "model" : content.role,
+      parts: content.parts || [{ text: content.content || "" }]
+    }));
   }
   /**
-   * Convert ADK Content to OpenAI ChatCompletionMessage
+   * Preprocesses the request based on the API backend.
    */
-  contentToOpenAiMessage(content) {
-    const role = this.toOpenAiRole(content.role);
-    if (role === "system") {
-      return {
-        role: "system",
-        content: _optionalChain([content, 'access', _103 => _103.parts, 'optionalAccess', _104 => _104[0], 'optionalAccess', _105 => _105.text]) || ""
-      };
-    }
-    if (_optionalChain([content, 'access', _106 => _106.parts, 'optionalAccess', _107 => _107.some, 'call', _108 => _108((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 || {}
-              )
-            }
+  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);
           }
-        ]
-      };
-    }
-    if (_optionalChain([content, 'access', _109 => _109.parts, 'optionalAccess', _110 => _110.some, 'call', _111 => _111((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 (_optionalChain([content, 'access', _112 => _112.parts, 'optionalAccess', _113 => _113.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 (_optionalChain([part, 'access', _114 => _114.inline_data, 'optionalAccess', _115 => _115.mime_type]) && _optionalChain([part, 'access', _116 => _116.inline_data, 'optionalAccess', _117 => _117.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");
   }
   /**
-   * Convert ADK function declaration to OpenAI tool
+   * Sets display_name to null for the Gemini API (non-Vertex) backend.
    */
-  functionDeclarationToOpenAiTool(functionDeclaration) {
-    return {
-      type: "function",
-      function: {
-        name: functionDeclaration.name,
-        description: functionDeclaration.description || "",
-        parameters: functionDeclaration.parameters || {}
-      }
-    };
+  removeDisplayNameIfPresent(dataObj) {
+    if (_optionalChain([dataObj, 'optionalAccess', _90 => _90.displayName])) {
+      dataObj.displayName = null;
+    }
   }
   /**
-   * Convert ADK role to OpenAI role format
+   * Builds function declaration log string.
    */
-  toOpenAiRole(role) {
-    if (role === "model") {
-      return "assistant";
-    }
-    if (role === "system") {
-      return "system";
+  buildFunctionDeclarationLog(funcDecl) {
+    let paramStr = "{}";
+    if (_optionalChain([funcDecl, 'access', _91 => _91.parameters, 'optionalAccess', _92 => _92.properties])) {
+      paramStr = JSON.stringify(funcDecl.parameters.properties);
     }
-    return "user";
+    return `${funcDecl.name}: ${paramStr}`;
   }
   /**
-   * Convert OpenAI finish reason to ADK finish reason
+   * Provides the api client.
    */
-  toAdkFinishReason(openaiFinishReason) {
-    switch (openaiFinishReason) {
-      case "stop":
-      case "tool_calls":
-        return "STOP";
-      case "length":
-        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);
-          }
-        }
+  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 (0, _genai.GoogleGenAI)({
+          vertexai: true,
+          project,
+          location
+        });
+      } else if (apiKey) {
+        this._apiClient = new (0, _genai.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 this._apiClient;
   }
   /**
-   * Preprocess individual parts for OpenAI compatibility
+   * Gets the API backend type.
    */
-  preprocessPart(part) {
-    if (part.inline_data) {
-      if (!part.inline_data.mime_type || !part.inline_data.data) {
-        delete part.inline_data;
-      }
+  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 */;
     }
+    return this._apiBackend;
   }
   /**
-   * Detect content type for flow control
-   * This is a simplified implementation - you may need to adjust based on your specific requirements
+   * Gets the tracking headers.
    */
-  getContentType(content) {
-    if (content.includes("<thinking>") || content.includes("[thinking]")) {
-      return "thought";
+  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}`;
+      }
+      const languageLabel = `gl-node/${process.version}`;
+      const versionHeaderValue = `${frameworkLabel} ${languageLabel}`;
+      this._trackingHeaders = {
+        "x-goog-api-client": versionHeaderValue,
+        "user-agent": versionHeaderValue
+      };
     }
-    return "regular";
+    return this._trackingHeaders;
   }
   /**
-   * Check if response has inline data (similar to Google LLM)
+   * Gets the live API version.
    */
-  hasInlineData(response) {
-    const parts = _optionalChain([response, 'access', _118 => _118.content, 'optionalAccess', _119 => _119.parts]);
-    return _optionalChain([parts, 'optionalAccess', _120 => _120.some, 'call', _121 => _121((part) => part.inlineData)]) || false;
+  get liveApiVersion() {
+    return this.apiBackend === "VERTEX_AI" /* VERTEX_AI */ ? "v1beta1" : "v1alpha";
   }
   /**
-   * Gets the OpenAI client
+   * Gets the live API 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"
-        );
+  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 (0, _genai.GoogleGenAI)({
+          vertexai: true,
+          project,
+          location,
+          apiVersion: this.liveApiVersion
+        });
+      } else if (apiKey) {
+        this._liveApiClient = new (0, _genai.GoogleGenAI)({
+          apiKey,
+          apiVersion: this.liveApiVersion
+        });
+      } else {
+        throw new Error("API configuration required for live client");
       }
-      this._client = new (0, _openai2.default)({
-        apiKey
-      });
     }
-    return this._client;
+    return this._liveApiClient;
   }
 };
 
-// src/models/ai-sdk.ts
-init_logger();
-
-
-
-
-var _ai = require('ai');
-var AiSdkLlm = (_class7 = class extends BaseLlm {
+// src/models/openai-llm.ts
+var _openai = require('openai'); var _openai2 = _interopRequireDefault(_openai);
+var OpenAiLlm = class extends BaseLlm {
   
-  __init13() {this.logger = new Logger({ name: "AiSdkLlm" })}
   /**
-   * Constructor accepts a pre-configured LanguageModel instance
-   * @param model - Pre-configured LanguageModel from provider(modelName)
+   * Constructor for OpenAI LLM
    */
-  constructor(modelInstance) {
-    super(modelInstance.modelId || "ai-sdk-model");_class7.prototype.__init13.call(this);;
-    this.modelInstance = modelInstance;
+  constructor(model = "gpt-4o-mini") {
+    super(model);
   }
   /**
-   * Returns empty array - following Python ADK pattern
+   * Provides the list of supported models
    */
   static supportedModels() {
-    return [];
+    return ["gpt-3.5-.*", "gpt-4.*", "gpt-4o.*", "o1-.*", "o3-.*"];
   }
-  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: _optionalChain([request, 'access', _122 => _122.config, 'optionalAccess', _123 => _123.maxOutputTokens]),
-        temperature: _optionalChain([request, 'access', _124 => _124.config, 'optionalAccess', _125 => _125.temperature]),
-        topP: _optionalChain([request, 'access', _126 => _126.config, 'optionalAccess', _127 => _127.topP])
-      };
-      if (stream) {
-        const result = _ai.streamText.call(void 0, requestParams);
-        let accumulatedText = "";
-        for await (const delta of result.textStream) {
-          accumulatedText += delta;
+  /**
+   * 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 messages = (llmRequest.contents || []).map(
+      (content) => this.contentToOpenAiMessage(content)
+    );
+    let tools;
+    if (_optionalChain([llmRequest, 'access', _93 => _93.config, 'optionalAccess', _94 => _94.tools, 'optionalAccess', _95 => _95[0], 'optionalAccess', _96 => _96.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: _optionalChain([llmRequest, 'access', _97 => _97.config, 'optionalAccess', _98 => _98.maxOutputTokens]),
+      temperature: _optionalChain([llmRequest, 'access', _99 => _99.config, 'optionalAccess', _100 => _100.temperature]),
+      top_p: _optionalChain([llmRequest, 'access', _101 => _101.config, 'optionalAccess', _102 => _102.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 (_optionalChain([llmResponse, 'access', _103 => _103.content, 'optionalAccess', _104 => _104.parts, 'optionalAccess', _105 => _105[0], 'optionalAccess', _106 => _106.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 (_optionalChain([toolCall, 'access', _107 => _107.function, 'optionalAccess', _108 => _108.name])) {
+              accumulatedToolCalls[index].function.name += toolCall.function.name;
+            }
+            if (_optionalChain([toolCall, 'access', _109 => _109.function, 'optionalAccess', _110 => _110.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 (_optionalChain([toolCall, 'access', _111 => _111.function, 'optionalAccess', _112 => _112.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 _ai.generateText.call(void 0, 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: ${_optionalChain([response, 'access', _113 => _113.usage, 'optionalAccess', _114 => _114.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 (_optionalChain([llmRequest, 'access', _128 => _128.config, 'optionalAccess', _129 => _129.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: _ai.jsonSchema.call(void 0, 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" && _optionalChain([toolCall, 'access', _115 => _115.function, 'optionalAccess', _116 => _116.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;
-    }
-    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 };
+  openAiMessageToLlmResponse(choice, usage) {
+    const message = choice.message;
+    const parts = [];
+    if (message.content) {
+      parts.push({ text: message.content });
     }
-    if (_optionalChain([content, 'access', _130 => _130.parts, 'optionalAccess', _131 => _131.some, 'call', _132 => _132((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
+    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 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: _optionalChain([content, 'access', _117 => _117.parts, 'optionalAccess', _118 => _118[0], 'optionalAccess', _119 => _119.text]) || ""
+      };
+    }
+    if (_optionalChain([content, 'access', _120 => _120.parts, 'optionalAccess', _121 => _121.some, 'call', _122 => _122((part) => part.functionCall)])) {
+      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 (_optionalChain([content, 'access', _133 => _133.parts, 'optionalAccess', _134 => _134.some, 'call', _135 => _135((part) => part.functionResponse)])) {
-      const functionResponses = content.parts.filter(
+    if (_optionalChain([content, 'access', _123 => _123.parts, 'optionalAccess', _124 => _124.some, 'call', _125 => _125((part) => part.functionResponse)])) {
+      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 (_optionalChain([content, 'access', _126 => _126.parts, 'optionalAccess', _127 => _127.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 (_optionalChain([part, 'access', _128 => _128.inline_data, 'optionalAccess', _129 => _129.mime_type]) && _optionalChain([part, 'access', _130 => _130.inline_data, 'optionalAccess', _131 => _131.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";
     }
   }
-}, _class7);
+  /**
+   * 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 = _optionalChain([response, 'access', _132 => _132.content, 'optionalAccess', _133 => _133.parts]);
+    return _optionalChain([parts, 'optionalAccess', _134 => _134.some, 'call', _135 => _135((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 (0, _openai2.default)({
+        apiKey
+      });
+    }
+    return this._client;
+  }
+};
 
 // src/models/llm-registry.ts
 init_logger();
@@ -2640,6 +2718,25 @@ function registerProviders() {
 }
 registerProviders();
 
+// src/auth/auth-config.ts
+var AuthConfig = class {
+  /**
+   * The authentication scheme
+   */
+  
+  /**
+   * Additional context properties
+   */
+  
+  /**
+   * 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
-   */
-  
-  /**
-   * Additional context properties
-   */
-  
-  /**
-   * Constructor for AuthConfig
-   */
-  constructor(config) {
-    this.authScheme = config.authScheme;
-    this.context = config.context;
-  }
-};
-
 // src/auth/auth-handler.ts
 var AuthHandler = class {
   /**