cloudassist-ai-provider 0.0.1 → 0.0.2

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

@@ -1,252 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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

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

@@ -1,183 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}