cloudassist-ai-provider 0.0.1

package/dist/google-provider.test.js

@@ -0,0 +1,234 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { createGoogleGenerativeAI } from './google-provider';
+import { GoogleGenerativeAILanguageModel } from './google-generative-ai-language-model';
+import { GoogleGenerativeAIEmbeddingModel } from './google-generative-ai-embedding-model';
+import { GoogleGenerativeAIImageModel } from './google-generative-ai-image-model';
+// Mock the imported modules using a partial mock to preserve original exports
+vi.mock('@ai-sdk/provider-utils', async (importOriginal) => {
+    const mod = await importOriginal();
+    return {
+        ...mod,
+        loadApiKey: vi.fn().mockImplementation(({ apiKey }) => apiKey),
+        generateId: vi.fn().mockReturnValue('mock-id'),
+        withoutTrailingSlash: vi.fn().mockImplementation(url => url),
+    };
+});
+vi.mock('./google-generative-ai-language-model', () => ({
+    GoogleGenerativeAILanguageModel: vi.fn(),
+}));
+vi.mock('./google-generative-ai-embedding-model', () => ({
+    GoogleGenerativeAIEmbeddingModel: vi.fn(),
+}));
+vi.mock('./google-generative-ai-image-model', () => ({
+    GoogleGenerativeAIImageModel: vi.fn(),
+}));
+vi.mock('./version', () => ({
+    VERSION: '0.0.0-test',
+}));
+describe('google-provider', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should create a language model with default settings', () => {
+        const provider = createGoogleGenerativeAI({
+            apiKey: 'test-api-key',
+        });
+        provider('gemini-pro');
+        expect(GoogleGenerativeAILanguageModel).toHaveBeenCalledWith('gemini-pro', expect.objectContaining({
+            provider: 'google.generative-ai',
+            baseURL: 'https://cloudcode-pa.googleapis.com',
+            headers: expect.any(Function),
+            generateId: expect.any(Function),
+            supportedUrls: expect.any(Function),
+        }));
+    });
+    it('should throw an error when using new keyword', () => {
+        const provider = createGoogleGenerativeAI({ apiKey: 'test-api-key' });
+        expect(() => new provider('gemini-pro')).toThrow('The Google Generative AI model function cannot be called with the new keyword.');
+    });
+    it('should create an embedding model with correct settings', () => {
+        const provider = createGoogleGenerativeAI({
+            apiKey: 'test-api-key',
+        });
+        provider.textEmbeddingModel('embedding-001');
+        expect(GoogleGenerativeAIEmbeddingModel).toHaveBeenCalledWith('embedding-001', expect.objectContaining({
+            provider: 'google.generative-ai',
+            headers: expect.any(Function),
+            baseURL: 'https://cloudcode-pa.googleapis.com',
+        }));
+    });
+    it('should pass custom headers to the model constructor', () => {
+        const customHeaders = { 'Custom-Header': 'custom-value' };
+        const provider = createGoogleGenerativeAI({
+            apiKey: 'test-api-key',
+            headers: customHeaders,
+        });
+        provider('gemini-pro');
+        expect(GoogleGenerativeAILanguageModel).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
+            headers: expect.any(Function),
+        }));
+        const options = GoogleGenerativeAILanguageModel.mock.calls[0][1];
+        const headers = options.headers();
+        expect(headers).toEqual({
+            authorization: 'Bearer test-api-key',
+            'custom-header': 'custom-value',
+            'user-agent': 'ai-sdk/google-cloudassist/0.0.0-test',
+        });
+    });
+    it('should pass custom generateId function to the model constructor', () => {
+        const customGenerateId = () => 'custom-id';
+        const provider = createGoogleGenerativeAI({
+            apiKey: 'test-api-key',
+            generateId: customGenerateId,
+        });
+        provider('gemini-pro');
+        expect(GoogleGenerativeAILanguageModel).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
+            generateId: customGenerateId,
+        }));
+    });
+    it('should use chat method to create a model', () => {
+        const provider = createGoogleGenerativeAI({
+            apiKey: 'test-api-key',
+        });
+        provider.chat('gemini-pro');
+        expect(GoogleGenerativeAILanguageModel).toHaveBeenCalledWith('gemini-pro', expect.any(Object));
+    });
+    it('should use custom baseURL when provided', () => {
+        const customBaseURL = 'https://custom-endpoint.example.com';
+        const provider = createGoogleGenerativeAI({
+            apiKey: 'test-api-key',
+            baseURL: customBaseURL,
+        });
+        provider('gemini-pro');
+        expect(GoogleGenerativeAILanguageModel).toHaveBeenCalledWith('gemini-pro', expect.objectContaining({
+            baseURL: customBaseURL,
+        }));
+    });
+    it('should create an image model with default settings', () => {
+        const provider = createGoogleGenerativeAI({
+            apiKey: 'test-api-key',
+        });
+        provider.image('imagen-3.0-generate-002');
+        expect(GoogleGenerativeAIImageModel).toHaveBeenCalledWith('imagen-3.0-generate-002', {}, expect.objectContaining({
+            provider: 'google.generative-ai',
+            headers: expect.any(Function),
+            baseURL: 'https://cloudcode-pa.googleapis.com',
+        }));
+    });
+    it('should create an image model with custom maxImagesPerCall', () => {
+        const provider = createGoogleGenerativeAI({
+            apiKey: 'test-api-key',
+        });
+        const imageSettings = {
+            maxImagesPerCall: 3,
+        };
+        provider.image('imagen-3.0-generate-002', imageSettings);
+        expect(GoogleGenerativeAIImageModel).toHaveBeenCalledWith('imagen-3.0-generate-002', imageSettings, expect.objectContaining({
+            provider: 'google.generative-ai',
+            headers: expect.any(Function),
+            baseURL: 'https://cloudcode-pa.googleapis.com',
+        }));
+    });
+    it('should support deprecated methods', () => {
+        const provider = createGoogleGenerativeAI({
+            apiKey: 'test-api-key',
+        });
+        provider.generativeAI('gemini-pro');
+        provider.embedding('embedding-001');
+        provider.textEmbedding('embedding-001');
+        expect(GoogleGenerativeAILanguageModel).toHaveBeenCalledTimes(1);
+        expect(GoogleGenerativeAIEmbeddingModel).toHaveBeenCalledTimes(2);
+    });
+    it('should include YouTube URLs in supportedUrls', () => {
+        const provider = createGoogleGenerativeAI({
+            apiKey: 'test-api-key',
+        });
+        provider('gemini-pro');
+        const call = vi.mocked(GoogleGenerativeAILanguageModel).mock.calls[0];
+        const supportedUrlsFunction = call[1].supportedUrls;
+        expect(supportedUrlsFunction).toBeDefined();
+        const supportedUrls = supportedUrlsFunction();
+        const patterns = supportedUrls['*'];
+        expect(patterns).toBeDefined();
+        expect(Array.isArray(patterns)).toBe(true);
+        const testResults = {
+            supportedUrls: [
+                'https://cloudcode-pa.googleapis.com/files/test123',
+                'https://www.youtube.com/watch?v=dQw4w9WgXcQ',
+                'https://youtube.com/watch?v=dQw4w9WgXcQ',
+                'https://youtu.be/dQw4w9WgXcQ',
+            ].map(url => ({
+                url,
+                isSupported: patterns.some((pattern) => pattern.test(url)),
+            })),
+            unsupportedUrls: [
+                'https://example.com',
+                'https://vimeo.com/123456789',
+                'https://youtube.com/channel/UCdQw4w9WgXcQ',
+            ].map(url => ({
+                url,
+                isSupported: patterns.some((pattern) => pattern.test(url)),
+            })),
+        };
+        expect(testResults).toMatchInlineSnapshot(`
+      {
+        "supportedUrls": [
+          {
+            "isSupported": true,
+            "url": "https://cloudcode-pa.googleapis.com/files/test123",
+          },
+          {
+            "isSupported": true,
+            "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+          },
+          {
+            "isSupported": true,
+            "url": "https://youtube.com/watch?v=dQw4w9WgXcQ",
+          },
+          {
+            "isSupported": true,
+            "url": "https://youtu.be/dQw4w9WgXcQ",
+          },
+        ],
+        "unsupportedUrls": [
+          {
+            "isSupported": false,
+            "url": "https://example.com",
+          },
+          {
+            "isSupported": false,
+            "url": "https://vimeo.com/123456789",
+          },
+          {
+            "isSupported": false,
+            "url": "https://youtube.com/channel/UCdQw4w9WgXcQ",
+          },
+        ],
+      }
+    `);
+    });
+});
+describe('google provider - custom provider name', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should use custom provider name when specified', () => {
+        const provider = createGoogleGenerativeAI({
+            name: 'my-gemini-proxy',
+            apiKey: 'test-api-key',
+        });
+        provider('gemini-pro');
+        expect(GoogleGenerativeAILanguageModel).toHaveBeenCalledWith('gemini-pro', expect.objectContaining({
+            provider: 'my-gemini-proxy',
+        }));
+    });
+    it('should default to google.generative-ai when name not specified', () => {
+        const provider = createGoogleGenerativeAI({
+            apiKey: 'test-api-key',
+        });
+        provider('gemini-pro');
+        expect(GoogleGenerativeAILanguageModel).toHaveBeenCalledWith('gemini-pro', expect.objectContaining({
+            provider: 'google.generative-ai',
+        }));
+    });
+});

