cloudassist-ai-provider 0.0.1

package/dist/google-generative-ai-image-model.test.js

@@ -0,0 +1,252 @@
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { GoogleGenerativeAIImageModel } from './google-generative-ai-image-model';
+import { describe, it, expect } from 'vitest';
+const prompt = 'A cute baby sea otter';
+const model = new GoogleGenerativeAIImageModel('imagen-3.0-generate-002', {}, {
+    provider: 'google.generative-ai',
+    baseURL: 'https://api.example.com/v1beta',
+    headers: () => ({ 'api-key': 'test-api-key' }),
+});
+const server = createTestServer({
+    'https://api.example.com/v1beta/models/imagen-3.0-generate-002:predict': {
+        response: {
+            type: 'json-value',
+            body: {
+                predictions: [
+                    { bytesBase64Encoded: 'base64-image-1' },
+                    { bytesBase64Encoded: 'base64-image-2' },
+                ],
+            },
+        },
+    },
+});
+describe('GoogleGenerativeAIImageModel', () => {
+    describe('doGenerate', () => {
+        function prepareJsonResponse({ headers, } = {}) {
+            const url = 'https://api.example.com/v1beta/models/imagen-3.0-generate-002:predict';
+            server.urls[url].response = {
+                type: 'json-value',
+                headers,
+                body: {
+                    predictions: [
+                        { bytesBase64Encoded: 'base64-image-1' },
+                        { bytesBase64Encoded: 'base64-image-2' },
+                    ],
+                },
+            };
+        }
+        it('should pass headers', async () => {
+            prepareJsonResponse();
+            const modelWithHeaders = new GoogleGenerativeAIImageModel('imagen-3.0-generate-002', {}, {
+                provider: 'google.generative-ai',
+                baseURL: 'https://api.example.com/v1beta',
+                headers: () => ({
+                    'Custom-Provider-Header': 'provider-header-value',
+                }),
+            });
+            await modelWithHeaders.doGenerate({
+                prompt,
+                n: 2,
+                size: undefined,
+                aspectRatio: undefined,
+                seed: undefined,
+                providerOptions: {},
+                headers: {
+                    'Custom-Request-Header': 'request-header-value',
+                },
+            });
+            expect(server.calls[0].requestHeaders).toStrictEqual({
+                'content-type': 'application/json',
+                'custom-provider-header': 'provider-header-value',
+                'custom-request-header': 'request-header-value',
+            });
+        });
+        it('should respect maxImagesPerCall setting', () => {
+            const customModel = new GoogleGenerativeAIImageModel('imagen-3.0-generate-002', { maxImagesPerCall: 2 }, {
+                provider: 'google.generative-ai',
+                baseURL: 'https://api.example.com/v1beta',
+                headers: () => ({ 'api-key': 'test-api-key' }),
+            });
+            expect(customModel.maxImagesPerCall).toBe(2);
+        });
+        it('should use default maxImagesPerCall when not specified', () => {
+            const defaultModel = new GoogleGenerativeAIImageModel('imagen-3.0-generate-002', {}, {
+                provider: 'google.generative-ai',
+                baseURL: 'https://api.example.com/v1beta',
+                headers: () => ({ 'api-key': 'test-api-key' }),
+            });
+            expect(defaultModel.maxImagesPerCall).toBe(4);
+        });
+        it('should extract the generated images', async () => {
+            prepareJsonResponse();
+            const result = await model.doGenerate({
+                prompt,
+                n: 2,
+                size: undefined,
+                aspectRatio: undefined,
+                seed: undefined,
+                providerOptions: {},
+            });
+            expect(result.images).toStrictEqual(['base64-image-1', 'base64-image-2']);
+        });
+        it('sends aspect ratio in the request', async () => {
+            prepareJsonResponse();
+            await model.doGenerate({
+                prompt: 'test prompt',
+                n: 1,
+                size: undefined,
+                aspectRatio: '16:9',
+                seed: undefined,
+                providerOptions: {},
+            });
+            expect(await server.calls[0].requestBodyJson).toStrictEqual({
+                instances: [{ prompt: 'test prompt' }],
+                parameters: {
+                    sampleCount: 1,
+                    aspectRatio: '16:9',
+                },
+            });
+        });
+        it('should pass aspect ratio directly when specified', async () => {
+            prepareJsonResponse();
+            await model.doGenerate({
+                prompt: 'test prompt',
+                n: 1,
+                size: undefined,
+                aspectRatio: '16:9',
+                seed: undefined,
+                providerOptions: {},
+            });
+            expect(await server.calls[0].requestBodyJson).toStrictEqual({
+                instances: [{ prompt: 'test prompt' }],
+                parameters: {
+                    sampleCount: 1,
+                    aspectRatio: '16:9',
+                },
+            });
+        });
+        it('should combine aspectRatio and provider options', async () => {
+            prepareJsonResponse();
+            await model.doGenerate({
+                prompt: 'test prompt',
+                n: 1,
+                size: undefined,
+                aspectRatio: '1:1',
+                seed: undefined,
+                providerOptions: {
+                    google: {
+                        personGeneration: 'dont_allow',
+                    },
+                },
+            });
+            expect(await server.calls[0].requestBodyJson).toStrictEqual({
+                instances: [{ prompt: 'test prompt' }],
+                parameters: {
+                    sampleCount: 1,
+                    personGeneration: 'dont_allow',
+                    aspectRatio: '1:1',
+                },
+            });
+        });
+        it('should return warnings for unsupported settings', async () => {
+            prepareJsonResponse();
+            const result = await model.doGenerate({
+                prompt,
+                n: 1,
+                size: '1024x1024',
+                aspectRatio: '1:1',
+                seed: 123,
+                providerOptions: {},
+            });
+            expect(result.warnings).toStrictEqual([
+                {
+                    type: 'unsupported-setting',
+                    setting: 'size',
+                    details: 'This model does not support the `size` option. Use `aspectRatio` instead.',
+                },
+                {
+                    type: 'unsupported-setting',
+                    setting: 'seed',
+                    details: 'This model does not support the `seed` option through this provider.',
+                },
+            ]);
+        });
+        it('should include response data with timestamp, modelId and headers', async () => {
+            prepareJsonResponse({
+                headers: {
+                    'request-id': 'test-request-id',
+                    'x-goog-quota-remaining': '123',
+                },
+            });
+            const testDate = new Date('2024-03-15T12:00:00Z');
+            const customModel = new GoogleGenerativeAIImageModel('imagen-3.0-generate-002', {}, {
+                provider: 'google.generative-ai',
+                baseURL: 'https://api.example.com/v1beta',
+                headers: () => ({ 'api-key': 'test-api-key' }),
+                _internal: {
+                    currentDate: () => testDate,
+                },
+            });
+            const result = await customModel.doGenerate({
+                prompt,
+                n: 1,
+                size: undefined,
+                aspectRatio: undefined,
+                seed: undefined,
+                providerOptions: {},
+            });
+            expect(result.response).toStrictEqual({
+                timestamp: testDate,
+                modelId: 'imagen-3.0-generate-002',
+                headers: {
+                    'content-length': '97',
+                    'content-type': 'application/json',
+                    'request-id': 'test-request-id',
+                    'x-goog-quota-remaining': '123',
+                },
+            });
+        });
+        it('should use real date when no custom date provider is specified', async () => {
+            prepareJsonResponse();
+            const beforeDate = new Date();
+            const result = await model.doGenerate({
+                prompt,
+                n: 2,
+                size: undefined,
+                aspectRatio: undefined,
+                seed: undefined,
+                providerOptions: {},
+            });
+            const afterDate = new Date();
+            expect(result.response.timestamp.getTime()).toBeGreaterThanOrEqual(beforeDate.getTime());
+            expect(result.response.timestamp.getTime()).toBeLessThanOrEqual(afterDate.getTime());
+            expect(result.response.modelId).toBe('imagen-3.0-generate-002');
+        });
+        it('should only pass valid provider options', async () => {
+            prepareJsonResponse();
+            await model.doGenerate({
+                prompt,
+                n: 2,
+                size: undefined,
+                aspectRatio: '16:9',
+                seed: undefined,
+                providerOptions: {
+                    google: {
+                        addWatermark: false,
+                        personGeneration: 'allow_all',
+                        foo: 'bar', // Invalid option
+                        negativePrompt: 'negative prompt', // Invalid option
+                    },
+                },
+            });
+            expect(await server.calls[0].requestBodyJson).toStrictEqual({
+                instances: [{ prompt }],
+                parameters: {
+                    sampleCount: 2,
+                    personGeneration: 'allow_all',
+                    aspectRatio: '16:9',
+                },
+            });
+        });
+    });
+});

