@divyacon/piece-google-gemini 0.0.0-stage → 0.1.1

package/dist/lib/output-schemas.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textToSpeechActionOutputSchema = exports.generateContentWithFilesearchActionOutputSchema = exports.generateContentFromImageActionOutputSchema = exports.chatGeminiActionOutputSchema = exports.generateContentActionOutputSchema = void 0;
+exports.generateContentActionOutputSchema = {
+    fields: [
+        {
+            key: 'text',
+            label: 'Generated Content',
+            value: '',
+        },
+    ],
+};
+exports.chatGeminiActionOutputSchema = {
+    fields: [
+        {
+            key: 'response',
+            label: 'Response',
+            value: 'response',
+        },
+        {
+            key: 'history',
+            label: 'Conversation History',
+            value: 'history',
+            listItems: [
+                {
+                    key: 'role',
+                    label: 'Role',
+                    value: 'role',
+                },
+                {
+                    key: 'text',
+                    label: 'Text',
+                    value: 'parts[0].text',
+                },
+            ],
+        },
+    ],
+};
+exports.generateContentFromImageActionOutputSchema = {
+    fields: [
+        {
+            key: 'text',
+            label: 'Generated Text',
+            value: 'text',
+        },
+        {
+            key: 'modelVersion',
+            label: 'Model Version',
+            value: 'raw.modelVersion',
+        },
+        {
+            key: 'finishReason',
+            label: 'Finish Reason',
+            value: 'raw.candidates[0].finishReason',
+        },
+        {
+            key: 'candidates',
+            label: 'Candidates',
+            value: 'raw.candidates',
+            listItems: [
+                {
+                    key: 'text',
+                    label: 'Text',
+                    value: 'content.parts[0].text',
+                },
+                {
+                    key: 'role',
+                    label: 'Role',
+                    value: 'content.role',
+                },
+                {
+                    key: 'finishReason',
+                    label: 'Finish Reason',
+                    value: 'finishReason',
+                },
+            ],
+        },
+        {
+            key: 'usageMetadata',
+            label: 'Usage Metadata',
+            value: 'raw.usageMetadata',
+            children: [
+                {
+                    key: 'promptTokenCount',
+                    label: 'Prompt Tokens',
+                    value: 'promptTokenCount',
+                    format: 'number',
+                },
+                {
+                    key: 'candidatesTokenCount',
+                    label: 'Candidates Tokens',
+                    value: 'candidatesTokenCount',
+                    format: 'number',
+                },
+                {
+                    key: 'totalTokenCount',
+                    label: 'Total Tokens',
+                    value: 'totalTokenCount',
+                    format: 'number',
+                },
+                {
+                    key: 'serviceTier',
+                    label: 'Service Tier',
+                    value: 'serviceTier',
+                },
+            ],
+        },
+    ],
+};
+exports.generateContentWithFilesearchActionOutputSchema = {
+    fields: [
+        {
+            key: 'text',
+            label: 'Generated Content',
+            value: '',
+        },
+    ],
+};
+exports.textToSpeechActionOutputSchema = {
+    fields: [
+        {
+            key: 'audioFile',
+            label: 'Audio File URL',
+            value: '',
+            format: 'url',
+        },
+    ],
+};
+//# sourceMappingURL=output-schemas.js.map

