Google GenAI Provider

npm install @core-ai/google-genai

import { createGoogleGenAI } from '@core-ai/google-genai';

const google = createGoogleGenAI({
    apiKey: process.env.GOOGLE_API_KEY,
});

import { createGoogleGenAI } from '@core-ai/google-genai';
import { generate } from '@core-ai/core-ai';

const google = createGoogleGenAI();

const result = await generate({
    model: google.chatModel('gemini-4-argon'),
    messages: [{ role: 'user', content: 'Explain machine learning' }],
});

console.log(result.content);

const result = await generate({
    model: google.chatModel('gemini-4-argon'),
    messages: [{ role: 'user', content: 'Analyze this complex scenario...' }],
    reasoning: {
        effort: 'high',
    },
});

const result = await generate({
    model: google.chatModel('gemini-3.1-pro-preview'),
    messages: [
        {
            role: 'user',
            content: [
                { type: 'text', text: 'Describe this image' },
                {
                    type: 'image',
                    source: {
                        type: 'url',
                        url: 'https://example.com/photo.jpg',
                    },
                },
            ],
        },
    ],
});

import { embed } from '@core-ai/core-ai';

const result = await embed({
    model: google.embeddingModel('text-embedding-004'),
    input: 'Text to embed',
});

console.log(result.embeddings[0]);

import { generateImage } from '@core-ai/core-ai';

const result = await generateImage({
    model: google.imageModel('gemini-nano-banana-2.1'),
    prompt: 'A serene mountain landscape at dawn',
    size: '1024x1024',
});

console.log(result.images);

import { stream } from '@core-ai/core-ai';

const chatStream = await stream({
    model: google.chatModel('gemini-2.5-flash'),
    messages: [{ role: 'user', content: 'Write a story about...' }],
});

for await (const event of chatStream) {
    if (event.type === 'text-delta') {
        process.stdout.write(event.text);
    }
}

import { generate, defineTool } from '@core-ai/core-ai';
import { z } from 'zod';

const result = await generate({
    model: google.chatModel('gemini-3.1-pro-preview'),
    messages: [
        {
            role: 'user',
            content: 'Calculate the area of a circle with radius 5',
        },
    ],
    tools: {
        calculateArea: defineTool({
            name: 'calculateArea',
            description: 'Calculate circle area',
            parameters: z.object({
                radius: z.number(),
            }),
        }),
    },
});

import { clampReasoningEffort, generate } from '@core-ai/core-ai';
import {
    createGoogleGenAI,
    getGoogleModelCapabilities,
} from '@core-ai/google-genai';

const google = createGoogleGenAI();
const model = google.chatModel('gemini-3.1-pro-preview');

if (model.capabilities.reasoning.mode !== 'unsupported') {
    const effort = clampReasoningEffort(
        'high',
        model.capabilities.reasoning.supportedEfforts
    );

    await generate({
        model,
        messages: [{ role: 'user', content: 'Analyze this carefully.' }],
        reasoning: { effort },
    });
}

const capabilities = getGoogleModelCapabilities('gemini-2.5-flash');
// capabilities.reasoning.thinkingParam === 'thinkingBudget'
// capabilities.reasoning.mode === 'optional'

// Throws: `max` on Gemini 2.5 Pro needs more than 32,768 tokens.
await generate({
    model: google.chatModel('gemini-2.5-pro'),
    messages: [{ role: 'user', content: 'Analyze this carefully.' }],
    reasoning: { effort: 'max' },
    maxTokens: 32_768,
});

import { generate, getProviderMetadata } from '@core-ai/core-ai';
import type { GoogleReasoningMetadata } from '@core-ai/google-genai';

const result = await generate({
    model: google.chatModel('gemini-3.1-pro-preview'),
    messages: [{ role: 'user', content: 'Search for something.' }],
    tools: {
        /* ... */
    },
});

for (const part of result.parts) {
    if (part.type !== 'tool-call') continue;

    const metadata = getProviderMetadata<GoogleReasoningMetadata>(
        part.providerMetadata,
        'google'
    );

    console.log(metadata?.thoughtSignature);
}

const result = await generate({
    model: google.chatModel('gemini-3.1-pro-preview'),
    messages: [{ role: 'user', content: 'Hello' }],
    providerOptions: {
        google: {
            stopSequences: ['\n\n'],
            frequencyPenalty: 0.5,
            presencePenalty: 0.3,
            seed: 42,
            topK: 40,
        },
    },
});

const result = await embed({
    model: google.embeddingModel('text-embedding-004'),
    input: 'text',
    providerOptions: {
        google: {
            taskType: 'RETRIEVAL_DOCUMENT',
            title: 'My Document',
        },
    },
});

const result = await generateImage({
    model: google.imageModel('gemini-3-pro-image-preview'),
    prompt: 'A serene landscape',
    size: '2048x1152',
    providerOptions: {
        google: {
            aspectRatio: '16:9',
            imageSize: '2K',
            seed: 42,
        },
    },
});

import { ProviderError } from '@core-ai/core-ai';

try {
    const result = await generate({
        model: google.chatModel('gemini-3.1-pro-preview'),
        messages: [{ role: 'user', content: 'Hello!' }],
    });
} catch (error) {
    if (error instanceof ProviderError) {
        console.error('Google AI API error:', error.message);
        console.error('Status:', error.statusCode);
    }
}