@llumiverse/drivers 1.2.0 → 1.4.0-dev.20260629.090753Z

package/src/groq/index.ts

@@ -1,21 +1,68 @@
-import { AbstractDriver, AIModel, Completion, CompletionChunkObject, DriverOptions, EmbeddingsOptions, EmbeddingsResult, ExecutionOptions, PromptSegment, TextFallbackOptions, ToolDefinition, ToolUse } from "@llumiverse/core";
-import { transformAsyncIterator } from "@llumiverse/core/async";
-import Groq from "groq-sdk";
-import type { ChatCompletionMessageParam, ChatCompletionTool } from "groq-sdk/resources/chat/completions";
-import type { FunctionParameters } from "groq-sdk/resources/shared";
-import type OpenAI from "openai";
-import { formatOpenAILikeMultimodalPrompt } from "../openai/openai_format.js";
+import type {
+    AIModel,
+    Completion,
+    CompletionChunkObject,
+    DriverOptions,
+    EmbeddingsOptions,
+    EmbeddingsResult,
+    ExecutionOptions,
+    PromptSegment,
+    TextFallbackOptions,
+    ToolDefinition,
+    ToolUse,
+} from '@llumiverse/core';
+import { transformAsyncIterator } from '@llumiverse/core/async';
+import { AbstractDriver } from '@llumiverse/core/driver';
+import Groq from 'groq-sdk';
+import type { ChatCompletionMessageParam, ChatCompletionTool } from 'groq-sdk/resources/chat/completions';
+import type { FunctionParameters } from 'groq-sdk/resources/shared';
+import type OpenAI from 'openai';
+import { formatOpenAILikeMultimodalPrompt } from '../openai/openai_format.js';
+import { truncateDataUrlForDebug } from '../shared/debug-prompt.js';
 
 type ResponseInputItem = OpenAI.Responses.ResponseInputItem;
 type EasyInputMessage = OpenAI.Responses.EasyInputMessage;
+type GroqToolCallMessage = {
+    tool_calls?: Array<{
+        id: string;
+        function: {
+            name: string;
+            arguments?: string;
+        };
+    }>;
+};
 
 interface GroqDriverOptions extends DriverOptions {
     apiKey: string;
     endpoint_url?: string;
 }
 
+type GroqTextContentPart = { type: 'text'; text: string };
+type GroqImageContentPart = { type: 'image_url'; image_url: { url: string; detail?: 'auto' | 'low' | 'high' } };
+type GroqContentPart = GroqTextContentPart | GroqImageContentPart;
+type GroqUserMessageWithArrayContent = Extract<ChatCompletionMessageParam, { role: 'user' }> & {
+    content: GroqContentPart[];
+};
+
+function hasGroqArrayContent(message: ChatCompletionMessageParam): message is GroqUserMessageWithArrayContent {
+    return message.role === 'user' && Array.isArray(message.content);
+}
+
+function formatGroqContentPartForDebug(part: GroqContentPart): GroqContentPart {
+    if (part.type !== 'image_url') {
+        return part;
+    }
+    return {
+        ...part,
+        image_url: {
+            ...part.image_url,
+            url: truncateDataUrlForDebug(part.image_url.url),
+        },
+    };
+}
+
 export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletionMessageParam[]> {
-    static PROVIDER = "groq";
+    static PROVIDER = 'groq';
     provider = GroqDriver.PROVIDER;
     apiKey: string;
     client: Groq;
@@ -26,7 +73,8 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
         this.apiKey = options.apiKey;
         this.client = new Groq({
             apiKey: options.apiKey,
-            baseURL: options.endpoint_url
+            baseURL: options.endpoint_url,
+            fetch: this.getDriverFetch(),
         });
     }
 
@@ -50,7 +98,10 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
         return undefined;
     }
 