package/dist/lib/output-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-schemas.js","sourceRoot":"","sources":["../../src/lib/output-schemas.ts"],"names":[],"mappings":";;;AAIa,QAAA,iCAAiC,GAAiB;IAC9D,MAAM,EAAE;QACP;YACC,GAAG,EAAE,MAAM;YACX,KAAK,EAAE,mBAAmB;YAC1B,KAAK,EAAE,EAAE;SACT;KACD;CACD,CAAC;AAEW,QAAA,4BAA4B,GAAiB;IACxD,MAAM,EAAE;QACN;YACE,GAAG,EAAE,UAAU;YACf,KAAK,EAAE,UAAU;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,GAAG,EAAE,SAAS;YACd,KAAK,EAAE,sBAAsB;YAC7B,KAAK,EAAE,SAAS;YAChB,SAAS,EAAE;gBACT;oBACE,GAAG,EAAE,MAAM;oBACX,KAAK,EAAE,MAAM;oBACb,KAAK,EAAE,MAAM;iBACd;gBACD;oBACE,GAAG,EAAE,MAAM;oBACX,KAAK,EAAE,MAAM;oBACb,KAAK,EAAE,eAAe;iBACvB;aACF;SACF;KACF;CACF,CAAC;AAEW,QAAA,0CAA0C,GAAiB;IACtE,MAAM,EAAE;QACN;YACE,GAAG,EAAE,MAAM;YACX,KAAK,EAAE,gBAAgB;YACvB,KAAK,EAAE,MAAM;SACd;QACD;YACE,GAAG,EAAE,cAAc;YACnB,KAAK,EAAE,eAAe;YACtB,KAAK,EAAE,kBAAkB;SAC1B;QACD;YACE,GAAG,EAAE,cAAc;YACnB,KAAK,EAAE,eAAe;YACtB,KAAK,EAAE,gCAAgC;SACxC;QACD;YACE,GAAG,EAAE,YAAY;YACjB,KAAK,EAAE,YAAY;YACnB,KAAK,EAAE,gBAAgB;YACvB,SAAS,EAAE;gBACT;oBACE,GAAG,EAAE,MAAM;oBACX,KAAK,EAAE,MAAM;oBACb,KAAK,EAAE,uBAAuB;iBAC/B;gBACD;oBACE,GAAG,EAAE,MAAM;oBACX,KAAK,EAAE,MAAM;oBACb,KAAK,EAAE,cAAc;iBACtB;gBACD;oBACE,GAAG,EAAE,cAAc;oBACnB,KAAK,EAAE,eAAe;oBACtB,KAAK,EAAE,cAAc;iBACtB;aACF;SACF;QACD;YACE,GAAG,EAAE,eAAe;YACpB,KAAK,EAAE,gBAAgB;YACvB,KAAK,EAAE,mBAAmB;YAC1B,QAAQ,EAAE;gBACR;oBACE,GAAG,EAAE,kBAAkB;oBACvB,KAAK,EAAE,eAAe;oBACtB,KAAK,EAAE,kBAAkB;oBACzB,MAAM,EAAE,QAAQ;iBACjB;gBACD;oBACE,GAAG,EAAE,sBAAsB;oBAC3B,KAAK,EAAE,mBAAmB;oBAC1B,KAAK,EAAE,sBAAsB;oBAC7B,MAAM,EAAE,QAAQ;iBACjB;gBACD;oBACE,GAAG,EAAE,iBAAiB;oBACtB,KAAK,EAAE,cAAc;oBACrB,KAAK,EAAE,iBAAiB;oBACxB,MAAM,EAAE,QAAQ;iBACjB;gBACD;oBACE,GAAG,EAAE,aAAa;oBAClB,KAAK,EAAE,cAAc;oBACrB,KAAK,EAAE,aAAa;iBACrB;aACF;SACF;KACF;CACF,CAAC;AAEW,QAAA,+CAA+C,GAAiB;IAC3E,MAAM,EAAE;QACN;YACE,GAAG,EAAE,MAAM;YACX,KAAK,EAAE,mBAAmB;YAC1B,KAAK,EAAE,EAAE;SACV;KACF;CACF,CAAC;AAEW,QAAA,8BAA8B,GAAiB;IAC1D,MAAM,EAAE;QACN;YACE,GAAG,EAAE,WAAW;YAChB,KAAK,EAAE,gBAAgB;YACvB,KAAK,EAAE,EAAE;YACT,MAAM,EAAE,KAAK;SACd;KACF;CACF,CAAC"}

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@divyacon/piece-google-gemini",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "DivyaCon google-gemini connector",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "LICENSE.MIT-AP"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "vendor": "node ../scripts/vendor-ap.mjs piece-google-gemini"
+  },
+  "dependencies": {
+    "@agnocon/core-utils": "0.2.0",
+    "@agnocon/piece-types": "0.3.1",
+    "@agnocon/pieces-common": "0.12.8",
+    "@agnocon/pieces-framework": "0.36.0",
+    "tslib": "2.6.2",
+    "@google/genai": "1.29.0",
+    "@google/generative-ai": "0.21.0",
+    "mime-types": "2.1.35",
+    "wav": "^1.0.2",
+    "zod": "4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "20.17.6",
+    "typescript": "5.5.4",
+    "@types/wav": "^1.0.4",
+    "@types/mime-types": "2.1.1"
+  },
+  "license": "MIT",
+  "agnocon": {
+    "originVersion": "0.1.14"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "keywords": [
+    "agnocon",
+    "connector"
+  ]
+}