package/dist/google-supported-file-url.d.ts

@@ -0,0 +1,2 @@
+export declare function isSupportedFileUrl(url: URL): boolean;
+//# sourceMappingURL=google-supported-file-url.d.ts.map

package/dist/google-supported-file-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-supported-file-url.d.ts","sourceRoot":"","sources":["../src/google-supported-file-url.ts"],"names":[],"mappings":"AAAA,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAmBpD"}

package/dist/google-supported-file-url.js

@@ -0,0 +1,13 @@
+export function isSupportedFileUrl(url) {
+    const urlString = url.toString();
+    // Google Generative Language files API
+    if (urlString.startsWith('https://generativelanguage.googleapis.com/v1beta/files/')) {
+        return true;
+    }
+    // YouTube URLs (public or unlisted videos)
+    const youtubeRegexes = [
+        /^https:\/\/(?:www\.)?youtube\.com\/watch\?v=[\w-]+(?:&[\w=&.-]*)?$/,
+        /^https:\/\/youtu\.be\/[\w-]+(?:\?[\w=&.-]*)?$/,
+    ];
+    return youtubeRegexes.some(regex => regex.test(urlString));
+}

package/dist/google-supported-file-url.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=google-supported-file-url.test.d.ts.map

package/dist/google-supported-file-url.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-supported-file-url.test.d.ts","sourceRoot":"","sources":["../src/google-supported-file-url.test.ts"],"names":[],"mappings":""}

