@iqai/adk 0.1.19 → 0.1.21

package/dist/index.js

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22; var _class23; var _class24; var _class25; var _class26; var _class27; var _class28; var _class29; var _class30; var _class31; var _class32; var _class33;var __defProp = Object.defineProperty;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13; var _class14; var _class15; var _class16; var _class17; var _class18; var _class19; var _class20; var _class21; var _class22; var _class23; var _class24; var _class25; var _class26; var _class27; var _class28; var _class29; var _class30; var _class31; var _class32; var _class33; var _class34;var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
@@ -1353,7 +1353,7 @@ var BaseLlm = (_class5 = 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}.`);
   }
 }, _class5);
@@ -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 (toolCalls && toolCalls.length > 0) {
-          for (const toolCall of toolCalls) {
-            parts.push({
-              functionCall: {
-                id: toolCall.toolCallId,
-                name: toolCall.toolName,
-                args: toolCall.args
-              }
-            });
+        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;
+            }
           }
         }
-        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);
-        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 (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;
+        }
+      }
+      if ((text || thoughtText) && usageMetadata) {
+        const parts = [];
+        if (thoughtText) {
+          parts.push({ text: thoughtText, thought: true });
+        }
+        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
+      };
+    }
+    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', _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}`
+        }
+      };
+    }
+    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 (!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 transformedSchema;
+  }
+  /**
+   * Convert ADK function declaration to OpenAI tool
+   */
+  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";
+  }
+  /**
+   * 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";
+    }
+  }
+  /**
+   * 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);
+          }
+        }
       }
     }
-    if (contentParts.length === 0) {
-      return null;
-    }
-    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 };
+  }
+  /**
+   * 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;
       }
-      return { role: "user", content: textContent };
-    }
-    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 };
   }
   /**
-   * Map ADK role to AI SDK role
+   * Detect content type for flow control
+   * This is a simplified implementation - you may need to adjust based on your specific requirements
    */
-  mapRole(role) {
-    switch (role) {
-      case "model":
-      case "assistant":
-        return "assistant";
-      case "system":
-        return "system";
-      default:
-        return "user";
+  getContentType(content) {
+    if (content.includes("<thinking>") || content.includes("[thinking]")) {
+      return "thought";
     }
+    return "regular";
   }
   /**
-   * Map AI SDK finish reason to ADK finish reason
+   * Check if response has inline data (similar to Google LLM)
    */
-  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";
+  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;
   }
-}, _class7);
+};
 
 // 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 {
   /**
@@ -8010,6 +8088,9 @@ var IdentityLlmRequestProcessor = class extends BaseLlmRequestProcessor {
 };
 var requestProcessor5 = new IdentityLlmRequestProcessor();
 
+// src/flows/llm-flows/instructions.ts
+
+
 // 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 = _zodtojsonschema.zodToJsonSchema.call(void 0, 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 (e5) {
+      }
+    }
     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 = (_class26 = class extends BaseLlmResponseProcessor {constructor(...args2) { super(...args2); _class26.prototype.__init46.call(this); }
+  __init46() {this.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;
+    }
+  }
+}, _class26);
+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" && _optionalChain([e, 'access', _230 => _230.content, 'optionalAccess', _231 => _231.parts, 'optionalAccess', _232 => _232.length]));
+    const lastUserEvent = invocationContext.session.events.findLast(
+      (e) => e.author === "user" && _optionalChain([e, 'access', _230 => _230.content, 'optionalAccess', _231 => _231.parts, 'optionalAccess', _232 => _232.length])
+    );
     if (!lastUserEvent) return;
     const query = (_nullishCoalesce(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");
   }
@@ -8582,7 +8756,7 @@ var AutoFlow = class extends SingleFlow {
 
 // src/agents/llm-agent.ts
 init_function_tool();
-var LlmAgent = (_class26 = class _LlmAgent extends BaseAgent {
+var LlmAgent = (_class27 = class _LlmAgent extends BaseAgent {
   /**
    * The model to use for the agent
    * When not set, the agent will inherit the model from its ancestor
@@ -8653,13 +8827,27 @@ var LlmAgent = (_class26 = class _LlmAgent extends BaseAgent {
    * The input schema when agent is used as a tool
    */
   
-  // Schema type - depends on specific implementation
   /**
    * The output schema when agent replies
    */
   
-  // Schema type - depends on specific implementation
-  __init46() {this.logger = new Logger({ name: "LlmAgent" })}
+  /**
+   * Callback or list of callbacks to be called before calling the LLM
+   */
+  
+  /**
+   * Callback or list of callbacks to be called after calling the LLM
+   */
+  
+  /**
+   * Callback or list of callbacks to be called before calling a tool
+   */
+  
+  /**
+   * Callback or list of callbacks to be called after calling a tool
+   */
+  
+  __init47() {this.logger = new Logger({ name: "LlmAgent" })}
   /**
    * Constructor for LlmAgent
    */