package/src/index.ts

@@ -0,0 +1,35 @@
+import { createCustomApiCallAction } from '@agnocon/pieces-common';
+import { createPiece } from '@agnocon/pieces-framework';
+import { PieceCategory } from '@agnocon/pieces-framework';
+import { chatGemini } from './lib/actions/chat-gemini.action';
+import { createVideoAction } from './lib/actions/create-video.action';
+import { generateContentFromImageAction } from './lib/actions/generate-content-from-image.action';
+import { generateContentAction } from './lib/actions/generate-content.action';
+import { textToSpeechAction } from './lib/actions/text-to-speech.action';
+import { generateContentWithFileSearchAction } from './lib/actions/generate-content-with-file-search';
+import { googleGeminiAuth } from './lib/auth';
+
+export const googleGemini = createPiece({
+  displayName: 'Google Gemini',
+  auth: googleGeminiAuth,
+  description: 'Use the new Gemini models from Google',
+  minimumSupportedRelease: '0.30.0',
+  logoUrl: 'https://cdn.activepieces.com/pieces/google-gemini.png',
+  categories: [PieceCategory.ARTIFICIAL_INTELLIGENCE],
+  authors: ["pfernandez98","kishanprmr","MoShizzle","AbdulTheActivePiecer","abuaboud"],
+  actions: [
+    generateContentAction,
+    generateContentWithFileSearchAction,
+    generateContentFromImageAction,
+    chatGemini,
+    textToSpeechAction,
+    createVideoAction,
+    createCustomApiCallAction({
+      baseUrl: () => 'https://generativelanguage.googleapis.com/v1beta',
+      auth: googleGeminiAuth,
+      authMapping: async (auth) => ({ key: auth.secret_text }),
+      authLocation: 'queryParams',
+    }),
+  ],
+  triggers: [],
+});

package/src/lib/actions/chat-gemini.action.ts

@@ -0,0 +1,78 @@
+import { Content, GoogleGenerativeAI } from '@google/generative-ai';
+import {
+  Property,
+  StoreScope,
+  createAction,
+} from '@agnocon/pieces-framework';
+import mime from 'mime-types';
+import * as z from 'zod/mini'
+import { googleGeminiAuth } from '../auth';
+import { defaultLLM, getGeminiModelOptions } from '../common/common';
+import { propsValidation } from '@agnocon/pieces-common';
+import { chatGeminiActionOutputSchema } from '../output-schemas';
+
+export const chatGemini = createAction({
+  audience: 'both',
+  auth: googleGeminiAuth,
+  name: 'chat_gemini',
+  displayName: 'Chat Gemini',
+  description: 'Chat with Google Gemini',
+  aiMetadata: { description: 'Sends a prompt as one turn of a Gemini chat and returns the reply, with two modes: supply a memory key (max 128 characters) to load and persist the conversation history in project storage so later runs remember earlier turns, or leave it empty for a stateless single turn. Pick it over generate_content when the exchange spans multiple runs and must retain context; generate_content is the better choice for one-shot generation or when a built-in tool such as Google Search or File Search is needed. Not idempotent: each call produces a new reply and, when a memory key is set, rewrites the stored history.', idempotent: false },
+  props: {
+    model: Property.Dropdown({
+      displayName: 'Model',
+      required: true,
+      description: 'The model which will generate the completion',
+      refreshers: [],
+      auth: googleGeminiAuth,
+      defaultValue: defaultLLM,
+      options: async ({ auth }) => getGeminiModelOptions({ auth }),
+    }),
+    prompt: Property.LongText({
+      displayName: 'Prompt',
+      required: true,
+      description: 'The prompt to generate content from.',
+    }),
+    memoryKey: Property.ShortText({
+      displayName: 'Memory Key',
+      description:
+        'A memory key that will keep the chat history. Keep it empty to leave Gemini without memory of previous messages.',
+      required: false,
+    }),
+  },
+  outputSchema: chatGeminiActionOutputSchema,
+  async run({ auth, propsValue, store }) {
+    await propsValidation.validateZod(propsValue, {
+      memoryKey: z.optional(z.string().check(z.maxLength(128))),
+    });
+
+    const { model, prompt, memoryKey } = propsValue;  
+    const genAI = new GoogleGenerativeAI(auth.secret_text);
+    const geminiModel = genAI.getGenerativeModel({ model });
+    let history: Content[] = [];
+
+    if (memoryKey) {
+      const storedHistory = await store.get(memoryKey, StoreScope.PROJECT);
+      if (Array.isArray(storedHistory)) {
+        history = storedHistory;
+      }
+    }
+
+    const chat = geminiModel.startChat({
+      history: history,
+    });
+
+    const result = await chat.sendMessage(prompt);
+    const responseText = result.response.text();
+
+    if (memoryKey) {
+      const updatedHistory = await chat.getHistory();
+      await store.put(memoryKey, updatedHistory, StoreScope.PROJECT);
+    }
+
+    return {
+      response: responseText,
+      history: history,
+    };
+  },
+});