package/dist/google-generative-ai-image-settings.d.ts

@@ -0,0 +1,8 @@
+export type GoogleGenerativeAIImageModelId = 'imagen-4.0-generate-001' | 'imagen-4.0-ultra-generate-001' | 'imagen-4.0-fast-generate-001' | (string & {});
+export interface GoogleGenerativeAIImageSettings {
+    /**
+  Override the maximum number of images per call (default 4)
+     */
+    maxImagesPerCall?: number;
+}
+//# sourceMappingURL=google-generative-ai-image-settings.d.ts.map

package/dist/google-generative-ai-image-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-generative-ai-image-settings.d.ts","sourceRoot":"","sources":["../src/google-generative-ai-image-settings.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,8BAA8B,GACtC,yBAAyB,GACzB,+BAA+B,GAC/B,8BAA8B,GAC9B,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAElB,MAAM,WAAW,+BAA+B;IAC9C;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B"}

package/dist/google-generative-ai-image-settings.js

@@ -0,0 +1 @@
+export {};

package/dist/google-generative-ai-language-model.d.ts

@@ -0,0 +1,183 @@
+import { LanguageModelV2 } from '@ai-sdk/provider';
+import { FetchFunction, InferValidator, Resolvable } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { GoogleGenerativeAIModelId } from './google-generative-ai-options';
+type GoogleGenerativeAIConfig = {
+    provider: string;
+    baseURL: string;
+    headers: Resolvable<Record<string, string | undefined>>;
+    fetch?: FetchFunction;
+    generateId: () => string;
+    /**
+     * The supported URLs for the model.
+     */
+    supportedUrls?: () => LanguageModelV2['supportedUrls'];
+};
+export declare class GoogleGenerativeAILanguageModel implements LanguageModelV2 {
+    readonly specificationVersion = "v2";
+    readonly modelId: GoogleGenerativeAIModelId;
+    private readonly config;
+    private readonly generateId;
+    constructor(modelId: GoogleGenerativeAIModelId, config: GoogleGenerativeAIConfig);
+    get provider(): string;
+    get supportedUrls(): Record<string, RegExp[]> | PromiseLike<Record<string, RegExp[]>>;
+    private getArgs;
+    doGenerate(options: Parameters<LanguageModelV2['doGenerate']>[0]): Promise<Awaited<ReturnType<LanguageModelV2['doGenerate']>>>;
+    doStream(options: Parameters<LanguageModelV2['doStream']>[0]): Promise<Awaited<ReturnType<LanguageModelV2['doStream']>>>;
+}
+export declare const getGroundingMetadataSchema: () => z.ZodObject<{
+    webSearchQueries: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    retrievalQueries: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    searchEntryPoint: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        renderedContent: z.ZodString;
+    }, z.core.$strip>>>;
+    groundingChunks: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        web: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            uri: z.ZodString;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        retrievedContext: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            uri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            fileSearchStore: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        maps: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            uri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            placeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>>;
+    groundingSupports: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        segment: z.ZodObject<{
+            startIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            endIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+        segment_text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        groundingChunkIndices: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
+        supportChunkIndices: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
+        confidenceScores: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
+        confidenceScore: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
+    }, z.core.$strip>>>>;
+    retrievalMetadata: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        webDynamicRetrievalScore: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>]>>>;
+}, z.core.$strip>;
+export declare const getUrlContextMetadataSchema: () => z.ZodObject<{
+    urlMetadata: z.ZodArray<z.ZodObject<{
+        retrievedUrl: z.ZodString;
+        urlRetrievalStatus: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const responseSchema: import("@ai-sdk/provider-utils").LazySchema<{
+    candidates: {
+        content?: Record<string, never> | {
+            parts?: ({
+                functionCall: {
+                    name: string;
+                    args: unknown;
+                    id?: string | null | undefined;
+                };
+                thoughtSignature?: string | null | undefined;
+            } | {
+                inlineData: {
+                    mimeType: string;
+                    data: string;
+                };
+            } | {
+                executableCode?: {
+                    language: string;
+                    code: string;
+                } | null | undefined;
+                codeExecutionResult?: {
+                    outcome: string;
+                    output: string;
+                } | null | undefined;
+                text?: string | null | undefined;
+                thought?: boolean | null | undefined;
+                thoughtSignature?: string | null | undefined;
+            })[] | null | undefined;
+        } | null | undefined;
+        finishReason?: string | null | undefined;
+        safetyRatings?: {
+            category?: string | null | undefined;
+            probability?: string | null | undefined;
+            probabilityScore?: number | null | undefined;
+            severity?: string | null | undefined;
+            severityScore?: number | null | undefined;
+            blocked?: boolean | null | undefined;
+        }[] | null | undefined;
+        groundingMetadata?: {
+            webSearchQueries?: string[] | null | undefined;
+            retrievalQueries?: string[] | null | undefined;
+            searchEntryPoint?: {
+                renderedContent: string;
+            } | null | undefined;
+            groundingChunks?: {
+                web?: {
+                    uri: string;
+                    title?: string | null | undefined;
+                } | null | undefined;
+                retrievedContext?: {
+                    uri?: string | null | undefined;
+                    title?: string | null | undefined;
+                    text?: string | null | undefined;
+                    fileSearchStore?: string | null | undefined;
+                } | null | undefined;
+                maps?: {
+                    uri?: string | null | undefined;
+                    title?: string | null | undefined;
+                    text?: string | null | undefined;
+                    placeId?: string | null | undefined;
+                } | null | undefined;
+            }[] | null | undefined;
+            groundingSupports?: {
+                segment: {
+                    startIndex?: number | null | undefined;
+                    endIndex?: number | null | undefined;
+                    text?: string | null | undefined;
+                };
+                segment_text?: string | null | undefined;
+                groundingChunkIndices?: number[] | null | undefined;
+                supportChunkIndices?: number[] | null | undefined;
+                confidenceScores?: number[] | null | undefined;
+                confidenceScore?: number[] | null | undefined;
+            }[] | null | undefined;
+            retrievalMetadata?: Record<string, never> | {
+                webDynamicRetrievalScore: number;
+            } | null | undefined;
+        } | null | undefined;
+        urlContextMetadata?: {
+            urlMetadata: {
+                retrievedUrl: string;
+                urlRetrievalStatus: string;
+            }[];
+        } | null | undefined;
+    }[];
+    usageMetadata?: {
+        cachedContentTokenCount?: number | null | undefined;
+        thoughtsTokenCount?: number | null | undefined;
+        promptTokenCount?: number | null | undefined;
+        candidatesTokenCount?: number | null | undefined;
+        totalTokenCount?: number | null | undefined;
+        trafficType?: string | null | undefined;
+    } | null | undefined;
+    promptFeedback?: {
+        blockReason?: string | null | undefined;
+        safetyRatings?: {
+            category?: string | null | undefined;
+            probability?: string | null | undefined;
+            probabilityScore?: number | null | undefined;
+            severity?: string | null | undefined;
+            severityScore?: number | null | undefined;
+            blocked?: boolean | null | undefined;
+        }[] | null | undefined;
+    } | null | undefined;
+}>;
+export type GroundingMetadataSchema = NonNullable<InferValidator<typeof responseSchema>['candidates'][number]['groundingMetadata']>;
+export type UrlContextMetadataSchema = NonNullable<InferValidator<typeof responseSchema>['candidates'][number]['urlContextMetadata']>;
+export type SafetyRatingSchema = NonNullable<InferValidator<typeof responseSchema>['candidates'][number]['safetyRatings']>[number];
+export {};
+//# sourceMappingURL=google-generative-ai-language-model.d.ts.map

package/dist/google-generative-ai-language-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-generative-ai-language-model.d.ts","sourceRoot":"","sources":["../src/google-generative-ai-language-model.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAQhB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,aAAa,EACb,cAAc,EAEd,UAAU,EAUX,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAM3B,OAAO,EACL,yBAAyB,EAE1B,MAAM,gCAAgC,CAAC;AAIxC,KAAK,wBAAwB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC;IACxD,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,UAAU,EAAE,MAAM,MAAM,CAAC;IAEzB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,eAAe,CAAC,eAAe,CAAC,CAAC;CACxD,CAAC;AAEF,qBAAa,+BAAgC,YAAW,eAAe;IACrE,QAAQ,CAAC,oBAAoB,QAAQ;IAErC,QAAQ,CAAC,OAAO,EAAE,yBAAyB,CAAC;IAE5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAClD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAe;gBAGxC,OAAO,EAAE,yBAAyB,EAClC,MAAM,EAAE,wBAAwB;IAOlC,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,aAAa,qEAEhB;YAEa,OAAO;IA2Hf,UAAU,CACd,OAAO,EAAE,UAAU,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,GACpD,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IA+VxD,QAAQ,CACZ,OAAO,EAAE,UAAU,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,GAClD,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;CA8U7D;AAwID,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsDnC,CAAC;AAkEL,eAAO,MAAM,2BAA2B;;;;;iBAQpC,CAAC;AAEL,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBnB,CAAC;AAKF,MAAM,MAAM,uBAAuB,GAAG,WAAW,CAC/C,cAAc,CACZ,OAAO,cAAc,CACtB,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,mBAAmB,CAAC,CAC7C,CAAC;AAMF,MAAM,MAAM,wBAAwB,GAAG,WAAW,CAChD,cAAc,CACZ,OAAO,cAAc,CACtB,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,oBAAoB,CAAC,CAC9C,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAC1C,cAAc,CAAC,OAAO,cAAc,CAAC,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAC7E,CAAC,MAAM,CAAC,CAAC"}