@hasna/connectors 0.0.1

package/connectors/connect-googlegemini/src/api/generate.ts

@@ -0,0 +1,187 @@
+import type { GeminiClient } from './client';
+import type {
+  GeminiModel,
+  Content,
+  GenerationConfig,
+  SafetySetting,
+  GenerateContentRequest,
+  GenerateContentResponse,
+  CountTokensRequest,
+  CountTokensResponse,
+} from '../types';
+
+/**
+ * Text Generation API
+ */
+export class GenerateApi {
+  constructor(private client: GeminiClient) {}
+
+  /**
+   * Generate content from a prompt
+   */
+  async generateContent(
+    model: GeminiModel,
+    contents: Content[] | string,
+    options?: {
+      generationConfig?: GenerationConfig;
+      safetySettings?: SafetySetting[];
+      systemInstruction?: string;
+    }
+  ): Promise<GenerateContentResponse> {
+    // Convert string to Content array
+    const contentArray: Content[] =
+      typeof contents === 'string'
+        ? [{ parts: [{ text: contents }], role: 'user' }]
+        : contents;
+
+    const request: GenerateContentRequest = {
+      contents: contentArray,
+      generationConfig: options?.generationConfig,
+      safetySettings: options?.safetySettings,
+    };
+
+    if (options?.systemInstruction) {
+      request.systemInstruction = {
+        parts: [{ text: options.systemInstruction }],
+      };
+    }
+
+    return this.client.post<GenerateContentResponse>(
+      `/models/${model}:generateContent`,
+      request
+    );
+  }
+
+  /**
+   * Generate content with streaming
+   */
+  async *streamGenerateContent(
+    model: GeminiModel,
+    contents: Content[] | string,
+    options?: {
+      generationConfig?: GenerationConfig;
+      safetySettings?: SafetySetting[];
+      systemInstruction?: string;
+    }
+  ): AsyncGenerator<string, void, unknown> {
+    const contentArray: Content[] =
+      typeof contents === 'string'
+        ? [{ parts: [{ text: contents }], role: 'user' }]
+        : contents;
+
+    const request: GenerateContentRequest = {
+      contents: contentArray,
+      generationConfig: options?.generationConfig,
+      safetySettings: options?.safetySettings,
+    };
+
+    if (options?.systemInstruction) {
+      request.systemInstruction = {
+        parts: [{ text: options.systemInstruction }],
+      };
+    }
+
+    yield* this.client.streamRequest(`/models/${model}:streamGenerateContent`, request);
+  }
+
+  /**
+   * Count tokens in content
+   */
+  async countTokens(
+    model: GeminiModel,
+    contents: Content[] | string,
+    generationConfig?: GenerationConfig
+  ): Promise<CountTokensResponse> {
+    const contentArray: Content[] =
+      typeof contents === 'string'
+        ? [{ parts: [{ text: contents }], role: 'user' }]
+        : contents;
+
+    const request: CountTokensRequest = {
+      contents: contentArray,
+      generationConfig,
+    };
+
+    return this.client.post<CountTokensResponse>(
+      `/models/${model}:countTokens`,
+      request
+    );
+  }
+
+  /**
+   * Simple text generation helper
+   */
+  async text(
+    prompt: string,
+    options?: {
+      model?: GeminiModel;
+      temperature?: number;
+      maxTokens?: number;
+      systemInstruction?: string;
+    }
+  ): Promise<string> {
+    const model = options?.model || 'gemini-2.5-flash';
+    const response = await this.generateContent(model, prompt, {
+      generationConfig: {
+        temperature: options?.temperature,
+        maxOutputTokens: options?.maxTokens,
+      },
+      systemInstruction: options?.systemInstruction,
+    });
+
+    return response.candidates?.[0]?.content?.parts?.[0]?.text || '';
+  }
+
+  /**
+   * Chat-style generation with history
+   */
+  async chat(
+    messages: { role: 'user' | 'model'; text: string }[],
+    options?: {
+      model?: GeminiModel;
+      temperature?: number;
+      maxTokens?: number;
+      systemInstruction?: string;
+    }
+  ): Promise<string> {
+    const model = options?.model || 'gemini-2.5-flash';
+    const contents: Content[] = messages.map((m) => ({
+      role: m.role,
+      parts: [{ text: m.text }],
+    }));
+
+    const response = await this.generateContent(model, contents, {
+      generationConfig: {
+        temperature: options?.temperature,
+        maxOutputTokens: options?.maxTokens,
+      },
+      systemInstruction: options?.systemInstruction,
+    });
+
+    return response.candidates?.[0]?.content?.parts?.[0]?.text || '';
+  }
+
+  /**
+   * JSON generation helper
+   */
+  async json<T = unknown>(
+    prompt: string,
+    options?: {
+      model?: GeminiModel;
+      temperature?: number;
+      systemInstruction?: string;
+    }
+  ): Promise<T> {
+    const model = options?.model || 'gemini-2.5-flash';
+    const response = await this.generateContent(model, prompt, {
+      generationConfig: {
+        temperature: options?.temperature,
+        responseMimeType: 'application/json',
+      },
+      systemInstruction: options?.systemInstruction,
+    });
+
+    const text = response.candidates?.[0]?.content?.parts?.[0]?.text || '{}';
+    return JSON.parse(text) as T;
+  }
+}

