@falai/agent 2.7.0 → 3.1.0

package/src/providers/GeminiProvider.ts

@@ -1,704 +1,68 @@
 /**
- * Google Gemini AI provider implementation with retry and backup models
+ * Google Gemini.
+ *
+ * Thought signatures, the `functionResponse`-by-name pairing, implicit cache
+ * hits and the thinking levels are all in `@providerkit/core`, written against
+ * the REST API rather than the SDK.
+ *
+ * v3 sends a response schema alongside tools when a caller asks for both. v2
+ * dropped the schema in that case, from a 2024-era constraint that no longer
+ * holds — a sibling codebase runs the combination in production today.
  */
 
-import type {
-  GoogleGenAI as GoogleGenAIType,
-  GenerateContentConfig,
-  GenerateContentResponse,
-  Schema,
-  FunctionDeclaration,
-} from "@google/genai";
-import { GoogleGenAI, Type } from "@google/genai";
+import { createGeminiProvider } from "@providerkit/core";
 
-import type {
-  AiProvider,
-  GenerateMessageInput,
-  GenerateMessageOutput,
-  GenerateMessageStreamChunk,
-  AgentStructuredResponse,
-  StructuredSchema,
-} from "../types";
-import type { ProviderCapabilities } from "../types/ai";
-import type { HistoryItem } from "../types/history";
-import { withTimeoutAndRetry, withStreamRetry, withBackupFallback, streamWithBackupFallback, backupFallbackLogging, resolveRetryConfig, combineAbortSignals } from "../utils/retry";
-import { assertUsableCompletion } from "../utils/completion";
-import { tryParseJSONResponse } from "../utils/json";
-import { logger } from "../utils/logger";
-import {
-  classifyProviderError,
-  isBackupEligible,
-  isRetriableProviderError,
-  toProviderError,
-  type ErrorClassificationOptions,
-} from "./errorClassification";
+import type { ProviderCapabilities } from "../types/ai.js";
+import { ProviderAdapter, type RequestConfig } from "./ProviderAdapter.js";
 
-/**
- * Configuration options for Gemini provider
- * Uses types from @google/genai package
- */
 export interface GeminiProviderOptions {
-  /** Gemini API key. Optional when `client` is injected (tests). */
-  apiKey?: string;
-  /** Model to use (required) - e.g., "gemini-3.1-pro-preview" */
+  /** Gemini API key */
+  apiKey: string;
+  /** Model to use (required) — e.g. "gemini-3.1-pro-preview" */
   model: string;
-  /** Backup models to try if primary fails (default: []) */
+  /** Backup models to try if the primary fails (default: []) */
   backupModels?: string[];
-  /** Default generation config - uses GenerateContentConfig from @google/genai */
-  config?: Partial<GenerateContentConfig>;
-  /** Retry configuration */
-  retryConfig?: {
-    timeout?: number;
-    retries?: number;
-  };
-  /**
-   * Pre-configured SDK client. Overrides the internally-constructed one.
-   * Intended for tests injecting scripted transports; production callers
-   * should pass `apiKey` instead.
-   */
-  client?: GoogleGenAIType;
+  /** Any endpoint speaking the Gemini generateContent dialect. */
+  baseUrl?: string;
+  /** Request defaults sent with every call */
+  config?: RequestConfig;
+  /** Idle-stream deadline and retry budget */
+  retryConfig?: { timeout?: number; retries?: number };
+  /** Replacement `fetch`, for tests that script the wire. Replaces v2's
+   *  injected SDK client — see {@link AnthropicProviderOptions.fetchImpl}. */
+  fetchImpl?: typeof fetch;
 }
 
