@tanstack/ai-gemini 0.0.2 → 0.1.0

package/README.md

@@ -38,7 +38,9 @@
 A powerful, type-safe AI SDK for building AI-powered applications.
 
 - Provider-agnostic adapters (OpenAI, Anthropic, Gemini, Ollama, etc.)
+- **Tree-shakeable adapters** - Import only what you need for smaller bundles
 - **Multimodal content support** - Send images, audio, video, and documents
+- **Image generation** - Generate images with OpenAI DALL-E/GPT-Image and Gemini Imagen
 - Chat completion, streaming, and agent loop strategies
 - Headless chat state management with adapters (SSE, HTTP stream, custom)
 - Isomorphic type-safe tools with server/client execution
@@ -46,6 +48,30 @@ A powerful, type-safe AI SDK for building AI-powered applications.
 
 ### <a href="https://tanstack.com/ai">Read the docs →</b></a>
 
+## Tree-Shakeable Adapters
+
+Import only the functionality you need for smaller bundle sizes:
+
+```typescript
+// Only chat functionality - no summarization code bundled
+import { openaiText } from '@tanstack/ai-openai/adapters'
+import { generate } from '@tanstack/ai'
+
+const textAdapter = openaiText()
+
+const result = generate({
+  adapter: textAdapter,
+  model: 'gpt-4o',
+  messages: [{ role: 'user', content: [{ type: 'text', content: 'Hello!' }] }],
+})
+
+for await (const chunk of result) {
+  console.log(chunk)
+}
+```
+
+Available adapters: `openaiText`, `openaiEmbed`, `openaiSummarize`, `anthropicText`, `geminiText`, `ollamaText`, and more.
+
 ## Bonus: TanStack Start Integration
 
 TanStack AI works with **any** framework (Next.js, Express, Remix, etc.).

package/dist/esm/adapters/image.d.ts

@@ -0,0 +1,83 @@
+import { BaseImageAdapter } from '@tanstack/ai/adapters';
+import { GEMINI_IMAGE_MODELS } from '../model-meta.js';
+import { GeminiImageModelProviderOptionsByName, GeminiImageModelSizeByName, GeminiImageProviderOptions } from '../image/image-provider-options.js';
+import { ImageGenerationOptions, ImageGenerationResult } from '@tanstack/ai';
+import { GeminiClientConfig } from '../utils.js';
+/**
+ * Configuration for Gemini image adapter
+ */
+export interface GeminiImageConfig extends GeminiClientConfig {
+}
+/** Model type for Gemini Image */
+export type GeminiImageModel = (typeof GEMINI_IMAGE_MODELS)[number];
+/**
+ * Gemini Image Generation Adapter
+ *
+ * Tree-shakeable adapter for Gemini Imagen image generation functionality.
+ * Supports Imagen 3 and Imagen 4 models.
+ *
+ * Features:
+ * - Aspect ratio-based image sizing
+ * - Person generation controls
+ * - Safety filtering
+ * - Watermark options
+ */
+export declare class GeminiImageAdapter<TModel extends GeminiImageModel> extends BaseImageAdapter<TModel, GeminiImageProviderOptions, GeminiImageModelProviderOptionsByName, GeminiImageModelSizeByName> {
+    readonly kind: "image";
+    readonly name: "gemini";
+    '~types': {
+        providerOptions: GeminiImageProviderOptions;
+        modelProviderOptionsByName: GeminiImageModelProviderOptionsByName;
+        modelSizeByName: GeminiImageModelSizeByName;
+    };
+    private client;
+    constructor(config: GeminiImageConfig, model: TModel);
+    generateImages(options: ImageGenerationOptions<GeminiImageProviderOptions>): Promise<ImageGenerationResult>;
+    private buildConfig;
+    private transformResponse;
+}
+/**
+ * Creates a Gemini image adapter with explicit API key.
+ * Type resolution happens here at the call site.
+ *
+ * @param model - The model name (e.g., 'imagen-3.0-generate-002')
+ * @param apiKey - Your Google API key
+ * @param config - Optional additional configuration
+ * @returns Configured Gemini image adapter instance with resolved types
+ *
+ * @example
+ * ```typescript
+ * const adapter = createGeminiImage('imagen-3.0-generate-002', "your-api-key");
+ *
+ * const result = await generateImage({
+ *   adapter,
+ *   prompt: 'A cute baby sea otter'
+ * });
+ * ```
+ */
+export declare function createGeminiImage<TModel extends GeminiImageModel>(model: TModel, apiKey: string, config?: Omit<GeminiImageConfig, 'apiKey'>): GeminiImageAdapter<TModel>;
+/**
+ * Creates a Gemini image adapter with automatic API key detection from environment variables.
+ * Type resolution happens here at the call site.
+ *
+ * Looks for `GOOGLE_API_KEY` or `GEMINI_API_KEY` in:
+ * - `process.env` (Node.js)
+ * - `window.env` (Browser with injected env)
+ *
+ * @param model - The model name (e.g., 'imagen-4.0-generate-001')
+ * @param config - Optional configuration (excluding apiKey which is auto-detected)
+ * @returns Configured Gemini image adapter instance with resolved types
+ * @throws Error if GOOGLE_API_KEY or GEMINI_API_KEY is not found in environment
+ *
+ * @example
+ * ```typescript
+ * // Automatically uses GOOGLE_API_KEY from environment
+ * const adapter = geminiImage('imagen-4.0-generate-001');
+ *
+ * const result = await generateImage({
+ *   adapter,
+ *   prompt: 'A beautiful sunset over mountains'
+ * });
+ * ```
+ */
+export declare function geminiImage<TModel extends GeminiImageModel>(model: TModel, config?: Omit<GeminiImageConfig, 'apiKey'>): GeminiImageAdapter<TModel>;

