@iqai/adk 0.1.19 → 0.1.21

package/dist/index.mjs

@@ -1353,7 +1353,7 @@ var BaseLlm = class {
    * @param llmRequest LlmRequest, the request to send to the LLM.
    * @returns BaseLLMConnection, the connection to the LLM.
    */
-  connect(llmRequest) {
+  connect(_llmRequest) {
     throw new Error(`Live connection is not supported for ${this.model}.`);
   }
 };
@@ -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];
+      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 (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 (thoughtText) {
+          parts.push({ text: thoughtText, thought: true });
         }
-        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
+        if (text) {
+          parts.push({ text });
+        }
+        yield new LlmResponse({
+          content: {
+            parts,
+            role: "model"
+          },
+          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;
-    }
-    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 (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
+    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: content.parts?.[0]?.text || ""
+      };
+    }
+    if (content.parts?.some((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 (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;
+    }
+    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 { role: "user", content: contentParts };
+    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 {
   /**
@@ -8010,6 +8088,9 @@ var IdentityLlmRequestProcessor = class extends BaseLlmRequestProcessor {
 };
 var requestProcessor5 = new IdentityLlmRequestProcessor();
 
+// src/flows/llm-flows/instructions.ts
+import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
+
 // src/utils/instructions-utils.ts
 async function injectSessionState(template, readonlyContext) {
   const invocationContext = readonlyContext._invocationContext;
@@ -8124,6 +8205,22 @@ var InstructionsLlmRequestProcessor = class extends BaseLlmRequestProcessor {
       }
       llmRequest.appendInstructions([instruction]);
     }
+    if (agent.outputSchema) {
+      try {
+        const raw = zodToJsonSchema2(agent.outputSchema, {
+          target: "jsonSchema7",
+          $refStrategy: "none"
+        });
+        const { $schema, ...json } = raw || {};
+        llmRequest.appendInstructions([
+          "You must respond with application/json that validates against this JSON Schema:",
+          "```json",
+          JSON.stringify(json, null, 2),
+          "```"
+        ]);
+      } catch {
+      }
+    }
     for await (const _ of []) {
       yield _;
     }
@@ -8415,12 +8512,87 @@ function removeThoughtFromRequest(llmRequest) {
 var requestProcessor7 = new NlPlanningRequestProcessor();
 var responseProcessor2 = new NlPlanningResponseProcessor();
 
+// src/flows/llm-flows/output-schema.ts
+init_logger();
+var OutputSchemaResponseProcessor = class extends BaseLlmResponseProcessor {
+  logger = new Logger({ name: "OutputSchemaResponseProcessor" });
+  async *runAsync(invocationContext, llmResponse) {
+    if (!llmResponse || !llmResponse.content || !llmResponse.content.parts || llmResponse.content.parts.length === 0) {
+      return;
+    }
+    const agent = invocationContext.agent;
+    if (!("outputSchema" in agent) || !agent.outputSchema) {
+      return;
+    }
+    let textContent = llmResponse.content.parts.map((part) => {
+      if (part && typeof part === "object" && "text" in part) {
+        return part.text || "";
+      }
+      return "";
+    }).join("");
+    if (!textContent.trim()) {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(textContent);
+      const validated = agent.outputSchema.parse(parsed);
+      textContent = JSON.stringify(validated, null, 2);
+      llmResponse.content.parts = llmResponse.content.parts.map((part) => {
+        if (part && typeof part === "object" && "text" in part) {
+          return {
+            ...part,
+            text: textContent
+          };
+        }
+        return part;
+      });
+      this.logger.debug("Output schema validation successful", {
+        agent: agent.name,
+        originalLength: textContent.length,
+        validatedKeys: Object.keys(validated)
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const detailedError = `Output schema validation failed for agent '${agent.name}': ${errorMessage}`;
+      this.logger.error(detailedError, {
+        agent: agent.name,
+        responseContent: textContent.substring(0, 200) + (textContent.length > 200 ? "..." : ""),
+        error: errorMessage
+      });
+      llmResponse.errorCode = "OUTPUT_SCHEMA_VALIDATION_FAILED";
+      llmResponse.errorMessage = detailedError;
+      llmResponse.error = new Error(detailedError);
+      const errorEvent = new Event({
+        id: Event.newId(),
+        invocationId: invocationContext.invocationId,
+        author: agent.name,
+        branch: invocationContext.branch,
+        content: {
+          role: "assistant",
+          parts: [
+            {
+              text: `Error: ${detailedError}`
+            }
+          ]
+        }
+      });
+      errorEvent.errorCode = "OUTPUT_SCHEMA_VALIDATION_FAILED";
+      errorEvent.errorMessage = detailedError;
+      errorEvent.error = new Error(detailedError);
+      yield errorEvent;
+    }
+  }
+};
+var responseProcessor3 = new OutputSchemaResponseProcessor();
+
 // src/flows/llm-flows/shared-memory.ts
 var SharedMemoryRequestProcessor = class extends BaseLlmRequestProcessor {
   async *runAsync(invocationContext, llmRequest) {
     const memoryService = invocationContext.memoryService;
     if (!memoryService) return;
-    const lastUserEvent = invocationContext.session.events.findLast((e) => e.author === "user" && e.content?.parts?.length);
+    const lastUserEvent = invocationContext.session.events.findLast(
+      (e) => e.author === "user" && e.content?.parts?.length
+    );
     if (!lastUserEvent) return;
     const query = (lastUserEvent.content.parts ?? []).map((p) => p.text || "").join(" ");
     const results = await memoryService.searchMemory({
@@ -8479,8 +8651,10 @@ var SingleFlow = class extends BaseLlmFlow {
     this.responseProcessors.push(
       responseProcessor2,
       // Phase 5: NL Planning
+      responseProcessor3,
+      // Phase 6: Output Schema validation and parsing - validates response against agent's output schema
       responseProcessor
-      // Phase 5: Code Execution (placeholder)
+      // Phase 7: Code Execution (placeholder)
     );
     this.logger.debug("SingleFlow initialized with processors");
   }
@@ -8653,12 +8827,26 @@ var LlmAgent = class _LlmAgent extends BaseAgent {
    * The input schema when agent is used as a tool
    */
   inputSchema;
-  // Schema type - depends on specific implementation
   /**
    * The output schema when agent replies
    */
   outputSchema;
-  // Schema type - depends on specific implementation
+  /**
+   * Callback or list of callbacks to be called before calling the LLM
+   */
+  beforeModelCallback;
+  /**
+   * Callback or list of callbacks to be called after calling the LLM
+   */
+  afterModelCallback;
+  /**
+   * Callback or list of callbacks to be called before calling a tool
+   */
+  beforeToolCallback;
+  /**
+   * Callback or list of callbacks to be called after calling a tool
+   */
+  afterToolCallback;
   logger = new Logger({ name: "LlmAgent" });
   /**
    * Constructor for LlmAgent
@@ -8689,6 +8877,11 @@ var LlmAgent = class _LlmAgent extends BaseAgent {
     this.generateContentConfig = config.generateContentConfig;
     this.inputSchema = config.inputSchema;
     this.outputSchema = config.outputSchema;
+    this.beforeModelCallback = config.beforeModelCallback;
+    this.afterModelCallback = config.afterModelCallback;
+    this.beforeToolCallback = config.beforeToolCallback;
+    this.afterToolCallback = config.afterToolCallback;
+    this.validateOutputSchemaConfig();
   }
   /**
    * The resolved model field as BaseLLM
@@ -8705,13 +8898,15 @@ var LlmAgent = class _LlmAgent extends BaseAgent {
       return new AiSdkLlm(this.model);
     }
     let ancestorAgent = this.parentAgent;
-    while (ancestorAgent !== null) {
+    while (ancestorAgent !== null && ancestorAgent !== void 0) {
       if (ancestorAgent instanceof _LlmAgent) {
         return ancestorAgent.canonicalModel;
       }
       ancestorAgent = ancestorAgent.parentAgent;
     }
-    throw new Error(`No model found for ${this.name}.`);
+    throw new Error(
+      `No model found for agent "${this.name}". Please specify a model directly on this agent using the 'model' property`
+    );
   }
   /**
    * The resolved instruction field to construct instruction for this agent
@@ -8751,6 +8946,80 @@ var LlmAgent = class _LlmAgent extends BaseAgent {
     }
     return resolvedTools;
   }
+  /**
+   * Gets the canonical before model callbacks as an array
+   */
+  get canonicalBeforeModelCallbacks() {
+    if (!this.beforeModelCallback) {
+      return [];
+    }
+    if (Array.isArray(this.beforeModelCallback)) {
+      return this.beforeModelCallback;
+    }
+    return [this.beforeModelCallback];
+  }
+  /**
+   * Gets the canonical after model callbacks as an array
+   */
+  get canonicalAfterModelCallbacks() {
+    if (!this.afterModelCallback) {
+      return [];
+    }
+    if (Array.isArray(this.afterModelCallback)) {
+      return this.afterModelCallback;
+    }
+    return [this.afterModelCallback];
+  }
+  /**
+   * Gets the canonical before tool callbacks as an array
+   */
+  get canonicalBeforeToolCallbacks() {
+    if (!this.beforeToolCallback) {
+      return [];
+    }
+    if (Array.isArray(this.beforeToolCallback)) {
+      return this.beforeToolCallback;
+    }
+    return [this.beforeToolCallback];
+  }
+  /**
+   * Gets the canonical after tool callbacks as an array
+   */
+  get canonicalAfterToolCallbacks() {
+    if (!this.afterToolCallback) {
+      return [];
+    }
+    if (Array.isArray(this.afterToolCallback)) {
+      return this.afterToolCallback;
+    }
+    return [this.afterToolCallback];
+  }
+  /**
+   * Validates output schema configuration
+   * This matches the Python implementation's __check_output_schema
+   */
+  validateOutputSchemaConfig() {
+    if (!this.outputSchema) {
+      return;
+    }
+    if (!this.disallowTransferToParent || !this.disallowTransferToPeers) {
+      this.logger.warn(
+        `Invalid config for agent ${this.name}: output_schema cannot co-exist with agent transfer configurations. Setting disallow_transfer_to_parent=true, disallow_transfer_to_peers=true`
+      );
+      this.disallowTransferToParent = true;
+      this.disallowTransferToPeers = true;
+    }
+    if (this.subAgents && this.subAgents.length > 0) {
+      throw new Error(
+        `Invalid config for agent ${this.name}: if output_schema is set, sub_agents must be empty to disable agent transfer.`
+      );
+    }
+    if (this.tools && this.tools.length > 0) {
+      throw new Error(
+        `Invalid config for agent ${this.name}: if output_schema is set, tools must be empty`
+      );
+    }
+  }
   /**
    * Gets the appropriate LLM flow for this agent
    * This matches the Python implementation's _llm_flow property
@@ -8766,8 +9035,28 @@ var LlmAgent = class _LlmAgent extends BaseAgent {
    * This matches the Python implementation's __maybe_save_output_to_state
    */
   maybeSaveOutputToState(event) {
+    if (event.author !== this.name) {
+      this.logger.debug(
+        `Skipping output save for agent ${this.name}: event authored by ${event.author}`
+      );
+      return;
+    }
     if (this.outputKey && event.isFinalResponse() && event.content?.parts) {
-      const result = event.content.parts.map((part) => part.text || "").join("");
+      let result = event.content.parts.map((part) => part.text || "").join("");
+      if (this.outputSchema) {
+        if (!result.trim()) {
+          return;
+        }
+        try {
+          const parsed = JSON.parse(result);
+          result = this.outputSchema.parse(parsed);
+        } catch (error) {
+          this.logger.error("Failed to validate output with schema:", error);
+          throw new Error(
+            `Output validation failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
       if (result) {
         if (!event.actions.stateDelta) {
           event.actions.stateDelta = {};
@@ -10110,6 +10399,14 @@ var AgentBuilder = class _AgentBuilder {
     this.config.instruction = instruction;
     return this;
   }
+  withInputSchema(schema) {
+    this.config.inputSchema = schema;
+    return this;
+  }
+  withOutputSchema(schema) {
+    this.config.outputSchema = schema;
+    return this;
+  }
   /**
    * Add tools to the agent
    * @param tools Tools to add to the agent
@@ -10316,6 +10613,14 @@ var AgentBuilder = class _AgentBuilder {
     }
     return { agent, runner, session };
   }
+  /**
+   * Type-safe build method for agents with output schemas
+   * Provides better type inference for the ask method return type
+   */
+  async buildWithSchema() {
+    const result = await this.build();
+    return result;
+  }
   /**
    * Quick execution helper - build and run a message
    * @param message Message to send to the agent (string or full message object)
@@ -10350,7 +10655,9 @@ var AgentBuilder = class _AgentBuilder {
           memoryService: this.memoryService,
           artifactService: this.artifactService,
           outputKey: this.config.outputKey,
-          sessionService: this.sessionService
+          sessionService: this.sessionService,
+          inputSchema: this.config.inputSchema,
+          outputSchema: this.config.outputSchema
         });
       }
       case "sequential":
@@ -10409,14 +10716,16 @@ var AgentBuilder = class _AgentBuilder {
     return `app-${this.config.name}`;
   }
   /**
-   * Create enhanced runner with simplified API
+   * Create enhanced runner with simplified API and proper typing
    * @param baseRunner The base runner instance
    * @param session The session instance
    * @returns Enhanced runner with simplified API
    */
   createEnhancedRunner(baseRunner, session) {
     const sessionOptions = this.sessionOptions;
+    const outputSchema = this.config.outputSchema;
     return {
+      __outputSchema: outputSchema,
       async ask(message) {
         const newMessage = typeof message === "string" ? { parts: [{ text: message }] } : typeof message === "object" && "contents" in message ? { parts: message.contents[message.contents.length - 1].parts } : message;
         let response = "";
@@ -10437,6 +10746,18 @@ var AgentBuilder = class _AgentBuilder {
             }
           }
         }
+        if (outputSchema) {
+          try {
+            const parsed = JSON.parse(response);
+            return outputSchema.parse(parsed);
+          } catch (parseError) {
+            try {
+              return outputSchema.parse(response);
+            } catch (validationError) {
+              return response.trim();
+            }
+          }
+        }
         return response.trim();
       },
       runAsync(params) {