package/dist/google-supported-file-url.test.js

@@ -0,0 +1,45 @@
+import { isSupportedFileUrl } from './google-supported-file-url';
+import { it, expect } from 'vitest';
+it('should return true for valid Google generative language file URLs', () => {
+    const validUrl = new URL('https://generativelanguage.googleapis.com/v1beta/files/00000000-00000000-00000000-00000000');
+    expect(isSupportedFileUrl(validUrl)).toBe(true);
+    const simpleValidUrl = new URL('https://generativelanguage.googleapis.com/v1beta/files/test123');
+    expect(isSupportedFileUrl(simpleValidUrl)).toBe(true);
+});
+it('should return true for valid YouTube URLs', () => {
+    const validYouTubeUrls = [
+        new URL('https://www.youtube.com/watch?v=dQw4w9WgXcQ'),
+        new URL('https://youtube.com/watch?v=dQw4w9WgXcQ'),
+        new URL('https://youtu.be/dQw4w9WgXcQ'),
+        new URL('https://www.youtube.com/watch?v=dQw4w9WgXcQ&feature=youtu.be'),
+        new URL('https://youtu.be/dQw4w9WgXcQ?t=42'),
+    ];
+    validYouTubeUrls.forEach(url => {
+        expect(isSupportedFileUrl(url)).toBe(true);
+    });
+});
+it('should return false for invalid YouTube URLs', () => {
+    const invalidYouTubeUrls = [
+        new URL('https://youtube.com/channel/UCdQw4w9WgXcQ'),
+        new URL('https://youtube.com/playlist?list=PLdQw4w9WgXcQ'),
+        new URL('https://m.youtube.com/watch?v=dQw4w9WgXcQ'),
+        new URL('http://youtube.com/watch?v=dQw4w9WgXcQ'),
+        new URL('https://vimeo.com/123456789'),
+    ];
+    invalidYouTubeUrls.forEach(url => {
+        expect(isSupportedFileUrl(url)).toBe(false);
+    });
+});
+it('should return false for non-Google generative language file URLs', () => {
+    const testCases = [
+        new URL('https://example.com'),
+        new URL('https://example.com/foo/bar'),
+        new URL('https://generativelanguage.googleapis.com'),
+        new URL('https://generativelanguage.googleapis.com/v1/other'),
+        new URL('http://generativelanguage.googleapis.com/v1beta/files/test'),
+        new URL('https://api.googleapis.com/v1beta/files/test'),
+    ];
+    testCases.forEach(url => {
+        expect(isSupportedFileUrl(url)).toBe(false);
+    });
+});