@@ -8670,7 +8858,7 @@ var LlmAgent = (_class26 = class _LlmAgent extends BaseAgent {
       subAgents: config.subAgents,
       beforeAgentCallback: config.beforeAgentCallback,
       afterAgentCallback: config.afterAgentCallback
-    });_class26.prototype.__init46.call(this);;
+    });_class27.prototype.__init47.call(this);;
     this.model = config.model || "";
     this.instruction = config.instruction || "";
     this.globalInstruction = config.globalInstruction || "";
@@ -8689,6 +8877,11 @@ var LlmAgent = (_class26 = 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 = (_class26 = 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 = (_class26 = 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 = (_class26 = 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() && _optionalChain([event, 'access', _238 => _238.content, 'optionalAccess', _239 => _239.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 = {};
@@ -8806,7 +9095,7 @@ var LlmAgent = (_class26 = class _LlmAgent extends BaseAgent {
       yield errorEvent;
     }
   }
-}, _class26);
+}, _class27);
 
 // src/agents/sequential-agent.ts
 var SequentialAgent = class extends BaseAgent {
@@ -8998,7 +9287,7 @@ var LoopAgent = class extends BaseAgent {
 
 // src/agents/lang-graph-agent.ts
 init_logger();
-var LangGraphAgent = (_class27 = class extends BaseAgent {
+var LangGraphAgent = (_class28 = class extends BaseAgent {
   /**
    * Graph nodes (agents and their connections)
    */
@@ -9014,8 +9303,8 @@ var LangGraphAgent = (_class27 = class extends BaseAgent {
   /**
    * Results from node executions
    */
-  __init47() {this.results = []}
-  __init48() {this.logger = new Logger({ name: "LangGraphAgent" })}
+  __init48() {this.results = []}
+  __init49() {this.logger = new Logger({ name: "LangGraphAgent" })}
   /**
    * Constructor for LangGraphAgent
    */
@@ -9023,7 +9312,7 @@ var LangGraphAgent = (_class27 = class extends BaseAgent {
     super({
       name: config.name,
       description: config.description
-    });_class27.prototype.__init47.call(this);_class27.prototype.__init48.call(this);;
+    });_class28.prototype.__init48.call(this);_class28.prototype.__init49.call(this);;
     this.nodes = /* @__PURE__ */ new Map();
     for (const node of config.nodes) {
       if (this.nodes.has(node.name)) {
@@ -9219,7 +9508,7 @@ var LangGraphAgent = (_class27 = class extends BaseAgent {
     }
     this.maxSteps = maxSteps;
   }
-}, _class27);
+}, _class28);
 
 // src/agents/agent-builder.ts
 
@@ -9322,8 +9611,8 @@ var RunConfig = class {
 };
 
 // src/artifacts/in-memory-artifact-service.ts
-var InMemoryArtifactService = (_class28 = class {constructor() { _class28.prototype.__init49.call(this); }
-  __init49() {this.artifacts = /* @__PURE__ */ new Map()}
+var InMemoryArtifactService = (_class29 = class {constructor() { _class29.prototype.__init50.call(this); }
+  __init50() {this.artifacts = /* @__PURE__ */ new Map()}
   fileHasUserNamespace(filename) {
     return filename.startsWith("user:");
   }
@@ -9396,7 +9685,7 @@ var InMemoryArtifactService = (_class28 = class {constructor() { _class28.protot
     }
     return Array.from({ length: versions.length }, (_, i) => i);
   }
-}, _class28);
+}, _class29);
 
 // src/runners.ts
 init_logger();
@@ -9423,15 +9712,15 @@ function _extractWordsLower(text) {
   const words = text.match(/[A-Za-z]+/g) || [];
   return new Set(words.map((word) => word.toLowerCase()));
 }
-var InMemoryMemoryService = (_class29 = class {
+var InMemoryMemoryService = (_class30 = class {
   /**
    * Keys are app_name/user_id, session_id. Values are session event lists.
    */
-  __init50() {this._sessionEvents = /* @__PURE__ */ new Map()}
+  __init51() {this._sessionEvents = /* @__PURE__ */ new Map()}
   /**
    * Constructor for InMemoryMemoryService
    */
-  constructor() {;_class29.prototype.__init50.call(this);
+  constructor() {;_class30.prototype.__init51.call(this);
     this._sessionEvents = /* @__PURE__ */ new Map();
   }
   /**
@@ -9515,7 +9804,7 @@ var InMemoryMemoryService = (_class29 = class {
   clear() {
     this._sessionEvents.clear();
   }
-}, _class29);
+}, _class30);
 
 // src/sessions/in-memory-session-service.ts
 var _crypto = require('crypto');
@@ -9557,19 +9846,19 @@ var BaseSessionService = class {
 };
 
 // src/sessions/in-memory-session-service.ts
-var InMemorySessionService = (_class30 = class extends BaseSessionService {constructor(...args2) { super(...args2); _class30.prototype.__init51.call(this);_class30.prototype.__init52.call(this);_class30.prototype.__init53.call(this); }
+var InMemorySessionService = (_class31 = class extends BaseSessionService {constructor(...args3) { super(...args3); _class31.prototype.__init52.call(this);_class31.prototype.__init53.call(this);_class31.prototype.__init54.call(this); }
   /**
    * A map from app name to a map from user ID to a map from session ID to session.
    */
-  __init51() {this.sessions = /* @__PURE__ */ new Map()}
+  __init52() {this.sessions = /* @__PURE__ */ new Map()}
   /**
    * A map from app name to a map from user ID to a map from key to the value.
    */
-  __init52() {this.userState = /* @__PURE__ */ new Map()}
+  __init53() {this.userState = /* @__PURE__ */ new Map()}
   /**
    * A map from app name to a map from key to the value.
    */
-  __init53() {this.appState = /* @__PURE__ */ new Map()}
+  __init54() {this.appState = /* @__PURE__ */ new Map()}
   /**
    * Creates a new session.
    */
@@ -9766,7 +10055,7 @@ var InMemorySessionService = (_class30 = class extends BaseSessionService {const
     storageSession.lastUpdateTime = event.timestamp;
     return event;
   }
-}, _class30);
+}, _class31);
 
 // src/runners.ts
 function _findFunctionCallEventIfLastEventIsFunctionResponse(session) {
@@ -9792,7 +10081,7 @@ function _findFunctionCallEventIfLastEventIsFunctionResponse(session) {
   }
   return null;
 }
-var Runner = (_class31 = class {
+var Runner = (_class32 = class {
   /**
    * The app name of the runner.
    */
@@ -9813,7 +10102,7 @@ var Runner = (_class31 = class {
    * The memory service for the runner.
    */
   
-  __init54() {this.logger = new Logger({ name: "Runner" })}
+  __init55() {this.logger = new Logger({ name: "Runner" })}
   /**
    * Initializes the Runner.
    */
@@ -9823,7 +10112,7 @@ var Runner = (_class31 = class {
     artifactService,
     sessionService,
     memoryService
-  }) {;_class31.prototype.__init54.call(this);
+  }) {;_class32.prototype.__init55.call(this);
     this.appName = appName;
     this.agent = agent;
     this.artifactService = artifactService;
@@ -10030,7 +10319,7 @@ var Runner = (_class31 = class {
       runConfig
     });
   }
-}, _class31);
+}, _class32);
 var InMemoryRunner = class extends Runner {
   /**
    * Deprecated. Please don't use. The in-memory session service for the runner.
@@ -10053,18 +10342,18 @@ var InMemoryRunner = class extends Runner {
 };
 
 // src/agents/agent-builder.ts
-var AgentBuilder = (_class32 = class _AgentBuilder {
+var AgentBuilder = (_class33 = class _AgentBuilder {
   
   
   
   
   
-  __init55() {this.agentType = "llm"}
+  __init56() {this.agentType = "llm"}
   
   /**
    * Private constructor - use static create() method
    */
-  constructor(name) {;_class32.prototype.__init55.call(this);
+  constructor(name) {;_class33.prototype.__init56.call(this);
     this.config = { name };
   }
   /**
@@ -10110,6 +10399,14 @@ var AgentBuilder = (_class32 = 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 = (_class32 = 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 = (_class32 = 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 = (_class32 = 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 = (_class32 = 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) {
@@ -10444,7 +10765,7 @@ var AgentBuilder = (_class32 = class _AgentBuilder {
       }
     };
   }
-}, _class32);
+}, _class33);
 
 // src/memory/index.ts
 var memory_exports = {};
@@ -10778,11 +11099,11 @@ var VertexAiSessionService = class extends BaseSessionService {
 
 // src/sessions/database-session-service.ts
 var _kysely = require('kysely');
-var DatabaseSessionService = (_class33 = class extends BaseSessionService {
+var DatabaseSessionService = (_class34 = class extends BaseSessionService {
   
-  __init56() {this.initialized = false}
+  __init57() {this.initialized = false}
   constructor(config) {
-    super();_class33.prototype.__init56.call(this);;
+    super();_class34.prototype.__init57.call(this);;
     this.db = config.db;
     if (!config.skipTableCreation) {
       this.initializeDatabase().catch((error) => {
@@ -10857,7 +11178,7 @@ var DatabaseSessionService = (_class33 = class extends BaseSessionService {
     if (!jsonString) return defaultValue;
     try {
       return JSON.parse(jsonString);
-    } catch (e5) {
+    } catch (e6) {
       return defaultValue;
     }
   }
@@ -11176,7 +11497,7 @@ var DatabaseSessionService = (_class33 = class extends BaseSessionService {
       }
     }
   }
-}, _class33);
+}, _class34);
 
 // src/sessions/database-factories.ts