-/**
- * Gemini-specific error classification signals ("overloaded" code plus
- * the "not available"/"INTERNAL" message patterns Gemini emits).
- */
-const CLASSIFICATION_OPTIONS: ErrorClassificationOptions = {
-  overloadedCodes: ["overloaded"],
-  overloadedMessages: ["not available", "INTERNAL"],
-};
-
-/**
- * Determines if an error should trigger backup model usage.
- * Derived from the normalized error classification.
- */
-const shouldUseBackupModel = (error: unknown): boolean =>
-  isBackupEligible(classifyProviderError(error, CLASSIFICATION_OPTIONS));
-
-/**
- * Gemini provider implementation with backup models and retry logic
- */
-export class GeminiProvider implements AiProvider {
+export class GeminiProvider extends ProviderAdapter {
   public readonly name = "gemini";
   public readonly capabilities: ProviderCapabilities = {
     supportsTools: true,
     supportsNativeJsonSchema: true,
     supportsStreaming: true,
     supportsStreamingToolCalls: true,
-    supportsPromptCaching: false,
+    supportsPromptCaching: true,
   };
-  private genAI: GoogleGenAIType;
-  private primaryModel: string;
-  private backupModels: string[];
-  private config?: Partial<GenerateContentConfig>;
-  private retryConfig: { timeout: number; retries: number };
 
   constructor(options: GeminiProviderOptions) {
-    const { apiKey, model, backupModels = [], config, retryConfig, client } = options;
-
-    if (!client && !apiKey) {
-      throw new Error("Gemini API key is required");
-    }
-
-    if (!model) {
+    if (!options.apiKey) throw new Error("Gemini API key is required");
+    if (!options.model) {
       throw new Error("Model is required. Example: 'gemini-3.1-pro-preview'");
     }
 
-    this.genAI = client ?? new GoogleGenAI({ apiKey });
-    this.primaryModel = model;
-    this.backupModels = backupModels;
-    this.config = config;
-    this.retryConfig = resolveRetryConfig(retryConfig);
-  }
-
-  /**
-   * Build Gemini-formatted contents from HistoryItem[] array.
-   * Gemini uses "user"/"model" roles (not "assistant").
-   * System messages are extracted separately for systemInstruction.
-   * Tool results map to functionResponse parts, tool calls to functionCall parts.
-   */
-  private buildGeminiContents(history: HistoryItem[]): {
-    contents: Array<{ role: string; parts: Array<Record<string, unknown>> }>;
-    systemInstructions: string[];
-  } {
-    const contents: Array<{ role: string; parts: Array<Record<string, unknown>> }> = [];
-    const systemInstructions: string[] = [];
-
-    for (const item of history) {
-      switch (item.role) {
-        case "system":
-          systemInstructions.push(item.content);
-          break;
-        case "user":
-          contents.push({ role: "user", parts: [{ text: item.content }] });
-          break;
-        case "assistant":
-          if (item.tool_calls && item.tool_calls.length > 0) {
-            const parts: Array<Record<string, unknown>> = [];
-            if (item.content) {
-              parts.push({ text: item.content });
-            }
-            for (const tc of item.tool_calls) {
-              parts.push({
-                functionCall: { name: tc.name, args: tc.arguments },
-              });
-            }
-            contents.push({ role: "model", parts });
-          } else {
-            contents.push({ role: "model", parts: [{ text: item.content || "" }] });
-          }
-          break;
-        case "tool":
-          contents.push({
-            role: "user",
-            parts: [
-              {
-                functionResponse: {
-                  name: item.name,
-                  response: typeof item.content === "object" ? item.content : { result: item.content },
-                },
-              },
-            ],
-          });
-          break;
-      }
-    }
-
-    return { contents, systemInstructions };
-  }
-
-  /**
-   * Convert tool parameter schemas (JSON Schema) to Gemini's Schema format.
-   * Gemini's FunctionDeclaration.parameters expects its own Schema type,
-   * not raw JSON Schema. This method handles the conversion, including
-   * edge cases like empty objects that Gemini rejects.
-   *
-   * @private
-   */
-  private convertToolParameters(parameters: unknown): Schema | undefined {
-    if (!parameters || typeof parameters !== "object") {
-      return undefined;
-    }
-    try {
-      return this.adaptSchemaForGemini(parameters as StructuredSchema);
-    } catch (error) {
-      logger.warn(`[GeminiProvider] Failed to convert tool parameters, passing as-is:`, error);
-      return parameters as Schema;
-    }
-  }
-
-  /**
-   * Safely extract text from a Gemini response or chunk.
-   * Bypasses the SDK's `.text` getter entirely to avoid warnings about
-   * non-text parts (e.g., "thoughtSignature") in the response.
-   * Manually concatenates only text parts from candidates.
-   *
-   * @private
-   */
-  private safeExtractText(responseOrChunk: { text?: string; candidates?: Array<{ content?: { parts?: Array<{ text?: string; thought?: boolean; functionCall?: unknown }> } }> }): string {
-    // Always extract text parts manually to avoid SDK warnings about
-    // non-text parts like "thoughtSignature" in the response.
-    const parts = responseOrChunk.candidates?.[0]?.content?.parts;
-    if (parts) {
-      // Exclude reasoning parts (thought: true) — with includeThoughts enabled
-      // they carry text but must never leak into the user-facing message.
-      return parts
-        .filter((p) => p.text != null && !p.thought)
-        .map((p) => p.text)
-        .join("");
-    }
-    // Fallback: try the .text getter if no candidates structure exists
-    try {
-      return responseOrChunk.text || "";
-    } catch {
-      return "";
-    }
-  }
-
-  /**
-   * Build Gemini function declarations from framework tool definitions.
-   * Converts JSON Schema parameters to Gemini's Schema format.
-   *
-   * @private
-   */
-  private buildFunctionDeclarations(
-    tools: Array<{ id: string; name?: string; description?: string; parameters?: unknown }>
-  ): FunctionDeclaration[] {
-    return tools.map((tool) => ({
-      name: tool.name || tool.id,
-      description: tool.description || "",
-      parameters: this.convertToolParameters(tool.parameters),
-    }));
-  }
-
-  /**
-   * Adapt common schema format to Gemini's specific requirements.
-   * Gemini has strict validation:
-   * - OBJECT types MUST have non-empty properties
-   * - Empty objects cause 400 Bad Request errors
-   * - Uses Gemini's Schema type with Type enums
-   *
-   * @private
-   */
-  private adaptSchemaForGemini(schema: StructuredSchema): Schema {
-    const geminiSchema: Schema = {};
-
-    // Convert type
-    if (schema.type) {
-      if (Array.isArray(schema.type)) {
-        // For now, take the first type (Gemini doesn't support union types the same way)
-        geminiSchema.type = this.mapToGeminiType(schema.type[0]);
-      } else {
-        geminiSchema.type = this.mapToGeminiType(schema.type);
-      }
-    }
-
-    // Handle description
-    if (schema.description) {
-      geminiSchema.description = schema.description;
-    }
-
-    // Handle nullable
-    if (schema.nullable !== undefined) {
-      geminiSchema.nullable = schema.nullable;
-    }
-
-    // Handle enum
-    if (schema.enum) {
-      geminiSchema.enum = schema.enum as string[];
-    }
-
-    // Handle object properties - Gemini requires non-empty properties for OBJECT type
-    if (
-      geminiSchema.type === Type.OBJECT ||
-      schema.type === "object" ||
-      (Array.isArray(schema.type) && schema.type.includes("object"))
-    ) {
-      if (!schema.properties || Object.keys(schema.properties).length === 0) {
-        logger.warn(
-          "[GeminiProvider] Gemini requires OBJECT types to have non-empty properties. Converting empty object to STRING."
-        );
-        geminiSchema.type = Type.STRING;
-        return geminiSchema;
-      }
-
-      // Recursively convert nested properties
-      geminiSchema.properties = {};
-      for (const [key, value] of Object.entries(schema.properties)) {
-        geminiSchema.properties[key] = this.adaptSchemaForGemini(value);
-      }
-
-      // Handle required fields
-      if (schema.required && schema.required.length > 0) {
-        geminiSchema.required = schema.required;
-      }
-    }
-
-    // Handle array items
-    if (
-      geminiSchema.type === Type.ARRAY ||
-      schema.type === "array" ||
-      (Array.isArray(schema.type) && schema.type.includes("array"))
-    ) {
-      if (schema.items) {
-        geminiSchema.items = this.adaptSchemaForGemini(schema.items);
-      }
-    }
-
-    return geminiSchema;
-  }
-
-  /**
-   * Map common JSON Schema type strings to Gemini's Type enum
-   * @private
-   */
-  private mapToGeminiType(type: string): Type {
-    switch (type.toLowerCase()) {
-      case "string":
-        return Type.STRING;
-      case "number":
-        return Type.NUMBER;
-      case "integer":
-        return Type.INTEGER;
-      case "boolean":
-        return Type.BOOLEAN;
-      case "array":
-        return Type.ARRAY;
-      case "object":
-        return Type.OBJECT;
-      default:
-        logger.warn(
-          `[GeminiProvider] Unknown type "${type}", defaulting to STRING`
-        );
-        return Type.STRING;
-    }
-  }
-
-  async generateMessage<
-    TContext = unknown,
-    TStructured = AgentStructuredResponse
-  >(
-    input: GenerateMessageInput<TContext>
-  ): Promise<GenerateMessageOutput<TStructured>> {
-    return this.generateWithBackup<TContext, TStructured>(input);
-  }
-
-  async *generateMessageStream<
-    TContext = unknown,
-    TStructured = AgentStructuredResponse
-  >(
-    input: GenerateMessageInput<TContext>
-  ): AsyncGenerator<GenerateMessageStreamChunk<TStructured>> {
-    yield* this.generateStreamWithBackup<TContext, TStructured>(input);
-  }
-
-  private async generateWithBackup<
-    TContext = unknown,
-    TStructured = AgentStructuredResponse
-  >(
-    input: GenerateMessageInput<TContext>
-  ): Promise<GenerateMessageOutput<TStructured>> {
-    const observer = backupFallbackLogging("[GEMINI]", shouldUseBackupModel);
-
-    try {
-      return await withBackupFallback({
-        models: [this.primaryModel, ...this.backupModels],
-        attempt: (model) =>
-          this.generateWithModel<TContext, TStructured>(model, input),
-        shouldTryBackup: shouldUseBackupModel,
-        ...observer.callbacks,
-      });
-    } catch (error: unknown) {
-      observer.logExhausted(error);
-      throw toProviderError(error, this.name, CLASSIFICATION_OPTIONS);
-    }
-  }
-
-  private async generateWithModel<
-    TContext = unknown,
-    TStructured = AgentStructuredResponse
-  >(
-    model: string,
-    input: GenerateMessageInput<TContext>
-  ): Promise<GenerateMessageOutput<TStructured>> {
-    const operation = async (signal: AbortSignal): Promise<GenerateMessageOutput> => {
-      // Schema-required: configure response schema
-      const configOverride: Partial<GenerateContentConfig> = { ...this.config };
-
-      // Handle tools and JSON schema - Gemini doesn't support both simultaneously
-      const hasTools = input.tools && input.tools.length > 0;
-      const hasJsonSchema = input.parameters?.jsonSchema;
-
-      if (hasTools && hasJsonSchema) {
-        logger.debug(`[GeminiProvider] Both tools and JSON schema provided. Prioritizing function calling - JSON schema will be ignored.`);
-      }
-
-      if (hasTools) {
-        const toolNames = input.tools?.map((tool) => tool.name || tool.id) || [];
-        logger.debug(`[GeminiProvider] Configuring ${toolNames.length} tools for model ${model}:`, toolNames);
-        const functionDeclarations = this.buildFunctionDeclarations(input.tools!);
-        configOverride.tools = [{ functionDeclarations }];
-
-      } else if (hasJsonSchema) {
-        // Only set JSON schema if no tools are present
-        configOverride.responseMimeType = "application/json";
-        // Adapt common schema format to Gemini's specific requirements
-        configOverride.responseSchema = input.parameters ? this.adaptSchemaForGemini(
-          input.parameters.jsonSchema
-        ) : {};
-      }
-
-      let response: GenerateContentResponse;
-      try {
-        // Build contents from history
-        const { contents: historyContents, systemInstructions } = this.buildGeminiContents(input.history);
-
-        // Append the current prompt as the final user content
-        historyContents.push({ role: "user", parts: [{ text: input.prompt }] });
-
-        // Set system instruction from history if present
-        if (systemInstructions.length > 0) {
-          const existingSystem = configOverride.systemInstruction;
-          if (typeof existingSystem === "string") {
-            configOverride.systemInstruction = `${existingSystem}\n\n${systemInstructions.join("\n\n")}`;
-          } else {
-            configOverride.systemInstruction = systemInstructions.join("\n\n");
-          }
-        }
-
-        const reqSignal = combineAbortSignals(input.signal, signal);
-        response = await this.genAI.models.generateContent({
-          model,
-          contents: historyContents,
-          config: {
-            ...configOverride,
-            ...(reqSignal ? { abortSignal: reqSignal } : {}),
-          },
-        });
-      } catch (error: unknown) {
-        logger.error(`[GeminiProvider] API call failed:`, error);
-        throw error;
-      }
-
-      // Extract tool calls from response first
-      const toolCalls: Array<{
-        toolName: string;
-        arguments: Record<string, unknown>;
-      }> = [];
-
-      // Check for function calls in the response content
-      if (response.candidates && response.candidates[0]?.content?.parts) {
-        for (const part of response.candidates[0].content.parts) {
-          if (part.functionCall) {
-            toolCalls.push({
-              toolName: part.functionCall.name || "",
-              arguments: (part.functionCall.args as Record<string, unknown>) || {},
-            });
-          }
-        }
-      }
-
-      // Safely extract text — avoids SDK warning about non-text parts
-      const message = this.safeExtractText(response);
-
-      // Debug logging for response structure
-      if (!message && toolCalls.length === 0) {
-        logger.debug(`[GeminiProvider] Debug - Response structure:`, {
-          candidatesCount: response.candidates?.length || 0,
-          firstCandidateParts: response.candidates?.[0]?.content?.parts?.length || 0,
-        });
-      }
-
-      // Only throw error if we have no text AND no function calls
-      if (!message && toolCalls.length === 0) {
-        logger.error(`[GeminiProvider] Empty response - no text or function calls`);
-        logger.error(`[GeminiProvider] Response candidates:`, response.candidates);
-        throw new Error("No response from Gemini");
-      }
-
-      // Log when we have function calls but no text (this is normal)
-      if (toolCalls.length > 0 && !message) {
-        logger.debug(`[GeminiProvider] Function calls detected without text message:`, toolCalls.map(tc => tc.toolName));
-      }
-
-      // Parse JSON response if schema was provided
-      let structured: AgentStructuredResponse | undefined;
-      if (input.parameters?.jsonSchema) {
-        const parsed = tryParseJSONResponse(message);
-        if (parsed) {
-          structured = parsed as AgentStructuredResponse;
-        } else {
-          logger.warn("[GeminiProvider] Failed to parse JSON response, treating as plain text");
-        }
-      }
-
-      // If tools were used, include them in structured response
-      if (toolCalls.length > 0) {
-        structured = {
-          message: structured?.message || message,
-          toolCalls,
-          ...structured,
-        } as AgentStructuredResponse;
-      }
-
-      // A parsed-but-blank message with no tool calls is as empty as no text;
-      // the shared guard throws so withTimeoutAndRetry retries instead of
-      // returning {"message":""}.
-      assertUsableCompletion(structured, message, toolCalls.length, "Gemini");
-
-      return {
-        message,
-        metadata: {
-          model,
-          tokensUsed: response.usageMetadata?.totalTokenCount,
-          promptTokens: response.usageMetadata?.promptTokenCount,
-          completionTokens: response.usageMetadata?.candidatesTokenCount,
-        },
-        structured,
-      };
-    };
-
-    return withTimeoutAndRetry(
-      operation,
-      this.retryConfig.timeout,
-      this.retryConfig.retries,
-      `Gemini ${model}`,
-      (error) => isRetriableProviderError(error, CLASSIFICATION_OPTIONS)
-    ) as Promise<GenerateMessageOutput<TStructured>>;
-  }
-
-  private async *generateStreamWithBackup<
-    TContext = unknown,
-    TStructured = AgentStructuredResponse
-  >(
-    input: GenerateMessageInput<TContext>
-  ): AsyncGenerator<GenerateMessageStreamChunk<TStructured>> {
-    const observer = backupFallbackLogging("[GEMINI]", shouldUseBackupModel, { streaming: true });
-
-    try {
-      yield* streamWithBackupFallback({
-        models: [this.primaryModel, ...this.backupModels],
-        attempt: (model) =>
-          withStreamRetry(
-            (signal) => this.generateStreamWithModel<TContext, TStructured>(model, input, signal),
-            { maxRetries: this.retryConfig.retries, firstChunkTimeoutMs: this.retryConfig.timeout, operationName: `Gemini ${model} stream`, isRetriable: (error) => isRetriableProviderError(error, CLASSIFICATION_OPTIONS) }
-          ),
-        shouldTryBackup: shouldUseBackupModel,
-        ...observer.callbacks,
-      });
-    } catch (error: unknown) {
-      observer.logExhausted(error);
-      throw toProviderError(error, this.name, CLASSIFICATION_OPTIONS);
-    }
-  }
-
-  private async *generateStreamWithModel<
-    TContext = unknown,
-    TStructured = AgentStructuredResponse
-  >(
-    model: string,
-    input: GenerateMessageInput<TContext>,
-    attemptSignal?: AbortSignal
-  ): AsyncGenerator<GenerateMessageStreamChunk<TStructured>> {
-    // Caller cancellation + the retry helper's per-attempt deadline, as one.
-    const reqSignal = combineAbortSignals(input.signal, attemptSignal);
-    // Streaming: request JSON if schema provided
-    const configOverride: Partial<GenerateContentConfig> = { ...this.config };
-
-    // Handle tools and JSON schema - Gemini doesn't support both simultaneously
-    const hasTools = input.tools && input.tools.length > 0;
-    const hasJsonSchema = input.parameters?.jsonSchema;
-
-    if (hasTools && hasJsonSchema) {
-      logger.debug(`[GeminiProvider] Both tools and JSON schema provided. Prioritizing function calling - JSON schema will be ignored.`);
-    }
-
-    if (hasTools) {
-      const toolNames = input.tools?.map((tool) => tool.name || tool.id) || [];
-      logger.debug(`[GeminiProvider] Configuring ${toolNames.length} tools for streaming:`, toolNames);
-      const functionDeclarations = this.buildFunctionDeclarations(input.tools!);
-      configOverride.tools = [{ functionDeclarations }];
-
-    } else if (hasJsonSchema) {
-      // Only set JSON schema if no tools are present
-      configOverride.responseMimeType = "application/json";
-      // Adapt common schema format to Gemini's specific requirements
-      configOverride.responseSchema = input.parameters ? this.adaptSchemaForGemini(
-        input.parameters.jsonSchema
-      ) : {};
-    }
-
-    let stream;
-    try {
-      // Build contents from history
-      const { contents: historyContents, systemInstructions } = this.buildGeminiContents(input.history);
-
-      // Append the current prompt as the final user content
-      historyContents.push({ role: "user", parts: [{ text: input.prompt }] });
-
-      // Set system instruction from history if present
-      if (systemInstructions.length > 0) {
-        const existingSystem = configOverride.systemInstruction;
-        if (typeof existingSystem === "string") {
-          configOverride.systemInstruction = `${existingSystem}\n\n${systemInstructions.join("\n\n")}`;
-        } else {
-          configOverride.systemInstruction = systemInstructions.join("\n\n");
-        }
-      }
-
-      stream = await this.genAI.models.generateContentStream({
-        model,
-        contents: historyContents,
-        config: {
-          ...configOverride,
-          ...(reqSignal ? { abortSignal: reqSignal } : {}),
-        },
-      });
-    } catch (error: unknown) {
-      logger.error(`[GeminiProvider] Streaming API call failed:`, error);
-      throw error;
-    }
-
-    let accumulated = "";
-    let promptTokenCount = 0;
-    let candidatesTokenCount = 0;
-    let totalTokenCount = 0;
-    const toolCalls: Array<{
-      toolName: string;
-      arguments: Record<string, unknown>;
-    }> = [];
-
-    for await (const chunk of stream) {
-      if (reqSignal?.aborted) break;
-
-      // Safely extract text — chunk.text can throw when chunk has only function calls
-      const delta = this.safeExtractText(chunk);
-
-      // Extract tool calls from chunk
-      if (chunk.candidates && chunk.candidates[0]?.content?.parts) {
-        for (const part of chunk.candidates[0].content.parts) {
-          if (part.functionCall) {
-            toolCalls.push({
-              toolName: part.functionCall.name || "",
-              arguments: (part.functionCall.args as Record<string, unknown>) || {},
-            });
-          }
-        }
-      }
-
-      if (delta) {
-        accumulated += delta;
-        yield {
-          delta,
-          accumulated,
-          done: false,
-        };
-      }
-
-      // Update token counts if available
-      if (chunk.usageMetadata) {
-        promptTokenCount = chunk.usageMetadata.promptTokenCount || 0;
-        candidatesTokenCount = chunk.usageMetadata.candidatesTokenCount || 0;
-        totalTokenCount = chunk.usageMetadata.totalTokenCount || 0;
-      }
-    }
-
-    // Parse JSON response if schema was provided
-    let structured: AgentStructuredResponse | undefined;
-    if (input.parameters?.jsonSchema && accumulated) {
-      const parsed = tryParseJSONResponse(accumulated);
-      if (parsed) {
-        structured = parsed as AgentStructuredResponse;
-      } else {
-        logger.warn("[GeminiProvider] Failed to parse JSON response in stream, treating as plain text");
-      }
-    }
-
-    // Include tool calls in structured response (even without JSON schema)
-    if (toolCalls.length > 0) {
-      structured = {
-        message: structured?.message || accumulated,
-        ...structured,
-        toolCalls,
-      } as AgentStructuredResponse;
-    }
-
-    // Empty-completion guard — same definition as the non-streaming path, so the
-    // stream retries / falls back to backup instead of emitting an empty message.
-    assertUsableCompletion(structured, accumulated, toolCalls.length, "Gemini");
-
-    // Yield final chunk
-    yield {
-      delta: "",
-      accumulated,
-      done: true,
-      metadata: {
-        model,
-        tokensUsed: totalTokenCount,
-        promptTokens: promptTokenCount,
-        completionTokens: candidatesTokenCount,
-      },
-      structured: structured as TStructured | undefined,
-    };
+    super({
+      provider: createGeminiProvider({
+        apiKey: options.apiKey,
+        model: options.model,
+        id: "gemini",
+        ...(options.baseUrl ? { baseUrl: options.baseUrl } : {}),
+        ...(options.config?.maxTokens ? { maxTokens: options.config.maxTokens } : {}),
+        ...(options.config?.effort ? { effort: options.config.effort } : {}),
+        ...(options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}),
+      }),
+      model: options.model,
+      ...(options.config ? { defaults: options.config } : {}),
+      ...(options.backupModels ? { backupModels: options.backupModels } : {}),
+      ...(options.retryConfig ? { retryConfig: options.retryConfig } : {}),
+    });
   }
 }