package/connectors/connect-googlegemini/src/api/images.ts

@@ -0,0 +1,216 @@
+import type { GeminiClient } from './client';
+import type {
+  GeminiModel,
+  Content,
+  GenerationConfig,
+  GenerateContentResponse,
+  ImageConfig,
+} from '../types';
+
+// Image generation models (Nano Banana)
+export type ImageModel =
+  | 'gemini-2.5-flash-preview-image-generation'
+  | 'gemini-3-pro-image-preview';
+
+export interface ImageGenerationOptions {
+  aspectRatio?: ImageConfig['aspectRatio'];
+  imageSize?: ImageConfig['imageSize'];
+  numberOfImages?: number;
+}
+
+export interface GeneratedImage {
+  mimeType: string;
+  data: string; // base64 encoded
+}
+
+/**
+ * Image Generation API (Nano Banana)
+ */
+export class ImagesApi {
+  constructor(private client: GeminiClient) {}
+
+  /**
+   * Generate images from text prompt
+   */
+  async generate(
+    prompt: string,
+    options?: ImageGenerationOptions & { model?: ImageModel }
+  ): Promise<GeneratedImage[]> {
+    const model = options?.model || 'gemini-2.5-flash-preview-image-generation';
+
+    const generationConfig: GenerationConfig = {
+      responseModalities: ['TEXT', 'IMAGE'],
+      imageConfig: {
+        aspectRatio: options?.aspectRatio || '16:9',
+        imageSize: options?.imageSize || '2K',
+        numberOfImages: options?.numberOfImages || 1,
+      },
+    };
+
+    const response = await this.client.post<GenerateContentResponse>(
+      `/models/${model}:generateContent`,
+      {
+        contents: [{ parts: [{ text: prompt }] }],
+        generationConfig,
+      }
+    );
+
+    // Extract images from response
+    const images: GeneratedImage[] = [];
+    for (const candidate of response.candidates || []) {
+      for (const part of candidate.content?.parts || []) {
+        if (part.inlineData) {
+          images.push({
+            mimeType: part.inlineData.mimeType,
+            data: part.inlineData.data,
+          });
+        }
+      }
+    }
+
+    return images;
+  }
+
+  /**
+   * Edit an existing image with text instructions
+   */
+  async edit(
+    imageBase64: string,
+    imageMimeType: string,
+    instruction: string,
+    options?: ImageGenerationOptions & { model?: ImageModel }
+  ): Promise<GeneratedImage[]> {
+    const model = options?.model || 'gemini-2.5-flash-preview-image-generation';
+
+    const generationConfig: GenerationConfig = {
+      responseModalities: ['TEXT', 'IMAGE'],
+      imageConfig: {
+        aspectRatio: options?.aspectRatio,
+        imageSize: options?.imageSize,
+        numberOfImages: options?.numberOfImages || 1,
+      },
+    };
+
+    const response = await this.client.post<GenerateContentResponse>(
+      `/models/${model}:generateContent`,
+      {
+        contents: [
+          {
+            parts: [
+              { text: instruction },
+              {
+                inlineData: {
+                  mimeType: imageMimeType,
+                  data: imageBase64,
+                },
+              },
+            ],
+          },
+        ],
+        generationConfig,
+      }
+    );
+
+    const images: GeneratedImage[] = [];
+    for (const candidate of response.candidates || []) {
+      for (const part of candidate.content?.parts || []) {
+        if (part.inlineData) {
+          images.push({
+            mimeType: part.inlineData.mimeType,
+            data: part.inlineData.data,
+          });
+        }
+      }
+    }
+
+    return images;
+  }
+
+  /**
+   * Generate and save images to files
+   */
+  async generateToFiles(
+    prompt: string,
+    outputDir: string,
+    options?: ImageGenerationOptions & { model?: ImageModel; filenamePrefix?: string }
+  ): Promise<string[]> {
+    const fs = await import('fs');
+    const path = await import('path');
+
+    const images = await this.generate(prompt, options);
+    const savedPaths: string[] = [];
+
+    for (let i = 0; i < images.length; i++) {
+      const image = images[i];
+      const ext = image.mimeType === 'image/png' ? 'png' : 'jpg';
+      const prefix = options?.filenamePrefix || 'generated';
+      const filename = `${prefix}_${Date.now()}_${i}.${ext}`;
+      const filepath = path.join(outputDir, filename);
+
+      const buffer = Buffer.from(image.data, 'base64');
+      fs.writeFileSync(filepath, buffer);
+      savedPaths.push(filepath);
+    }
+
+    return savedPaths;
+  }
+
+  /**
+   * Describe an image (vision)
+   */
+  async describe(
+    imageBase64: string,
+    imageMimeType: string,
+    prompt?: string,
+    model?: GeminiModel
+  ): Promise<string> {
+    const response = await this.client.post<GenerateContentResponse>(
+      `/models/${model || 'gemini-2.5-flash'}:generateContent`,
+      {
+        contents: [
+          {
+            parts: [
+              { text: prompt || 'Describe this image in detail.' },
+              {
+                inlineData: {
+                  mimeType: imageMimeType,
+                  data: imageBase64,
+                },
+              },
+            ],
+          },
+        ],
+      }
+    );
+
+    return response.candidates?.[0]?.content?.parts?.[0]?.text || '';
+  }
+
+  /**
+   * Analyze image from file
+   */
+  async analyzeFile(
+    filePath: string,
+    prompt?: string,
+    model?: GeminiModel
+  ): Promise<string> {
+    const fs = await import('fs');
+    const path = await import('path');
+
+    const fileContent = fs.readFileSync(filePath);
+    const base64 = fileContent.toString('base64');
+
+    // Determine MIME type from extension
+    const ext = path.extname(filePath).toLowerCase();
+    const mimeTypes: Record<string, string> = {
+      '.jpg': 'image/jpeg',
+      '.jpeg': 'image/jpeg',
+      '.png': 'image/png',
+      '.gif': 'image/gif',
+      '.webp': 'image/webp',
+    };
+    const mimeType = mimeTypes[ext] || 'image/jpeg';
+
+    return this.describe(base64, mimeType, prompt, model);
+  }
+}