package/src/lib/actions/create-video.action.ts

@@ -0,0 +1,206 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+import { googleGeminiAuth } from '../auth';
+import { getGeminiVideoModelOptions } from '../common/common';
+import { GoogleGenAI } from '@google/genai';
+import mime from 'mime-types';
+
+export const createVideoAction = createAction({
+  audience: 'both',
+  name: 'create_video',
+  auth: googleGeminiAuth,
+  displayName: 'Create Video',
+  description: 'Generate a video from a text prompt using Google Veo models.',
+  aiMetadata: { description: 'Generates a short video with a Google Veo model from a text prompt, optionally seeded by a start image (image-to-video) or by both a start and end image (interpolation between those frames), polling the long-running generation job for up to 10 minutes before returning the finished MP4 as a file. Use it whenever the required output is video; text goes through generate_content and speech through text-to-speech. Note the model-dependent limits: 1080p needs Veo 3.0 or newer, 4K needs Veo 3.1, and both require an 8-second duration. Not idempotent: each call renders a new video.', idempotent: false },
+  props: {
+    model: Property.Dropdown({
+      displayName: 'Model',
+      required: true,
+      auth: googleGeminiAuth,
+      refreshers: [],
+      defaultValue: 'veo-3.1-generate-preview',
+      options: async ({ auth }) => getGeminiVideoModelOptions({ auth }),
+    }),
+    prompt: Property.LongText({
+      displayName: 'Prompt',
+      description:
+        'Describe the video you want to generate. Be specific about the scene, motion, style, and lighting for best results.',
+      required: true,
+    }),
+    image: Property.File({
+      displayName: 'Start Image',
+      description:
+        'Optional image to use as the first frame of the video (image-to-video).',
+      required: false,
+    }),
+    lastFrame: Property.File({
+      displayName: 'End Image',
+      description:
+        'Optional image to use as the last frame. Use together with Start Image to generate an interpolation video.',
+      required: false,
+    }),
+    aspectRatio: Property.StaticDropdown({
+      displayName: 'Aspect Ratio',
+      required: true,
+      defaultValue: '16:9',
+      options: {
+        disabled: false,
+        options: [
+          { label: '16:9 (Landscape)', value: '16:9' },
+          { label: '9:16 (Portrait)', value: '9:16' },
+        ],
+      },
+    }),
+    durationSeconds: Property.Dropdown({
+      displayName: 'Duration (seconds)',
+      description: 'Must be 8 when using 1080p, 4K, or reference images.',
+      required: false,
+      auth: googleGeminiAuth,
+      refreshers: ['model'],
+      defaultValue: 8,
+      options: async ({ model }) => {
+        const isVeo2 = (model as string)?.startsWith('veo-2');
+        if (isVeo2) {
+          return {
+            disabled: false,
+            options: [
+              { label: '5 seconds', value: 5 },
+              { label: '6 seconds', value: 6 },
+              { label: '7 seconds', value: 7 },
+              { label: '8 seconds', value: 8 },
+            ],
+          };
+        }
+        return {
+          disabled: false,
+          options: [
+            { label: '4 seconds', value: 4 },
+            { label: '6 seconds', value: 6 },
+            { label: '8 seconds', value: 8 },
+          ],
+        };
+      },
+    }),
+    resolution: Property.Dropdown({
+      displayName: 'Resolution',
+      description:
+        '1080p is available on Veo 3.0+ only. 4K is only available on Veo 3.1 models. 1080p and 4K require 8-second duration.',
+      required: false,
+      auth: googleGeminiAuth,
+      refreshers: ['model'],
+      defaultValue: '720p',
+      options: async ({ model }) => {
+        const modelStr = model as string;
+        const isVeo2 = modelStr?.startsWith('veo-2');
+        const is31 = modelStr?.startsWith('veo-3.1');
+        return {
+          disabled: false,
+          options: [
+            { label: '720p', value: '720p' },
+            ...(isVeo2 ? [] : [{ label: '1080p', value: '1080p' }]),
+            ...(is31 ? [{ label: '4K', value: '4k' }] : []),
+          ],
+        };
+      },
+    }),
+    personGeneration: Property.StaticDropdown({
+      displayName: 'Person Generation',
+      description:
+        'Controls whether people or faces can appear in the generated video.',
+      required: false,
+      defaultValue: 'allow_adult',
+      options: {
+        disabled: false,
+        options: [
+          { label: 'Allow Adults Only (default)', value: 'allow_adult' },
+          { label: 'Allow All Ages (requires allowlist)', value: 'allow_all' },
+          { label: "Don't Allow People", value: 'dont_allow' },
+        ],
+      },
+    }),
+  },
+  async run(context) {
+    const {
+      model,
+      prompt,
+      image,
+      lastFrame,
+      aspectRatio,
+      durationSeconds,
+      resolution,
+      personGeneration,
+    } = context.propsValue;
+
+    // API reference: https://docs.cloud.google.com/vertex-ai/generative-ai/docs/model-reference/veo-video-generation#sample-request
+
+    const ai = new GoogleGenAI({ apiKey: context.auth.secret_text });
+
+    let operation = await ai.models.generateVideos({
+      model,
+      prompt,
+      ...(image
+        ? {
+            image: {
+              imageBytes: image.base64,
+              mimeType:
+                mime.lookup(image.extension || image.filename) || 'image/jpeg',
+            },
+          }
+        : {}),
+      config: {
+        aspectRatio,
+        numberOfVideos: 1,
+        durationSeconds,
+        resolution,
+        personGeneration,
+        ...(lastFrame
+          ? {
+              lastFrame: {
+                imageBytes: lastFrame.base64,
+                mimeType:
+                  mime.lookup(lastFrame.extension || lastFrame.filename) ||
+                  'image/jpeg',
+              },
+            }
+          : {}),
+      },
+    });
+
+    const maxWaitMs = 10 * 60 * 1000; // 10 minutes
+    const startTime = Date.now();
+    while (!operation.done) {
+      if (Date.now() - startTime > maxWaitMs) {
+        throw new Error('Video generation timed out after 10 minutes.');
+      }
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+      operation = await ai.operations.getVideosOperation({ operation });
+    }
+
+    const video = operation.response?.generatedVideos?.[0]?.video;
+
+    if (!video) {
+      throw new Error('No video data returned from model response.');
+    }
+
+    let videoBuffer: Buffer;
+
+    if (video.videoBytes) {
+      videoBuffer = Buffer.from(video.videoBytes, 'base64');
+    } else if (video.uri) {
+      const response = await httpClient.sendRequest<ArrayBuffer>({
+        method: HttpMethod.GET,
+        url: video.uri,
+        queryParams: { key: context.auth.secret_text },
+        responseType: 'arraybuffer',
+      });
+      videoBuffer = Buffer.from(response.body);
+    } else {
+      throw new Error('No video bytes or URI in model response.');
+    }
+
+    return await context.files.write({
+      data: videoBuffer,
+      fileName: 'video.mp4',
+    });
+  },
+});