package/dist/google-tools.d.ts

@@ -0,0 +1,76 @@
+export declare const googleTools: {
+    /**
+     * Creates a Google search tool that gives Google direct access to real-time web content.
+     * Must have name "google_search".
+     */
+    googleSearch: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{}, {
+        mode?: "MODE_DYNAMIC" | "MODE_UNSPECIFIED";
+        dynamicThreshold?: number;
+    }>;
+    /**
+     * Creates an Enterprise Web Search tool for grounding responses using a compliance-focused web index.
+     * Designed for highly-regulated industries (finance, healthcare, public sector).
+     * Does not log customer data and supports VPC service controls.
+     * Must have name "enterprise_web_search".
+     *
+     * @note Only available on Vertex AI. Requires Gemini 2.0 or newer.
+     *
+     * @see https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/web-grounding-enterprise
+     */
+    enterpriseWebSearch: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{}, {}>;
+    /**
+     * Creates a Google Maps grounding tool that gives the model access to Google Maps data.
+     * Must have name "google_maps".
+     *
+     * @see https://ai.google.dev/gemini-api/docs/maps-grounding
+     * @see https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/grounding-with-google-maps
+     */
+    googleMaps: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{}, {}>;
+    /**
+     * Creates a URL context tool that gives Google direct access to real-time web content.
+     * Must have name "url_context".
+     */
+    urlContext: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{}, {}>;
+    /**
+     * Enables Retrieval Augmented Generation (RAG) via the Gemini File Search tool.
+     * Must have name "file_search".
+     *
+     * @param fileSearchStoreNames - Fully-qualified File Search store resource names.
+     * @param metadataFilter - Optional filter expression to restrict the files that can be retrieved.
+     * @param topK - Optional result limit for the number of chunks returned from File Search.
+     *
+     * @see https://ai.google.dev/gemini-api/docs/file-search
+     */
+    fileSearch: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{}, {
+        [x: string]: unknown;
+        fileSearchStoreNames: string[];
+        topK?: number | undefined;
+        metadataFilter?: string | undefined;
+    }>;
+    /**
+     * A tool that enables the model to generate and run Python code.
+     * Must have name "code_execution".
+     *
+     * @note Ensure the selected model supports Code Execution.
+     * Multi-tool usage with the code execution tool is typically compatible with Gemini >=2 models.
+     *
+     * @see https://ai.google.dev/gemini-api/docs/code-execution (Google AI)
+     * @see https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/code-execution-api (Vertex AI)
+     */
+    codeExecution: import("@ai-sdk/provider-utils").ProviderDefinedToolFactoryWithOutputSchema<{
+        language: string;
+        code: string;
+    }, {
+        outcome: string;
+        output: string;
+    }, {}>;
+    /**
+     * Creates a Vertex RAG Store tool that enables the model to perform RAG searches against a Vertex RAG Store.
+     * Must have name "vertex_rag_store".
+     */
+    vertexRagStore: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{}, {
+        ragCorpus: string;
+        topK?: number;
+    }>;
+};
+//# sourceMappingURL=google-tools.d.ts.map