-    protected async formatPrompt(segments: PromptSegment[], opts: ExecutionOptions): Promise<ChatCompletionMessageParam[]> {
+    protected async formatPrompt(
+        segments: PromptSegment[],
+        opts: ExecutionOptions,
+    ): Promise<ChatCompletionMessageParam[]> {
         // Use OpenAI's multimodal formatter as base then convert to Groq types
         const responseItems = await formatOpenAILikeMultimodalPrompt(segments, {
             ...opts,
@@ -61,27 +112,39 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
         return convertResponseItemsToGroqMessages(responseItems);
     }
 
+    public formatDebugPrompt(messages: ChatCompletionMessageParam[]): ChatCompletionMessageParam[] {
+        return messages.map((message) => {
+            if (!hasGroqArrayContent(message)) {
+                return message;
+            }
+            return {
+                ...message,
+                content: message.content.map(formatGroqContentPartForDebug),
+            };
+        });
+    }
+
     private getToolDefinitions(tools: ToolDefinition[] | undefined): ChatCompletionTool[] | undefined {
         if (!tools || tools.length === 0) {
             return undefined;
         }
 
-        return tools.map(tool => ({
+        return tools.map((tool) => ({
             type: 'function' as const,
             function: {
                 name: tool.name,
                 description: tool.description,
                 parameters: tool.input_schema satisfies FunctionParameters,
-            }
+            },
         }));
     }
 
-    private extractToolUse(message: any): ToolUse[] | undefined {
+    private extractToolUse(message: GroqToolCallMessage): ToolUse<unknown>[] | undefined {
         if (!message.tool_calls || message.tool_calls.length === 0) {
             return undefined;
         }
 
-        return message.tool_calls.map((toolCall: any) => ({
+        return message.tool_calls.map((toolCall) => ({
             id: toolCall.id,
             tool_name: toolCall.function.name,
             tool_input: JSON.parse(toolCall.function.arguments || '{}'),
@@ -89,27 +152,35 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
     }
 
     private sanitizeMessagesForGroq(messages: ChatCompletionMessageParam[]): ChatCompletionMessageParam[] {
-        return messages.map(message => {
+        return messages.map((message) => {
             // Remove any reasoning field from message objects
-            const { reasoning, ...sanitizedMessage } = message as any;
+            const sanitizedMessage = { ...(message as unknown as Record<string, unknown>) };
+            delete sanitizedMessage.reasoning;
 
             // If message has content array, filter out reasoning content types
-            if (Array.isArray(sanitizedMessage.content)) {
-                sanitizedMessage.content = sanitizedMessage.content.filter((part: any) => {
+            const content = sanitizedMessage.content;
+            if (Array.isArray(content)) {
+                sanitizedMessage.content = content.filter((part) => {
                     // Filter out any reasoning-related content parts
-                    return part.type !== 'reasoning' && !('reasoning' in part);
+                    const typedPart = part as { type?: string; reasoning?: unknown };
+                    return typedPart.type !== 'reasoning' && !('reasoning' in typedPart);
                 });
             }
 
-            return sanitizedMessage as ChatCompletionMessageParam;
+            return sanitizedMessage as unknown as ChatCompletionMessageParam;
         });
     }
 
-    async requestTextCompletion(messages: ChatCompletionMessageParam[], options: ExecutionOptions): Promise<Completion> {
-        if (options.model_options?._option_id !== undefined &&
-            options.model_options?._option_id !== "text-fallback" &&
-            options.model_options?._option_id !== "groq-deepseek-thinking") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
+    async requestTextCompletion(
+        messages: ChatCompletionMessageParam[],
+        options: ExecutionOptions,
+    ): Promise<Completion> {
+        if (
+            options.model_options?._option_id !== undefined &&
+            options.model_options?._option_id !== 'text-fallback' &&
+            options.model_options?._option_id !== 'groq-deepseek-thinking'
+        ) {
+            this.logger.debug({ options: options.model_options }, 'Unexpected option id');
         }
         options.model_options = options.model_options as TextFallbackOptions;
 
@@ -146,11 +217,11 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
 
         let finish_reason = choice.finish_reason;
         if (tool_use && tool_use.length > 0) {
-            finish_reason = "tool_calls";
+            finish_reason = 'tool_calls';
         }
 
         return {
-            result: result ? [{ type: "text", value: result }] : [],
+            result: result ? [{ type: 'text', value: result }] : [],
             token_usage: {
                 prompt: res.usage?.prompt_tokens,
                 result: res.usage?.completion_tokens,
@@ -163,9 +234,12 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
         };
     }
 
-    async requestTextCompletionStream(messages: ChatCompletionMessageParam[], options: ExecutionOptions): Promise<AsyncIterable<CompletionChunkObject>> {
-        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "text-fallback") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
+    async requestTextCompletionStream(
+        messages: ChatCompletionMessageParam[],
+        options: ExecutionOptions,
+    ): Promise<AsyncIterable<CompletionChunkObject>> {
+        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== 'text-fallback') {
+            this.logger.debug({ options: options.model_options }, 'Unexpected option id');
         }
         options.model_options = options.model_options as TextFallbackOptions;
 
@@ -197,11 +271,11 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
 
             // Check for tool calls in the delta
             if (choice.delta.tool_calls && choice.delta.tool_calls.length > 0) {
-                finish_reason = "tool_calls";
+                finish_reason = 'tool_calls';
             }
 
             return {
-                result: choice.delta.content ? [{ type: "text", value: choice.delta.content }] : [],
+                result: choice.delta.content ? [{ type: 'text', value: choice.delta.content }] : [],
                 finish_reason: finish_reason ?? undefined,
                 token_usage: {
                     prompt: chunk.x_groq?.usage?.prompt_tokens,
@@ -216,12 +290,12 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
         const models = await this.client.models.list();
 
         if (!models.data) {
-            throw new Error("No models found");
+            throw new Error('No models found');
         }
 
-        const aiModels = models.data?.map(m => {
+        const aiModels = models.data?.map((m) => {
             if (!m.id) {
-                throw new Error("Model id is missing");
+                throw new Error('Model id is missing');
             }
             return {
                 id: m.id,
@@ -229,20 +303,19 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
                 description: undefined,
                 provider: this.provider,
                 owner: m.owned_by || '',
-            }
+            };
         });
 
         return aiModels;
     }
 
     validateConnection(): Promise<boolean> {
-        throw new Error("Method not implemented.");
+        throw new Error('Method not implemented.');
     }
 
-    async generateEmbeddings({ }: EmbeddingsOptions): Promise<EmbeddingsResult> {
-        throw new Error("Method not implemented.");
+    async generateEmbeddings(_options: EmbeddingsOptions): Promise<EmbeddingsResult> {
+        throw new Error('Method not implemented.');
     }
-
 }
 
 /**
@@ -253,7 +326,7 @@ export class GroqDriver extends AbstractDriver<GroqDriverOptions, ChatCompletion
  */
 function updateConversation(
     conversation: ChatCompletionMessageParam[] | undefined,
-    messages: ChatCompletionMessageParam[]
+    messages: ChatCompletionMessageParam[],
 ): ChatCompletionMessageParam[] {
     return (conversation || []).concat(messages);
 }
@@ -278,7 +351,7 @@ function convertResponseItemsToGroqMessages(items: ResponseInputItem[]): ChatCom
                 } else if (Array.isArray(msg.content)) {
                     content = msg.content
                         .filter((part): part is OpenAI.Responses.ResponseInputText => part.type === 'input_text')
-                        .map(part => part.text)
+                        .map((part) => part.text)
                         .join('\n');
                 } else {
                     content = '';
@@ -289,11 +362,19 @@ function convertResponseItemsToGroqMessages(items: ResponseInputItem[]): ChatCom
 
             // Handle user messages
             if (role === 'user') {
-                let content: string | Array<{ type: 'text', text: string } | { type: 'image_url', image_url: { url: string, detail?: 'auto' | 'low' | 'high' } }>;
+                let content:
+                    | string
+                    | Array<
+                          | { type: 'text'; text: string }
+                          | { type: 'image_url'; image_url: { url: string; detail?: 'auto' | 'low' | 'high' } }
+                      >;
                 if (typeof msg.content === 'string') {
                     content = msg.content;
                 } else if (Array.isArray(msg.content)) {
-                    const parts: Array<{ type: 'text', text: string } | { type: 'image_url', image_url: { url: string, detail?: 'auto' | 'low' | 'high' } }> = [];
+                    const parts: Array<
+                        | { type: 'text'; text: string }
+                        | { type: 'image_url'; image_url: { url: string; detail?: 'auto' | 'low' | 'high' } }
+                    > = [];
                     for (const part of msg.content) {
                         if (part.type === 'input_text') {
                             parts.push({ type: 'text', text: part.text });
@@ -301,7 +382,7 @@ function convertResponseItemsToGroqMessages(items: ResponseInputItem[]): ChatCom
                             const imgPart = part as OpenAI.Responses.ResponseInputImage;
                             if (imgPart.image_url) {
                                 const image_url: { url: string; detail?: 'auto' | 'low' | 'high' } = {
-                                    url: imgPart.image_url
+                                    url: imgPart.image_url,
                                 };
 
                                 if (imgPart.detail) {
@@ -310,7 +391,7 @@ function convertResponseItemsToGroqMessages(items: ResponseInputItem[]): ChatCom
 
                                 parts.push({
                                     type: 'image_url',
-                                    image_url
+                                    image_url,
                                 });
                             }
                         }
@@ -329,10 +410,11 @@ function convertResponseItemsToGroqMessages(items: ResponseInputItem[]): ChatCom
                 if (typeof msg.content === 'string') {
                     content = msg.content;
                 } else if (Array.isArray(msg.content)) {
-                    content = msg.content
-                        .filter((part): part is OpenAI.Responses.ResponseInputText => part.type === 'input_text')
-                        .map(part => part.text)
-                        .join('\n') || null;
+                    content =
+                        msg.content
+                            .filter((part): part is OpenAI.Responses.ResponseInputText => part.type === 'input_text')
+                            .map((part) => part.text)
+                            .join('\n') || null;
                 } else {
                     content = null;
                 }
@@ -360,18 +442,19 @@ function convertResponseItemsToGroqMessages(items: ResponseInputItem[]): ChatCom
             messages.push({
                 role: 'assistant',
                 content: null,
-                tool_calls: [{
-                    id: call.call_id,
-                    type: 'function',
-                    function: {
-                        name: call.name,
-                        arguments: call.arguments,
-                    }
-                }]
+                tool_calls: [
+                    {
+                        id: call.call_id,
+                        type: 'function',
+                        function: {
+                            name: call.name,
+                            arguments: call.arguments,
+                        },
+                    },
+                ],
             });
-            continue;
         }
     }
 
     return messages;
-}
+}

package/src/http-timeout-wiring.test.ts

@@ -0,0 +1,263 @@
+import type { HttpTimeoutOptions } from '@llumiverse/core';
+import { describe, expect, it } from 'vitest';
+import { exposePrivate } from '../test/__helpers__/test-utils.js';
+import { AnthropicDriver } from './anthropic/index.js';
+import { BedrockDriver } from './bedrock/index.js';
+import { GroqDriver } from './groq/index.js';
+import { HuggingFaceIEDriver } from './huggingface_ie.js';
+import { MistralAIDriver } from './mistral/index.js';
+import { AzureOpenAIDriver } from './openai/azure_openai.js';
+import { OpenAIDriver } from './openai/openai.js';
+import { OpenAICompatibleDriver } from './openai/openai_compatible.js';
+import { ReplicateDriver } from './replicate.js';
+import { TogetherAIDriver } from './togetherai/index.js';
+import { VertexAIDriver } from './vertexai/index.js';
+import { WatsonxDriver } from './watsonx/index.js';
+import { xAIDriver } from './xai/index.js';
+
+type DriverFetchInternals = {
+    _driverFetch?: typeof fetch;
+};
+
+type SdkFetchHolder = {
+    fetch?: typeof fetch;
+    _options?: {
+        fetch?: typeof fetch;
+    };
+};
+
+type FetchClientInternals = {
+    _fetch: Promise<typeof fetch>;
+};
+
+type BedrockRequestHandlerConfig = {
+    requestTimeout: number;
+    throwOnRequestTimeout: boolean;
+    connectionTimeout: number;
+    socketTimeout: number;
+};
+
+function driverFetch(driver: object): typeof fetch {
+    const fetchImpl = exposePrivate<DriverFetchInternals>(driver)._driverFetch;
+    if (!fetchImpl) {
+        throw new Error('Driver fetch was not initialized');
+    }
+    return fetchImpl;
+}
+
+function expectSdkUsesDriverFetch(driver: object, client: object): void {
+    const expectedFetch = driverFetch(driver);
+    const sdkClient = exposePrivate<SdkFetchHolder>(client);
+    expect(sdkClient.fetch ?? sdkClient._options?.fetch).toBe(expectedFetch);
+}
+
+async function expectFetchClientUsesDriverFetch(driver: object, client: object): Promise<void> {
+    await expect(exposePrivate<FetchClientInternals>(client)._fetch).resolves.toBe(driverFetch(driver));
+}
+
+describe('driver HTTP timeout wiring', () => {
+    it('configures Bedrock request handlers to throw on request timeout', () => {
+        const driver = new BedrockDriver({
+            region: 'us-east-1',
+            httpTimeout: {
+                headersTimeout: 1_234,
+                bodyTimeout: 2_345,
+                connectTimeout: 345,
+            },
+        });
+
+        const config = exposePrivate<{
+            getBedrockRequestHandlerConfig: (httpTimeout?: HttpTimeoutOptions) => BedrockRequestHandlerConfig;
+        }>(driver).getBedrockRequestHandlerConfig();
+
+        expect(config).toEqual({
+            requestTimeout: 1_234,
+            throwOnRequestTimeout: true,
+            connectionTimeout: 345,
+            socketTimeout: 2_345,
+        });
+
+        const overrideConfig = exposePrivate<{
+            getBedrockRequestHandlerConfig: (httpTimeout?: HttpTimeoutOptions) => BedrockRequestHandlerConfig;
+        }>(driver).getBedrockRequestHandlerConfig({
+            headersTimeout: 456,
+            bodyTimeout: 567,
+        });
+
+        expect(overrideConfig).toEqual({
+            requestTimeout: 456,
+            throwOnRequestTimeout: true,
+            connectionTimeout: 345,
+            socketTimeout: 567,
+        });
+
+        const defaultExecutor = driver.getExecutor();
+        const scopedExecutor = driver.getExecutor({ headersTimeout: 456 });
+        expect(scopedExecutor).not.toBe(defaultExecutor);
+        expect(driver.getExecutor()).toBe(defaultExecutor);
+        scopedExecutor.destroy();
+        driver.destroy();
+    });
+
+    it('passes the driver fetch to SDK clients that accept a custom fetch implementation', () => {
+        const openai = new OpenAIDriver({ apiKey: 'test-key' });
+        expectSdkUsesDriverFetch(openai, openai.service);
+        openai.destroy();
+
+        const azure = new AzureOpenAIDriver({
+            apiKey: 'test-key',
+            endpoint: 'https://example.openai.azure.com',
+            deployment: 'deployment',
+        });
+        expectSdkUsesDriverFetch(azure, azure.service);
+        azure.destroy();
+
+        const compatible = new OpenAICompatibleDriver({
+            apiKey: 'test-key',
+            endpoint: 'https://example.test/v1',
+        });
+        expectSdkUsesDriverFetch(compatible, compatible.service);
+        compatible.destroy();
+
+        const together = new TogetherAIDriver({ apiKey: 'test-key' });
+        expectSdkUsesDriverFetch(together, together.service);
+        together.destroy();
+
+        const anthropic = new AnthropicDriver({ apiKey: 'test-key' });
+        expectSdkUsesDriverFetch(anthropic, anthropic.client);
+        anthropic.destroy();
+
+        const groq = new GroqDriver({ apiKey: 'test-key' });
+        expectSdkUsesDriverFetch(groq, groq.client);
+        groq.destroy();
+
+        const replicate = new ReplicateDriver({ apiKey: 'test-key' });
+        expectSdkUsesDriverFetch(replicate, replicate.service);
+        replicate.destroy();
+
+        const xai = new xAIDriver({ apiKey: 'test-key' });
+        expectSdkUsesDriverFetch(xai, xai.service);
+        xai.destroy();
+    });
+
+    it('passes the driver fetch to FetchClient-backed drivers', async () => {
+        const mistral = new MistralAIDriver({ apiKey: 'test-key' });
+        await expectFetchClientUsesDriverFetch(mistral, mistral.client);
+        mistral.destroy();
+
+        const watsonx = new WatsonxDriver({
+            apiKey: 'test-key',
+            projectId: 'project',
+            endpointUrl: 'https://example.test',
+        });
+        await expectFetchClientUsesDriverFetch(watsonx, watsonx.fetchClient);
+        watsonx.destroy();
+
+        const huggingFace = new HuggingFaceIEDriver({
+            apiKey: 'test-key',
+            endpoint_url: 'https://example.test',
+        });
+        await expectFetchClientUsesDriverFetch(huggingFace, huggingFace.service);
+        huggingFace.destroy();
+
+        const xai = new xAIDriver({ apiKey: 'test-key' });
+        await expectFetchClientUsesDriverFetch(xai, xai.xai_service);
+        xai.destroy();
+    });
+
+    it('passes the driver fetch to Vertex AI FetchClient paths', async () => {
+        const driver = new VertexAIDriver({
+            project: 'project',
+            region: 'us-central1',
+        });
+
+        await expectFetchClientUsesDriverFetch(driver, driver.getFetchClient());
+        await expectFetchClientUsesDriverFetch(driver, driver.getLLamaClient());
+
+        driver.destroy();
+    });
+
+    it('maps Vertex AI single-timeout SDK clients from DriverOptions.httpTimeout', () => {
+        const driver = new VertexAIDriver({
+            project: 'project',
+            region: 'us-central1',
+            httpTimeout: {
+                headersTimeout: 1_000,
+                bodyTimeout: 3_000,
+            },
+        });
+
+        const internals = exposePrivate<{
+            getGoogleGenAIHttpOptions: (
+                flex: boolean,
+                httpTimeout?: HttpTimeoutOptions,
+            ) => {
+                timeout: number;
+                headers?: Record<string, string>;
+            };
+            getAnthropicVertexClientOptions: (
+                region: string,
+                authClient: unknown,
+                httpTimeout?: HttpTimeoutOptions,
+            ) => {
+                timeout: number;
+                region: string;
+                projectId: string;
+                fetch: typeof fetch;
+            };
+        }>(driver);
+
+        expect(internals.getGoogleGenAIHttpOptions(false)).toEqual({
+            timeout: 3_000,
+        });
+        expect(internals.getGoogleGenAIHttpOptions(true)).toEqual({
+            timeout: 3_000,
+            headers: {
+                'X-Vertex-AI-LLM-Request-Type': 'shared',
+                'X-Vertex-AI-LLM-Shared-Request-Type': 'flex',
+            },
+        });
+        expect(
+            internals.getGoogleGenAIHttpOptions(false, {
+                headersTimeout: 10_000,
+                bodyTimeout: 20_000,
+            }),
+        ).toEqual({
+            timeout: 20_000,
+        });
+
+        const anthropicOptions = internals.getAnthropicVertexClientOptions('global', {});
+        expect(anthropicOptions).toEqual({
+            timeout: 3_000,
+            region: 'global',
+            projectId: 'project',
+            authClient: {},
+            fetch: driverFetch(driver),
+        });
+        expect(
+            internals.getAnthropicVertexClientOptions(
+                'global',
+                {},
+                {
+                    headersTimeout: 10_000,
+                    bodyTimeout: 20_000,
+                },
+            ),
+        ).toEqual({
+            timeout: 20_000,
+            region: 'global',
+            projectId: 'project',
+            authClient: {},
+            fetch: driverFetch(driver),
+        });
+
+        const defaultGoogleClient = driver.getGoogleGenAIClient();
+        const overrideGoogleClient = driver.getGoogleGenAIClient('us-central1', false, {
+            headersTimeout: 10_000,
+        });
+        expect(overrideGoogleClient).not.toBe(defaultGoogleClient);
+        expect(driver.getGoogleGenAIClient()).toBe(defaultGoogleClient);
+
+        driver.destroy();
+    });
+});