package/dist/esm/adapters/image.js

@@ -0,0 +1,60 @@
+import { BaseImageAdapter } from "@tanstack/ai/adapters";
+import { createGeminiClient, generateId, getGeminiApiKeyFromEnv } from "../utils/client.js";
+import { validatePrompt, validateImageSize, validateNumberOfImages, sizeToAspectRatio } from "../image/image-provider-options.js";
+class GeminiImageAdapter extends BaseImageAdapter {
+  constructor(config, model) {
+    super({}, model);
+    this.kind = "image";
+    this.name = "gemini";
+    this.client = createGeminiClient(config);
+  }
+  async generateImages(options) {
+    const { model, prompt, numberOfImages, size } = options;
+    validatePrompt({ prompt, model });
+    validateImageSize(model, size);
+    validateNumberOfImages(model, numberOfImages);
+    const config = this.buildConfig(options);
+    const response = await this.client.models.generateImages({
+      model,
+      prompt,
+      config
+    });
+    return this.transformResponse(model, response);
+  }
+  buildConfig(options) {
+    const { size, numberOfImages, modelOptions } = options;
+    return {
+      numberOfImages: numberOfImages ?? 1,
+      // Map size to aspect ratio if provided (modelOptions.aspectRatio will override)
+      aspectRatio: size ? sizeToAspectRatio(size) : void 0,
+      ...modelOptions
+    };
+  }
+  transformResponse(model, response) {
+    const images = (response.generatedImages ?? []).map(
+      (item) => ({
+        b64Json: item.image?.imageBytes,
+        revisedPrompt: item.enhancedPrompt
+      })
+    );
+    return {
+      id: generateId(this.name),
+      model,
+      images,
+      usage: void 0
+    };
+  }
+}
+function createGeminiImage(model, apiKey, config) {
+  return new GeminiImageAdapter({ apiKey, ...config }, model);
+}
+function geminiImage(model, config) {
+  const apiKey = getGeminiApiKeyFromEnv();
+  return createGeminiImage(model, apiKey, config);
+}
+export {
+  GeminiImageAdapter,
+  createGeminiImage,
+  geminiImage
+};
+//# sourceMappingURL=image.js.map