package/src/lib/actions/generate-content-from-image.action.ts

@@ -0,0 +1,67 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import mime from 'mime-types';
+import {
+  Property,
+  createAction,
+} from '@agnocon/pieces-framework';
+import { googleGeminiAuth } from '../auth';
+import { defaultLLM, getGeminiModelOptions } from '../common/common';
+import { generateContentFromImageActionOutputSchema } from '../output-schemas';
+
+export const generateContentFromImageAction = createAction({
+  audience: 'both',
+  description:
+    'Generate content using Google Gemini using the "gemini-pro-vision" model',
+  aiMetadata: { description: 'Sends an image together with a prompt to a vision-capable Gemini model and returns the generated text describing or answering questions about that image, covering captioning, text extraction, and visual question answering. This is the only Gemini action here that accepts image input, so pick it over generate_content whenever a picture is part of the question; the image is required and is sent inline, so keep it small. Not idempotent: each call produces a fresh completion.', idempotent: false },
+  displayName: 'Generate Content from Image',
+  name: 'generate_content_from_image',
+  auth: googleGeminiAuth,
+  props: {
+    prompt: Property.LongText({
+      displayName: 'Prompt',
+      required: true,
+      description: 'The prompt to generate content from.',
+    }),
+    image: Property.File({
+      displayName: 'Image',
+      required: true,
+      description: 'The image to generate content from.'
+    }),
+    model: Property.Dropdown({
+      displayName: 'Model',
+      auth: googleGeminiAuth,
+      required: true,
+      description: 'The model which will generate the completion',
+      refreshers: [],
+      defaultValue: defaultLLM,
+      options: async ({ auth }) =>
+        getGeminiModelOptions({ auth }),
+    }),
+  },
+  outputSchema: generateContentFromImageActionOutputSchema,
+
+  async run({ auth, propsValue }) {
+    const { image, model, prompt } = propsValue;
+    const mimeType =
+      mime.lookup(image.extension || image.filename) ||
+      `image/${image.extension}`;
+
+    const genAI = new GoogleGenerativeAI(auth.secret_text);
+    const generativeModel = genAI.getGenerativeModel({ model });
+    const result = await generativeModel.generateContent([
+      prompt,
+      {
+        inlineData: {
+          data: image.base64,
+          mimeType,
+        },
+      },
+    ]);
+
+    const response = await result.response;
+    return {
+      text: response.text(),
+      raw: response,
+    };
+  },
+});