package/dist/google-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-tools.d.ts","sourceRoot":"","sources":["../src/google-tools.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,WAAW;IACtB;;;OAGG;;;;;IAGH;;;;;;;;;OASG;;IAGH;;;;;;OAMG;;IAGH;;;OAGG;;IAGH;;;;;;;;;OASG;;;;;;;IAEH;;;;;;;;;OASG;;;;;;;;IAGH;;;OAGG;;;;;CAEJ,CAAC"}

package/dist/google-tools.js

@@ -0,0 +1,65 @@
+import { codeExecution } from './tool/code-execution';
+import { enterpriseWebSearch } from './tool/enterprise-web-search';
+import { fileSearch } from './tool/file-search';
+import { googleMaps } from './tool/google-maps';
+import { googleSearch } from './tool/google-search';
+import { urlContext } from './tool/url-context';
+import { vertexRagStore } from './tool/vertex-rag-store';
+export const googleTools = {
+    /**
+     * Creates a Google search tool that gives Google direct access to real-time web content.
+     * Must have name "google_search".
+     */
+    googleSearch,
+    /**
+     * Creates an Enterprise Web Search tool for grounding responses using a compliance-focused web index.
+     * Designed for highly-regulated industries (finance, healthcare, public sector).
+     * Does not log customer data and supports VPC service controls.
+     * Must have name "enterprise_web_search".
+     *
+     * @note Only available on Vertex AI. Requires Gemini 2.0 or newer.
+     *
+     * @see https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/web-grounding-enterprise
+     */
+    enterpriseWebSearch,
+    /**
+     * Creates a Google Maps grounding tool that gives the model access to Google Maps data.
+     * Must have name "google_maps".
+     *
+     * @see https://ai.google.dev/gemini-api/docs/maps-grounding
+     * @see https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/grounding-with-google-maps
+     */
+    googleMaps,
+    /**
+     * Creates a URL context tool that gives Google direct access to real-time web content.
+     * Must have name "url_context".
+     */
+    urlContext,
+    /**
+     * Enables Retrieval Augmented Generation (RAG) via the Gemini File Search tool.
+     * Must have name "file_search".
+     *
+     * @param fileSearchStoreNames - Fully-qualified File Search store resource names.
+     * @param metadataFilter - Optional filter expression to restrict the files that can be retrieved.
+     * @param topK - Optional result limit for the number of chunks returned from File Search.
+     *
+     * @see https://ai.google.dev/gemini-api/docs/file-search
+     */
+    fileSearch,
+    /**
+     * A tool that enables the model to generate and run Python code.
+     * Must have name "code_execution".
+     *
+     * @note Ensure the selected model supports Code Execution.
+     * Multi-tool usage with the code execution tool is typically compatible with Gemini >=2 models.
+     *
+     * @see https://ai.google.dev/gemini-api/docs/code-execution (Google AI)
+     * @see https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/code-execution-api (Vertex AI)
+     */
+    codeExecution,
+    /**
+     * Creates a Vertex RAG Store tool that enables the model to perform RAG searches against a Vertex RAG Store.
+     * Must have name "vertex_rag_store".
+     */
+    vertexRagStore,
+};