package/connectors/connect-googlegemini/src/api/index.ts

@@ -0,0 +1,103 @@
+import { GeminiClient, type GeminiClientConfig } from './client';
+import { GenerateApi } from './generate';
+import { ImagesApi } from './images';
+import { VideoApi } from './video';
+import { SpeechApi } from './speech';
+import { EmbeddingsApi } from './embeddings';
+import { FilesApi } from './files';
+import { ModelsApi } from './models';
+
+/**
+ * Main Google Gemini Connector class
+ * Provides access to all Gemini API endpoints
+ */
+export class Gemini {
+  private readonly client: GeminiClient;
+
+  // API modules
+  public readonly generate: GenerateApi;
+  public readonly images: ImagesApi;
+  public readonly video: VideoApi;
+  public readonly speech: SpeechApi;
+  public readonly embeddings: EmbeddingsApi;
+  public readonly files: FilesApi;
+  public readonly models: ModelsApi;
+
+  constructor(config: GeminiClientConfig) {
+    this.client = new GeminiClient(config);
+    this.generate = new GenerateApi(this.client);
+    this.images = new ImagesApi(this.client);
+    this.video = new VideoApi(this.client);
+    this.speech = new SpeechApi(this.client);
+    this.embeddings = new EmbeddingsApi(this.client);
+    this.files = new FilesApi(this.client);
+    this.models = new ModelsApi(this.client);
+  }
+
+  /**
+   * Create a client from environment variables
+   * Looks for GEMINI_API_KEY
+   */
+  static fromEnv(): Gemini {
+    const apiKey = process.env.GEMINI_API_KEY;
+    const baseUrl = process.env.GEMINI_BASE_URL;
+
+    if (!apiKey) {
+      throw new Error('GEMINI_API_KEY environment variable is required');
+    }
+
+    return new Gemini({ apiKey, baseUrl });
+  }
+
+  /**
+   * Quick text generation
+   */
+  async text(prompt: string, options?: { model?: string; temperature?: number }): Promise<string> {
+    return this.generate.text(prompt, options);
+  }
+
+  /**
+   * Quick image generation
+   */
+  async image(prompt: string, options?: { aspectRatio?: string; imageSize?: string }): Promise<string> {
+    const images = await this.images.generate(prompt, options as any);
+    return images[0]?.data || '';
+  }
+
+  /**
+   * Quick embedding
+   */
+  async embed(text: string): Promise<number[]> {
+    return this.embeddings.embed(text);
+  }
+
+  /**
+   * Get the underlying client for direct API access
+   */
+  getClient(): GeminiClient {
+    return this.client;
+  }
+
+  /**
+   * Get API key preview (for debugging)
+   */
+  getApiKeyPreview(): string {
+    return this.client.getApiKeyPreview();
+  }
+
+  /**
+   * Get base URL
+   */
+  getBaseUrl(): string {
+    return this.client.getBaseUrl();
+  }
+}
+
+export { GeminiClient } from './client';
+export { GenerateApi } from './generate';
+export { ImagesApi } from './images';
+export { VideoApi } from './video';
+export { SpeechApi } from './speech';
+export { EmbeddingsApi } from './embeddings';
+export { FilesApi } from './files';
+export { ModelsApi } from './models';