package/dist/esm/adapters/image.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.js","sources":["../../../src/adapters/image.ts"],"sourcesContent":["import { BaseImageAdapter } from '@tanstack/ai/adapters'\nimport {\n  createGeminiClient,\n  generateId,\n  getGeminiApiKeyFromEnv,\n} from '../utils'\nimport {\n  sizeToAspectRatio,\n  validateImageSize,\n  validateNumberOfImages,\n  validatePrompt,\n} from '../image/image-provider-options'\nimport type { GEMINI_IMAGE_MODELS } from '../model-meta'\nimport type {\n  GeminiImageModelProviderOptionsByName,\n  GeminiImageModelSizeByName,\n  GeminiImageProviderOptions,\n} from '../image/image-provider-options'\nimport type {\n  GeneratedImage,\n  ImageGenerationOptions,\n  ImageGenerationResult,\n} from '@tanstack/ai'\nimport type {\n  GenerateImagesConfig,\n  GenerateImagesResponse,\n  GoogleGenAI,\n} from '@google/genai'\nimport type { GeminiClientConfig } from '../utils'\n\n/**\n * Configuration for Gemini image adapter\n */\nexport interface GeminiImageConfig extends GeminiClientConfig {}\n\n/** Model type for Gemini Image */\nexport type GeminiImageModel = (typeof GEMINI_IMAGE_MODELS)[number]\n\n/**\n * Gemini Image Generation Adapter\n *\n * Tree-shakeable adapter for Gemini Imagen image generation functionality.\n * Supports Imagen 3 and Imagen 4 models.\n *\n * Features:\n * - Aspect ratio-based image sizing\n * - Person generation controls\n * - Safety filtering\n * - Watermark options\n */\nexport class GeminiImageAdapter<\n  TModel extends GeminiImageModel,\n> extends BaseImageAdapter<\n  TModel,\n  GeminiImageProviderOptions,\n  GeminiImageModelProviderOptionsByName,\n  GeminiImageModelSizeByName\n> {\n  readonly kind = 'image' as const\n  readonly name = 'gemini' as const\n\n  // Type-only property - never assigned at runtime\n  declare '~types': {\n    providerOptions: GeminiImageProviderOptions\n    modelProviderOptionsByName: GeminiImageModelProviderOptionsByName\n    modelSizeByName: GeminiImageModelSizeByName\n  }\n\n  private client: GoogleGenAI\n\n  constructor(config: GeminiImageConfig, model: TModel) {\n    super({}, model)\n    this.client = createGeminiClient(config)\n  }\n\n  async generateImages(\n    options: ImageGenerationOptions<GeminiImageProviderOptions>,\n  ): Promise<ImageGenerationResult> {\n    const { model, prompt, numberOfImages, size } = options\n\n    // Validate inputs\n    validatePrompt({ prompt, model })\n    validateImageSize(model, size)\n    validateNumberOfImages(model, numberOfImages)\n\n    // Build request config\n    const config = this.buildConfig(options)\n\n    const response = await this.client.models.generateImages({\n      model,\n      prompt,\n      config,\n    })\n\n    return this.transformResponse(model, response)\n  }\n\n  private buildConfig(\n    options: ImageGenerationOptions<GeminiImageProviderOptions>,\n  ): GenerateImagesConfig {\n    const { size, numberOfImages, modelOptions } = options\n\n    return {\n      numberOfImages: numberOfImages ?? 1,\n      // Map size to aspect ratio if provided (modelOptions.aspectRatio will override)\n      aspectRatio: size ? sizeToAspectRatio(size) : undefined,\n      ...modelOptions,\n    }\n  }\n\n  private transformResponse(\n    model: string,\n    response: GenerateImagesResponse,\n  ): ImageGenerationResult {\n    const images: Array<GeneratedImage> = (response.generatedImages ?? []).map(\n      (item) => ({\n        b64Json: item.image?.imageBytes,\n        revisedPrompt: item.enhancedPrompt,\n      }),\n    )\n\n    return {\n      id: generateId(this.name),\n      model,\n      images,\n      usage: undefined,\n    }\n  }\n}\n\n/**\n * Creates a Gemini image adapter with explicit API key.\n * Type resolution happens here at the call site.\n *\n * @param model - The model name (e.g., 'imagen-3.0-generate-002')\n * @param apiKey - Your Google API key\n * @param config - Optional additional configuration\n * @returns Configured Gemini image adapter instance with resolved types\n *\n * @example\n * ```typescript\n * const adapter = createGeminiImage('imagen-3.0-generate-002', \"your-api-key\");\n *\n * const result = await generateImage({\n *   adapter,\n *   prompt: 'A cute baby sea otter'\n * });\n * ```\n */\nexport function createGeminiImage<TModel extends GeminiImageModel>(\n  model: TModel,\n  apiKey: string,\n  config?: Omit<GeminiImageConfig, 'apiKey'>,\n): GeminiImageAdapter<TModel> {\n  return new GeminiImageAdapter({ apiKey, ...config }, model)\n}\n\n/**\n * Creates a Gemini image adapter with automatic API key detection from environment variables.\n * Type resolution happens here at the call site.\n *\n * Looks for `GOOGLE_API_KEY` or `GEMINI_API_KEY` in:\n * - `process.env` (Node.js)\n * - `window.env` (Browser with injected env)\n *\n * @param model - The model name (e.g., 'imagen-4.0-generate-001')\n * @param config - Optional configuration (excluding apiKey which is auto-detected)\n * @returns Configured Gemini image adapter instance with resolved types\n * @throws Error if GOOGLE_API_KEY or GEMINI_API_KEY is not found in environment\n *\n * @example\n * ```typescript\n * // Automatically uses GOOGLE_API_KEY from environment\n * const adapter = geminiImage('imagen-4.0-generate-001');\n *\n * const result = await generateImage({\n *   adapter,\n *   prompt: 'A beautiful sunset over mountains'\n * });\n * ```\n */\nexport function geminiImage<TModel extends GeminiImageModel>(\n  model: TModel,\n  config?: Omit<GeminiImageConfig, 'apiKey'>,\n): GeminiImageAdapter<TModel> {\n  const apiKey = getGeminiApiKeyFromEnv()\n  return createGeminiImage(model, apiKey, config)\n}\n"],"names":[],"mappings":";;;AAkDO,MAAM,2BAEH,iBAKR;AAAA,EAaA,YAAY,QAA2B,OAAe;AACpD,UAAM,CAAA,GAAI,KAAK;AAbjB,SAAS,OAAO;AAChB,SAAS,OAAO;AAad,SAAK,SAAS,mBAAmB,MAAM;AAAA,EACzC;AAAA,EAEA,MAAM,eACJ,SACgC;AAChC,UAAM,EAAE,OAAO,QAAQ,gBAAgB,SAAS;AAGhD,mBAAe,EAAE,QAAQ,OAAO;AAChC,sBAAkB,OAAO,IAAI;AAC7B,2BAAuB,OAAO,cAAc;AAG5C,UAAM,SAAS,KAAK,YAAY,OAAO;AAEvC,UAAM,WAAW,MAAM,KAAK,OAAO,OAAO,eAAe;AAAA,MACvD;AAAA,MACA;AAAA,MACA;AAAA,IAAA,CACD;AAED,WAAO,KAAK,kBAAkB,OAAO,QAAQ;AAAA,EAC/C;AAAA,EAEQ,YACN,SACsB;AACtB,UAAM,EAAE,MAAM,gBAAgB,aAAA,IAAiB;AAE/C,WAAO;AAAA,MACL,gBAAgB,kBAAkB;AAAA;AAAA,MAElC,aAAa,OAAO,kBAAkB,IAAI,IAAI;AAAA,MAC9C,GAAG;AAAA,IAAA;AAAA,EAEP;AAAA,EAEQ,kBACN,OACA,UACuB;AACvB,UAAM,UAAiC,SAAS,mBAAmB,CAAA,GAAI;AAAA,MACrE,CAAC,UAAU;AAAA,QACT,SAAS,KAAK,OAAO;AAAA,QACrB,eAAe,KAAK;AAAA,MAAA;AAAA,IACtB;AAGF,WAAO;AAAA,MACL,IAAI,WAAW,KAAK,IAAI;AAAA,MACxB;AAAA,MACA;AAAA,MACA,OAAO;AAAA,IAAA;AAAA,EAEX;AACF;AAqBO,SAAS,kBACd,OACA,QACA,QAC4B;AAC5B,SAAO,IAAI,mBAAmB,EAAE,QAAQ,GAAG,OAAA,GAAU,KAAK;AAC5D;AA0BO,SAAS,YACd,OACA,QAC4B;AAC5B,QAAM,SAAS,uBAAA;AACf,SAAO,kBAAkB,OAAO,QAAQ,MAAM;AAChD;"}

package/dist/esm/adapters/summarize.d.ts

@@ -0,0 +1,53 @@
+import { GoogleGenAI } from '@google/genai';
+import { SummarizeAdapter } from '@tanstack/ai/adapters';
+import { StreamChunk, SummarizationOptions, SummarizationResult } from '@tanstack/ai';
+/**
+ * Available Gemini models for summarization
+ */
+export declare const GeminiSummarizeModels: readonly ["gemini-2.0-flash", "gemini-1.5-flash", "gemini-1.5-pro", "gemini-2.0-flash-lite"];
+export type GeminiSummarizeModel = (typeof GeminiSummarizeModels)[number];
+/**
+ * Provider-specific options for Gemini summarization
+ */
+export interface GeminiSummarizeProviderOptions {
+    /** Generation configuration */
+    generationConfig?: {
+        temperature?: number;
+        topP?: number;
+        topK?: number;
+        maxOutputTokens?: number;
+        stopSequences?: Array<string>;
+    };
+    /** Safety settings */
+    safetySettings?: Array<{
+        category: string;
+        threshold: string;
+    }>;
+}
+export interface GeminiSummarizeAdapterOptions {
+}
+/**
+ * Gemini Summarize Adapter
+ * A tree-shakeable summarization adapter for Google Gemini
+ */
+export declare class GeminiSummarizeAdapter<TModel extends GeminiSummarizeModel> implements SummarizeAdapter<TModel, GeminiSummarizeProviderOptions> {
+    readonly kind: "summarize";
+    readonly name: "gemini";
+    readonly model: TModel;
+    '~types': {
+        providerOptions: GeminiSummarizeProviderOptions;
+    };
+    private client;
+    constructor(apiKeyOrClient: string | GoogleGenAI, model: TModel, _options?: GeminiSummarizeAdapterOptions);
+    summarize(options: SummarizationOptions): Promise<SummarizationResult>;
+    summarizeStream(options: SummarizationOptions): AsyncIterable<StreamChunk>;
+    private getFormatInstructions;
+}
+/**
+ * Creates a Gemini summarize adapter with explicit API key and model
+ */
+export declare function createGeminiSummarize<TModel extends GeminiSummarizeModel>(apiKey: string, model: TModel, options?: GeminiSummarizeAdapterOptions): GeminiSummarizeAdapter<TModel>;
+/**
+ * Creates a Gemini summarize adapter with API key from environment and required model
+ */
+export declare function geminiSummarize<TModel extends GeminiSummarizeModel>(model: TModel, options?: GeminiSummarizeAdapterOptions): GeminiSummarizeAdapter<TModel>;

package/dist/esm/adapters/summarize.js

@@ -0,0 +1,139 @@
+import { FinishReason } from "@google/genai";
+import { createGeminiClient, generateId, getGeminiApiKeyFromEnv } from "../utils/client.js";
+const GeminiSummarizeModels = [
+  "gemini-2.0-flash",
+  "gemini-1.5-flash",
+  "gemini-1.5-pro",
+  "gemini-2.0-flash-lite"
+];
+class GeminiSummarizeAdapter {
+  constructor(apiKeyOrClient, model, _options = {}) {
+    this.kind = "summarize";
+    this.name = "gemini";
+    this.client = typeof apiKeyOrClient === "string" ? createGeminiClient({ apiKey: apiKeyOrClient }) : apiKeyOrClient;
+    this.model = model;
+  }
+  async summarize(options) {
+    const model = options.model;
+    const formatInstructions = this.getFormatInstructions(options.style);
+    const lengthInstructions = options.maxLength ? ` Keep the summary under ${options.maxLength} tokens.` : "";
+    const systemPrompt = `You are a helpful assistant that summarizes text. ${formatInstructions}${lengthInstructions}`;
+    const response = await this.client.models.generateContent({
+      model,
+      contents: [
+        {
+          role: "user",
+          parts: [
+            { text: `Please summarize the following:
+
+${options.text}` }
+          ]
+        }
+      ],
+      config: {
+        systemInstruction: systemPrompt
+      }
+    });
+    const summary = response.text ?? "";
+    const inputTokens = response.usageMetadata?.promptTokenCount ?? 0;
+    const outputTokens = response.usageMetadata?.candidatesTokenCount ?? 0;
+    return {
+      id: generateId("sum"),
+      model,
+      summary,
+      usage: {
+        promptTokens: inputTokens,
+        completionTokens: outputTokens,
+        totalTokens: inputTokens + outputTokens
+      }
+    };
+  }
+  async *summarizeStream(options) {
+    const model = options.model;
+    const id = generateId("sum");
+    let accumulatedContent = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const formatInstructions = this.getFormatInstructions(options.style);
+    const lengthInstructions = options.maxLength ? ` Keep the summary under ${options.maxLength} words.` : "";
+    const systemPrompt = `You are a helpful assistant that summarizes text. ${formatInstructions}${lengthInstructions}`;
+    const result = await this.client.models.generateContentStream({
+      model,
+      contents: [
+        {
+          role: "user",
+          parts: [
+            { text: `Please summarize the following:
+
+${options.text}` }
+          ]
+        }
+      ],
+      config: {
+        systemInstruction: systemPrompt
+      }
+    });
+    for await (const chunk of result) {
+      if (chunk.usageMetadata) {
+        inputTokens = chunk.usageMetadata.promptTokenCount ?? inputTokens;
+        outputTokens = chunk.usageMetadata.candidatesTokenCount ?? outputTokens;
+      }
+      if (chunk.candidates?.[0]?.content?.parts) {
+        for (const part of chunk.candidates[0].content.parts) {
+          if (part.text) {
+            accumulatedContent += part.text;
+            yield {
+              type: "content",
+              id,
+              model,
+              timestamp: Date.now(),
+              delta: part.text,
+              content: accumulatedContent,
+              role: "assistant"
+            };
+          }
+        }
+      }
+      const finishReason = chunk.candidates?.[0]?.finishReason;
+      if (finishReason === FinishReason.STOP || finishReason === FinishReason.MAX_TOKENS || finishReason === FinishReason.SAFETY) {
+        yield {
+          type: "done",
+          id,
+          model,
+          timestamp: Date.now(),
+          finishReason: finishReason === FinishReason.STOP ? "stop" : finishReason === FinishReason.MAX_TOKENS ? "length" : "content_filter",
+          usage: {
+            promptTokens: inputTokens,
+            completionTokens: outputTokens,
+            totalTokens: inputTokens + outputTokens
+          }
+        };
+      }
+    }
+  }
+  getFormatInstructions(style) {
+    switch (style) {
+      case "bullet-points":
+        return "Provide the summary as bullet points.";
+      case "concise":
+        return "Provide a very brief one or two sentence summary.";
+      case "paragraph":
+      default:
+        return "Provide the summary in paragraph form.";
+    }
+  }
+}
+function createGeminiSummarize(apiKey, model, options) {
+  return new GeminiSummarizeAdapter(apiKey, model, options);
+}
+function geminiSummarize(model, options) {
+  const apiKey = getGeminiApiKeyFromEnv();
+  return new GeminiSummarizeAdapter(apiKey, model, options);
+}
+export {
+  GeminiSummarizeAdapter,
+  GeminiSummarizeModels,
+  createGeminiSummarize,
+  geminiSummarize
+};
+//# sourceMappingURL=summarize.js.map

package/dist/esm/adapters/summarize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarize.js","sources":["../../../src/adapters/summarize.ts"],"sourcesContent":["import { FinishReason } from '@google/genai'\nimport {\n  createGeminiClient,\n  generateId,\n  getGeminiApiKeyFromEnv,\n} from '../utils'\n\nimport type { GoogleGenAI } from '@google/genai'\nimport type { SummarizeAdapter } from '@tanstack/ai/adapters'\nimport type {\n  StreamChunk,\n  SummarizationOptions,\n  SummarizationResult,\n} from '@tanstack/ai'\n\n/**\n * Available Gemini models for summarization\n */\nexport const GeminiSummarizeModels = [\n  'gemini-2.0-flash',\n  'gemini-1.5-flash',\n  'gemini-1.5-pro',\n  'gemini-2.0-flash-lite',\n] as const\n\nexport type GeminiSummarizeModel = (typeof GeminiSummarizeModels)[number]\n\n/**\n * Provider-specific options for Gemini summarization\n */\nexport interface GeminiSummarizeProviderOptions {\n  /** Generation configuration */\n  generationConfig?: {\n    temperature?: number\n    topP?: number\n    topK?: number\n    maxOutputTokens?: number\n    stopSequences?: Array<string>\n  }\n  /** Safety settings */\n  safetySettings?: Array<{\n    category: string\n    threshold: string\n  }>\n}\n\nexport interface GeminiSummarizeAdapterOptions {\n  // Additional adapter options can be added here\n}\n\n/**\n * Gemini Summarize Adapter\n * A tree-shakeable summarization adapter for Google Gemini\n */\nexport class GeminiSummarizeAdapter<\n  TModel extends GeminiSummarizeModel,\n> implements SummarizeAdapter<TModel, GeminiSummarizeProviderOptions> {\n  readonly kind = 'summarize' as const\n  readonly name = 'gemini' as const\n  readonly model: TModel\n\n  // Type-only property - never assigned at runtime\n  declare '~types': {\n    providerOptions: GeminiSummarizeProviderOptions\n  }\n\n  private client: GoogleGenAI\n\n  constructor(\n    apiKeyOrClient: string | GoogleGenAI,\n    model: TModel,\n    _options: GeminiSummarizeAdapterOptions = {},\n  ) {\n    this.client =\n      typeof apiKeyOrClient === 'string'\n        ? createGeminiClient({ apiKey: apiKeyOrClient })\n        : apiKeyOrClient\n    this.model = model\n  }\n\n  async summarize(options: SummarizationOptions): Promise<SummarizationResult> {\n    const model = options.model\n\n    // Build the system prompt based on format\n    const formatInstructions = this.getFormatInstructions(options.style)\n    const lengthInstructions = options.maxLength\n      ? ` Keep the summary under ${options.maxLength} tokens.`\n      : ''\n\n    const systemPrompt = `You are a helpful assistant that summarizes text. ${formatInstructions}${lengthInstructions}`\n\n    const response = await this.client.models.generateContent({\n      model,\n      contents: [\n        {\n          role: 'user',\n          parts: [\n            { text: `Please summarize the following:\\n\\n${options.text}` },\n          ],\n        },\n      ],\n      config: {\n        systemInstruction: systemPrompt,\n      },\n    })\n\n    const summary = response.text ?? ''\n    const inputTokens = response.usageMetadata?.promptTokenCount ?? 0\n    const outputTokens = response.usageMetadata?.candidatesTokenCount ?? 0\n\n    return {\n      id: generateId('sum'),\n      model,\n      summary,\n      usage: {\n        promptTokens: inputTokens,\n        completionTokens: outputTokens,\n        totalTokens: inputTokens + outputTokens,\n      },\n    }\n  }\n\n  async *summarizeStream(\n    options: SummarizationOptions,\n  ): AsyncIterable<StreamChunk> {\n    const model = options.model\n    const id = generateId('sum')\n    let accumulatedContent = ''\n    let inputTokens = 0\n    let outputTokens = 0\n\n    // Build the system prompt based on format\n    const formatInstructions = this.getFormatInstructions(options.style)\n    const lengthInstructions = options.maxLength\n      ? ` Keep the summary under ${options.maxLength} words.`\n      : ''\n\n    const systemPrompt = `You are a helpful assistant that summarizes text. ${formatInstructions}${lengthInstructions}`\n\n    const result = await this.client.models.generateContentStream({\n      model,\n      contents: [\n        {\n          role: 'user',\n          parts: [\n            { text: `Please summarize the following:\\n\\n${options.text}` },\n          ],\n        },\n      ],\n      config: {\n        systemInstruction: systemPrompt,\n      },\n    })\n\n    for await (const chunk of result) {\n      // Track usage metadata\n      if (chunk.usageMetadata) {\n        inputTokens = chunk.usageMetadata.promptTokenCount ?? inputTokens\n        outputTokens = chunk.usageMetadata.candidatesTokenCount ?? outputTokens\n      }\n\n      if (chunk.candidates?.[0]?.content?.parts) {\n        for (const part of chunk.candidates[0].content.parts) {\n          if (part.text) {\n            accumulatedContent += part.text\n            yield {\n              type: 'content',\n              id,\n              model,\n              timestamp: Date.now(),\n              delta: part.text,\n              content: accumulatedContent,\n              role: 'assistant',\n            }\n          }\n        }\n      }\n\n      // Check for finish reason\n      const finishReason = chunk.candidates?.[0]?.finishReason\n      if (\n        finishReason === FinishReason.STOP ||\n        finishReason === FinishReason.MAX_TOKENS ||\n        finishReason === FinishReason.SAFETY\n      ) {\n        yield {\n          type: 'done',\n          id,\n          model,\n          timestamp: Date.now(),\n          finishReason:\n            finishReason === FinishReason.STOP\n              ? 'stop'\n              : finishReason === FinishReason.MAX_TOKENS\n                ? 'length'\n                : 'content_filter',\n          usage: {\n            promptTokens: inputTokens,\n            completionTokens: outputTokens,\n            totalTokens: inputTokens + outputTokens,\n          },\n        }\n      }\n    }\n  }\n\n  private getFormatInstructions(\n    style?: 'paragraph' | 'bullet-points' | 'concise',\n  ): string {\n    switch (style) {\n      case 'bullet-points':\n        return 'Provide the summary as bullet points.'\n      case 'concise':\n        return 'Provide a very brief one or two sentence summary.'\n      case 'paragraph':\n      default:\n        return 'Provide the summary in paragraph form.'\n    }\n  }\n}\n\n/**\n * Creates a Gemini summarize adapter with explicit API key and model\n */\nexport function createGeminiSummarize<TModel extends GeminiSummarizeModel>(\n  apiKey: string,\n  model: TModel,\n  options?: GeminiSummarizeAdapterOptions,\n): GeminiSummarizeAdapter<TModel> {\n  return new GeminiSummarizeAdapter(apiKey, model, options)\n}\n\n/**\n * Creates a Gemini summarize adapter with API key from environment and required model\n */\nexport function geminiSummarize<TModel extends GeminiSummarizeModel>(\n  model: TModel,\n  options?: GeminiSummarizeAdapterOptions,\n): GeminiSummarizeAdapter<TModel> {\n  const apiKey = getGeminiApiKeyFromEnv()\n  return new GeminiSummarizeAdapter(apiKey, model, options)\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/adapters/text.d.ts

@@ -0,0 +1,63 @@
+import { BaseTextAdapter, StructuredOutputOptions, StructuredOutputResult } from '@tanstack/ai/adapters';
+import { GEMINI_MODELS, GeminiChatModelProviderOptionsByName, GeminiModelInputModalitiesByName } from '../model-meta.js';
+import { Modality, StreamChunk, TextOptions } from '@tanstack/ai';
+import { ExternalTextProviderOptions } from '../text/text-provider-options.js';
+import { GeminiMessageMetadataByModality } from '../message-types.js';
+import { GeminiClientConfig } from '../utils.js';
+/**
+ * Configuration for Gemini text adapter
+ */
+export interface GeminiTextConfig extends GeminiClientConfig {
+}
+/**
+ * Gemini-specific provider options for text/chat
+ */
+export type GeminiTextProviderOptions = ExternalTextProviderOptions;
+/**
+ * Resolve provider options for a specific model.
+ * If the model has explicit options in the map, use those; otherwise use base options.
+ */
+type ResolveProviderOptions<TModel extends string> = TModel extends keyof GeminiChatModelProviderOptionsByName ? GeminiChatModelProviderOptionsByName[TModel] : GeminiTextProviderOptions;
+/**
+ * Resolve input modalities for a specific model.
+ * If the model has explicit modalities in the map, use those; otherwise use all modalities.
+ */
+type ResolveInputModalities<TModel extends string> = TModel extends keyof GeminiModelInputModalitiesByName ? GeminiModelInputModalitiesByName[TModel] : readonly ['text', 'image', 'audio', 'video', 'document'];
+/**
+ * Gemini Text (Chat) Adapter
+ *
+ * Tree-shakeable adapter for Gemini chat/text completion functionality.
+ * Import only what you need for smaller bundle sizes.
+ */
+export declare class GeminiTextAdapter<TModel extends (typeof GEMINI_MODELS)[number], TProviderOptions extends object = ResolveProviderOptions<TModel>, TInputModalities extends ReadonlyArray<Modality> = ResolveInputModalities<TModel>> extends BaseTextAdapter<TModel, TProviderOptions, TInputModalities, GeminiMessageMetadataByModality> {
+    readonly kind: "text";
+    readonly name: "gemini";
+    private client;
+    constructor(config: GeminiTextConfig, model: TModel);
+    chatStream(options: TextOptions<GeminiTextProviderOptions>): AsyncIterable<StreamChunk>;
+    /**
+     * Generate structured output using Gemini's native JSON response format.
+     * Uses responseMimeType: 'application/json' and responseSchema for structured output.
+     * The outputSchema is already JSON Schema (converted in the ai layer).
+     */
+    structuredOutput(options: StructuredOutputOptions<GeminiTextProviderOptions>): Promise<StructuredOutputResult<unknown>>;
+    /**
+     * Extract text content from a non-streaming response
+     */
+    private extractTextFromResponse;
+    private processStreamChunks;
+    private convertContentPartToGemini;
+    private formatMessages;
+    private mapCommonOptionsToGemini;
+}
+/**
+ * Creates a Gemini text adapter with explicit API key.
+ * Type resolution happens here at the call site.
+ */
+export declare function createGeminiChat<TModel extends (typeof GEMINI_MODELS)[number]>(model: TModel, apiKey: string, config?: Omit<GeminiTextConfig, 'apiKey'>): GeminiTextAdapter<TModel, ResolveProviderOptions<TModel>, ResolveInputModalities<TModel>>;
+/**
+ * Creates a Gemini text adapter with automatic API key detection.
+ * Type resolution happens here at the call site.
+ */
+export declare function geminiText<TModel extends (typeof GEMINI_MODELS)[number]>(model: TModel, config?: Omit<GeminiTextConfig, 'apiKey'>): GeminiTextAdapter<TModel, ResolveProviderOptions<TModel>, ResolveInputModalities<TModel>>;
+export {};