package/src/lib/actions/generate-content-with-file-search.ts

@@ -0,0 +1,82 @@
+import { googleGeminiAuth } from '../auth';
+import { Property, createAction } from '@agnocon/pieces-framework';
+import { defaultLLM, getGeminiModelOptions } from '../common/common';
+import { GoogleGenAI } from '@google/genai';
+import mime from 'mime-types';
+import { generateContentWithFilesearchActionOutputSchema } from '../output-schemas';
+
+export const generateContentWithFileSearchAction = createAction({
+  audience: 'both',
+  description: 'Generate content with file search functionality.',
+  aiMetadata: { description: 'Uploads one file to a newly created Gemini File Search store, waits for indexing to finish, then answers the prompt grounded on that document. Use it for one-shot question answering over a document supplied at run time; prefer generate_content when no file grounding is needed or when a different built-in tool such as Google Search or URL Context fits better. Both a file and a store display name are required. Not idempotent: every call creates another file search store and a fresh completion.', idempotent: false },
+  displayName: 'Generate Content with File Search',
+  name: 'generate_content_with_filesearch',
+  auth: googleGeminiAuth,
+  props: {
+    prompt: Property.LongText({
+      displayName: 'Prompt',
+      required: true,
+      description: 'The prompt to generate content from.',
+    }),
+    model: Property.Dropdown({
+      displayName: 'Model',
+      auth: googleGeminiAuth,
+      required: true,
+      description: 'The model which will generate the completion',
+      refreshers: [],
+      defaultValue: defaultLLM,
+      options: async ({ auth }) => getGeminiModelOptions({ auth }),
+    }),
+    fileStoreName: Property.ShortText({
+      displayName: 'File Store Name',
+      required: true,
+    }),
+    file: Property.File({
+      displayName: 'File',
+      required: true,
+    }),
+  },
+  outputSchema: generateContentWithFilesearchActionOutputSchema,
+  async run({ auth, propsValue }) {
+    const { file, fileStoreName, model, prompt } = propsValue;
+
+    const fileBlob = new Blob([Buffer.from(file.base64, 'base64')], {
+      type: mime.lookup(file.extension || file.filename) || undefined,
+    });
+
+    const genAI = new GoogleGenAI({ apiKey: auth.secret_text });
+
+    const fileSearchStore = await genAI.fileSearchStores.create({
+      config: { displayName: fileStoreName },
+    });
+
+    let operation = await genAI.fileSearchStores.uploadToFileSearchStore({
+      file: fileBlob,
+      fileSearchStoreName: fileSearchStore.name!,
+      config: {
+        displayName: file.filename,
+      },
+    });
+
+    while (!operation.done) {
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+      operation = await genAI.operations.get({ operation });
+    }
+
+    const response = await genAI.models.generateContent({
+      model: model,
+      contents: prompt,
+      config: {
+        tools: [
+          {
+            fileSearch: {
+              fileSearchStoreNames: [fileSearchStore.name!],
+            },
+          },
+        ],
+      },
+    });
+
+    return response.text;
+  },
+});