Google Gemini

GOOGLE_AI_API_KEY=AIzaSyxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx   # From console.cloud.google.com
GOOGLE_AI_DEFAULT_MODEL=gemini-2.5-flash
GOOGLE_AI_IMAGE_MODEL=imagen-3.0-generate-001

import { GoogleGenerativeAI } from '@google/generative-ai';
 
class GeminiAdapter implements LLMAdapter {
  private client: GoogleGenerativeAI;
  private history: { role: 'user' | 'model'; parts: { text: string }[] }[] = [];
 
  constructor(
    private apiKey: string,
    private model:  string = 'gemini-2.5-flash',
  ) {
    this.client = new GoogleGenerativeAI(apiKey);
  }
 
  async *run(systemPrompt: string, userPrompt: string): AsyncGenerator<LLMEvent> {
    const generativeModel = this.client.getGenerativeModel({
      model:            this.model,
      systemInstruction: systemPrompt,
    });
 
    this.history.push({ role: 'user', parts: [{ text: userPrompt }] });
 
    const chat   = generativeModel.startChat({ history: this.history.slice(0, -1) });
    const stream = await chat.sendMessageStream(userPrompt);
 
    let assistantText = '';
 
    for await (const chunk of stream.stream) {
      const text = chunk.text();
      assistantText += text;
      yield { type: 'content', text };
    }
 
    this.history.push({ role: 'model', parts: [{ text: assistantText }] });
 
    const usage = (await stream.response).usageMetadata;
    yield {
      type:         'usage',
      inputTokens:  usage?.promptTokenCount      ?? 0,
      outputTokens: usage?.candidatesTokenCount   ?? 0,
    };
  }
}

const tools = [{
  functionDeclarations: [
    {
      name:        'web_search',
      description: 'Search the web for current information',
      parameters: {
        type: 'object',
        properties: { query: { type: 'string', description: 'Search query' } },
        required: ['query'],
      },
    },
    {
      name:        'rag_search',
      description: 'Search the client knowledge base',
      parameters: {
        type: 'object',
        properties: {
          query:      { type: 'string' },
          datasetIds: { type: 'array', items: { type: 'string' } },
        },
        required: ['query'],
      },
    },
  ],
}];

import { GoogleGenerativeAI } from '@google/generative-ai';
import axios from 'axios';
 
class GeminiImageTool implements ImageGenerationTool {
  readonly name = 'gemini';
  private client: GoogleGenerativeAI;
 
  constructor(private apiKey: string) {
    this.client = new GoogleGenerativeAI(apiKey);
  }
 
  async generateImage(options: {
    prompt:        string;
    negativePrompt?: string;   // Things to avoid in the image
    aspectRatio?:  '1:1' | '16:9' | '9:16' | '4:3' | '3:4';
    style?:        'photograph' | 'illustration' | 'painting' | 'digital_art';
    count?:        number;   // 1–4 images
  }): Promise<GeneratedImage[]> {
    // Imagen 3 via REST API (SDK wrapper not yet stable)
    const response = await axios.post(
      `https://generativelanguage.googleapis.com/v1beta/models/imagen-3.0-generate-001:predict`,
      {
        instances: [{
          prompt: this.buildPrompt(options),
        }],
        parameters: {
          sampleCount:    options.count      ?? 1,
          aspectRatio:    options.aspectRatio ?? '16:9',
          negativePrompt: options.negativePrompt,
        },
      },
      {
        headers: {
          'Content-Type': 'application/json',
          'x-goog-api-key': this.apiKey,
        },
      },
    );
 
    return response.data.predictions.map((pred: any, i: number) => ({
      provider:    'gemini',
      model:       'imagen-3.0-generate-001',
      imageBase64: pred.bytesBase64Encoded,
      mimeType:    pred.mimeType ?? 'image/png',
      revisedPrompt: null,
    }));
  }
 
  // Generate with reference image (Gemini 2.5 Flash multimodal)
  async editImage(options: {
    prompt:         string;
    referenceImages: Buffer[];   // Input images for style/content reference
    aspectRatio?:   string;
  }): Promise<GeneratedImage[]> {
    const model = this.client.getGenerativeModel({ model: 'gemini-2.5-flash' });
 
    const parts: any[] = [
      { text: options.prompt },
      ...options.referenceImages.map(buf => ({
        inlineData: {
          data:     buf.toString('base64'),
          mimeType: 'image/jpeg',
        },
      })),
    ];
 
    const result = await model.generateContent({ contents: [{ role: 'user', parts }] });
    const imagePart = result.response.candidates?.[0].content.parts
      .find((p: any) => p.inlineData);
 
    if (!imagePart) throw new Error('Gemini did not return an image');
 
    return [{
      provider:    'gemini',
      model:       'gemini-2.5-flash',
      imageBase64: imagePart.inlineData.data,
      mimeType:    imagePart.inlineData.mimeType,
      revisedPrompt: null,
    }];
  }
 
  private buildPrompt(options: { prompt: string; style?: string }): string {
    const styleModifiers: Record<string, string> = {
      photograph:   'professional photograph, realistic, high quality, 4K',
      illustration: 'digital illustration, clean vector art style',
      painting:     'oil painting, artistic, painterly strokes',
      digital_art:  'digital art, concept art, highly detailed',
    };
    const suffix = options.style ? `, ${styleModifiers[options.style]}` : '';
    return `${options.prompt}${suffix}`;
  }
}

interface ImageGenerationTool {
  readonly name: string;
  generateImage(options: ImageGenerationOptions): Promise<GeneratedImage[]>;
}
 
interface GeneratedImage {
  provider:      string;
  model:         string;
  imageBase64:   string;   // Base64-encoded image
  mimeType:      string;
  revisedPrompt: string | null;  // Some models return a revised prompt
}