package/connectors/connect-googlegemini/src/api/models.ts

@@ -0,0 +1,102 @@
+import type { GeminiClient } from './client';
+import type { ModelInfo, GeminiModel, VeoModel } from '../types';
+
+export interface ListModelsResponse {
+  models: ModelInfo[];
+  nextPageToken?: string;
+}
+
+/**
+ * Models API
+ */
+export class ModelsApi {
+  constructor(private client: GeminiClient) {}
+
+  /**
+   * List all available models
+   */
+  async list(pageSize?: number, pageToken?: string): Promise<ListModelsResponse> {
+    return this.client.get<ListModelsResponse>('/models', {
+      pageSize,
+      pageToken,
+    });
+  }
+
+  /**
+   * Get model info
+   */
+  async get(modelName: string): Promise<ModelInfo> {
+    const name = modelName.startsWith('models/') ? modelName : `models/${modelName}`;
+    return this.client.get<ModelInfo>(`/${name}`);
+  }
+
+  /**
+   * Get recommended text generation models
+   */
+  getTextModels(): GeminiModel[] {
+    return [
+      'gemini-3-pro-preview',
+      'gemini-3-flash-preview',
+      'gemini-2.5-pro',
+      'gemini-2.5-flash',
+      'gemini-2.5-flash-lite',
+    ];
+  }
+
+  /**
+   * Get image generation models (Nano Banana)
+   */
+  getImageModels(): GeminiModel[] {
+    return [
+      'gemini-2.5-flash-preview-image-generation',
+      'gemini-3-pro-image-preview',
+    ];
+  }
+
+  /**
+   * Get video generation models (Veo)
+   */
+  getVideoModels(): VeoModel[] {
+    return [
+      'veo-3.1-generate-preview',
+      'veo-3.1-fast-generate-preview',
+      'veo-2.0-generate-001',
+    ];
+  }
+
+  /**
+   * Get TTS models
+   */
+  getTTSModels(): GeminiModel[] {
+    return [
+      'gemini-2.5-flash-preview-tts',
+      'gemini-2.5-pro-preview-tts',
+    ];
+  }
+
+  /**
+   * Get embedding models
+   */
+  getEmbeddingModels(): GeminiModel[] {
+    return ['gemini-embedding-001'];
+  }
+
+  /**
+   * Get all available models by category
+   */
+  getAllModels(): {
+    text: GeminiModel[];
+    image: GeminiModel[];
+    video: VeoModel[];
+    tts: GeminiModel[];
+    embedding: GeminiModel[];
+  } {
+    return {
+      text: this.getTextModels(),
+      image: this.getImageModels(),
+      video: this.getVideoModels(),
+      tts: this.getTTSModels(),
+      embedding: this.getEmbeddingModels(),
+    };
+  }
+}