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

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

@@ -0,0 +1,199 @@
+import { googleGeminiAuth } from '../auth';
+import { ApFile, DynamicPropsValue, Property, createAction } from '@agnocon/pieces-framework';
+import { defaultLLM, getGeminiModelOptions } from '../common/common';
+import { GenerateContentParameters, GoogleGenAI } from '@google/genai';
+import { isEmpty } from '@agnocon/pieces-framework';
+import { MarkdownVariant } from '@agnocon/pieces-framework';
+import mime from 'mime-types';
+import { generateContentActionOutputSchema } from '../output-schemas';
+
+export const generateContentAction = createAction({
+  audience: 'both',
+	description: 'Generate content using Google Gemini using the "gemini-pro" model',
+	aiMetadata: { description: 'Runs a single stateless prompt through a Gemini text model and returns the generated text, optionally grounded by one built-in tool: Google Search for live web results, URL Context to fetch pages named in the prompt, Google Maps scoped to a latitude/longitude, or File Search over an uploaded file. Use this as the default Gemini text-generation call; prefer chat_gemini when the exchange needs conversation memory, generate_content_from_image when the input includes an image, and create_video or text-to-speech for non-text output. Not idempotent: each call produces a fresh completion, and the File Search mode additionally creates a new file search store.', idempotent: false },
+	displayName: 'Generate Content',
+	name: 'generate_content',
+	auth: googleGeminiAuth,
+	props: {
+		prompt: Property.LongText({
+			displayName: 'Prompt',
+			required: true,
+			description: 'The prompt to generate content from.',
+		}),
+		model: Property.Dropdown({
+			displayName: 'Model',
+			required: true,
+			description: 'The model which will generate the completion',
+			refreshers: [],
+			defaultValue: defaultLLM,
+			auth: googleGeminiAuth,
+			options: async ({ auth }) => getGeminiModelOptions({ auth }),
+		}),
+		toolType: Property.StaticDropdown({
+			displayName: 'Tool Type',
+			description: 'Select built-in tool to use with Gemini model.',
+			required: false,
+			options: {
+				disabled: false,
+				options: [
+					{ label: 'Google Search', value: 'google-search' },
+					{ label: 'File Search', value: 'file-search' },
+					{ label: 'Google Maps', value: 'google-maps' },
+					{ label: 'URL Context', value: 'url-context' },
+				],
+			},
+		}),
+		toolProperties: Property.DynamicProperties({
+			displayName: 'Tool Config',
+			auth: googleGeminiAuth,
+			refreshers: ['toolType'],
+			required: false,
+			props: async ({ auth, toolType }) => {
+				if (!auth || !toolType) return {};
+
+				let props: DynamicPropsValue = {};
+
+				switch (toolType) {
+					case 'file-search':
+						props = {
+							file: Property.File({
+								displayName: 'File',
+								required: true,
+								description: 'File to use for search tool.',
+							}),
+							fileStoreName: Property.ShortText({
+								displayName: 'File Store Name',
+								required: true,
+							}),
+						};
+						break;
+					case 'url-context':
+						props = {
+							mrkdown: Property.MarkDown({
+								variant: MarkdownVariant.INFO,
+								value:
+									'To use URL context tool, include one or more URLs directly in the prompt. Gemini will fetch and use the page content as additional context.',
+							}),
+						};
+						break;
+					case 'google-search':
+						props = {
+							mrkdown: Property.MarkDown({
+								variant: MarkdownVariant.INFO,
+								value:
+									'To use Google Search tool, include a clear search query in the prompt. Gemini will use Google Search to retrieve up-to-date web information.',
+							}),
+						};
+						break;
+					case 'google-maps':
+						props = {
+							latitude: Property.Number({
+								displayName: 'Latitude',
+								required: true,
+								description: 'Provide the relevant location latitude.',
+							}),
+							longitude: Property.Number({
+								displayName: 'Longitude',
+								required: true,
+								description: 'Provide the relevant location longitude.',
+							}),
+						};
+						break;
+					default:
+						break;
+				}
+				return props;
+			},
+		}),
+	},
+	outputSchema: generateContentActionOutputSchema,
+	async run({ auth, propsValue }) {
+		const { model, prompt, toolType } = propsValue;
+		const toolProperties = propsValue.toolProperties ?? {};
+
+		const genAI = new GoogleGenAI({ apiKey: auth.secret_text });
+
+		const params: GenerateContentParameters = {
+			model,
+			contents: prompt,
+		};
+
+		const generate = async () => {
+			const response = await genAI.models.generateContent(params);
+			return response.text;
+		};
+
+		if (isEmpty(toolType)) {
+			return generate();
+		}
+
+		switch (toolType) {
+			case 'file-search': {
+				const { file, fileStoreName } = toolProperties as { file: ApFile; fileStoreName: string };
+
+				const fileBlob = new Blob([Buffer.from(file.base64, 'base64')], {
+					type: mime.lookup(file.extension || file.filename) || undefined,
+				});
+
+				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 });
+				}
+
+				params.config = {
+					tools: [
+						{
+							fileSearch: {
+								fileSearchStoreNames: [fileSearchStore.name!],
+							},
+						},
+					],
+				};
+
+				break;
+			}
+			case 'url-context': {
+				params.config = {
+					tools: [{ urlContext: {} }],
+				};
+				break;
+			}
+			case 'google-search': {
+				params.config = {
+					tools: [{ googleSearch: {} }],
+				};
+				break;
+			}
+			case 'google-maps': {
+				const { latitude, longitude } = toolProperties as { latitude: number; longitude: number };
+
+				params.config = {
+					tools: [{ googleMaps: {} }],
+					toolConfig: {
+						retrievalConfig: {
+							latLng: {
+								latitude,
+								longitude,
+							},
+						},
+					},
+				};
+
+				break;
+			}
+		}
+
+		return generate();
+	},
+});

package/src/lib/actions/text-to-speech.action.ts

@@ -0,0 +1,143 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { googleGeminiAuth } from '../auth';
+import { getGeminiTtsModelOptions } from '../common/common';
+import { GoogleGenAI } from '@google/genai';
+import wav from 'wav';
+import { Writable } from 'stream';
+import { textToSpeechActionOutputSchema } from '../output-schemas';
+
+export const textToSpeechAction = createAction({
+  audience: 'both',
+  name: 'text-to-speech',
+  auth: googleGeminiAuth,
+  displayName: 'Text to Speech',
+  description: 'Converts text to audio file.',
+  aiMetadata: { description: 'Synthesizes spoken audio from input text using a Gemini TTS model and one of roughly thirty prebuilt named voices, returning a WAV file. This is the audio-output sibling of generate_content: use it when the flow needs speech instead of text, and create_video when it needs video. Requires a TTS-capable model, which the model dropdown restricts to. Not idempotent: each call renders a new audio file.', idempotent: false },
+  props: {
+    model: Property.Dropdown({
+      displayName: 'Model',
+      required: true,
+      auth: googleGeminiAuth,
+      refreshers: [],
+      options: async ({ auth }) => getGeminiTtsModelOptions({ auth }),
+    }),
+    text: Property.LongText({
+      displayName: 'Input Text',
+      required: true,
+    }),
+    voice: Property.StaticDropdown({
+      displayName: 'Voice',
+      required: true,
+      options: {
+        disabled: false,
+        options: [
+          { label: 'Zephyr (Bright)', value: 'Zephyr' },
+          { label: 'Puck (Upbeat)', value: 'Puck' },
+          { label: 'Charon (Informative)', value: 'Charon' },
+          { label: 'Kore (Firm)', value: 'Kore' },
+          { label: 'Fenrir (Excitable)', value: 'Fenrir' },
+          { label: 'Leda (Youthful)', value: 'Leda' },
+          { label: 'Orus (Firm)', value: 'Orus' },
+          { label: 'Aoede (Breezy)', value: 'Aoede' },
+          { label: 'Callirrhoe (Easy-going)', value: 'Callirrhoe' },
+          { label: 'Autonoe (Bright)', value: 'Autonoe' },
+          { label: 'Enceladus (Breathy)', value: 'Enceladus' },
+          { label: 'Iapetus (Clear)', value: 'Iapetus' },
+          { label: 'Umbriel (Easy-going)', value: 'Umbriel' },
+          { label: 'Algieba (Smooth)', value: 'Algieba' },
+          { label: 'Despina (Smooth)', value: 'Despina' },
+          { label: 'Erinome (Clear)', value: 'Erinome' },
+          { label: 'Algenib (Gravelly)', value: 'Algenib' },
+          { label: 'Rasalgethi (Informative)', value: 'Rasalgethi' },
+          { label: 'Laomedeia (Upbeat)', value: 'Laomedeia' },
+          { label: 'Achernar (Soft)', value: 'Achernar' },
+          { label: 'Alnilam (Firm)', value: 'Alnilam' },
+          { label: 'Schedar (Even)', value: 'Schedar' },
+          { label: 'Gacrux (Mature)', value: 'Gacrux' },
+          { label: 'Pulcherrima (Forward)', value: 'Pulcherrima' },
+          { label: 'Achird (Friendly)', value: 'Achird' },
+          { label: 'Zubenelgenubi (Casual)', value: 'Zubenelgenubi' },
+          { label: 'Vindemiatrix (Gentle)', value: 'Vindemiatrix' },
+          { label: 'Sadachbia (Lively)', value: 'Sadachbia' },
+          { label: 'Sadaltager (Knowledgeable)', value: 'Sadaltager' },
+          { label: 'Sulafat (Warm)', value: 'Sulafat' },
+        ],
+      },
+    }),
+  },
+  outputSchema: textToSpeechActionOutputSchema,
+  async run(context) {
+    const { text, model, voice } = context.propsValue;
+
+    try {
+      const genAI = new GoogleGenAI({ apiKey: context.auth.secret_text });
+
+      const response = await genAI.models.generateContent({
+        model,
+        contents: [{ parts: [{ text }] }],
+        config: {
+          responseModalities: ['AUDIO'],
+          speechConfig: {
+            voiceConfig: {
+              prebuiltVoiceConfig: { voiceName: voice },
+            },
+          },
+        },
+      });
+
+      const data =
+        response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
+
+      if (!data) {
+        throw new Error('No audio data returned from model response.');
+      }
+
+      const pcmBuffer = Buffer.from(data, 'base64');
+      const wavBuffer = await pcmToWavBuffer(pcmBuffer, 1, 24000, 2);
+
+      return await context.files.write({
+        data: wavBuffer,
+        fileName: 'audio.wav',
+      });
+
+    } catch (error) {
+      console.error('Error in generate content from image:', error);
+      throw error;
+    }
+  },
+});
+
+export async function pcmToWavBuffer(
+  pcmBuffer: Buffer,
+  channels = 1,
+  rate = 24000,
+  sampleWidth = 2
+): Promise<Buffer> {
+  return new Promise<Buffer>((resolve, reject) => {
+    const wavBuffers: Buffer[] = [];
+
+    const writer = new wav.Writer({
+      channels,
+      sampleRate: rate,
+      bitDepth: sampleWidth * 8,
+    });
+
+    const writable = new Writable({
+      write(chunk: Buffer, _encoding, callback) {
+        wavBuffers.push(chunk);
+        callback();
+      },
+    });
+
+    writer.pipe(writable);
+    writer.write(pcmBuffer);
+    writer.end();
+
+    writer.on('finish', () => {
+      const fullWavBuffer = Buffer.concat(wavBuffers);
+      resolve(fullWavBuffer);
+    });
+
+    writer.on('error', (err) => reject(err));
+  });
+}

package/src/lib/auth.ts

@@ -0,0 +1,38 @@
+import { PieceAuth } from '@agnocon/pieces-framework';
+import { httpClient, HttpMethod } from '@agnocon/pieces-common';
+
+const markdownDescription = `
+Follow these instructions to get your API Key:
+1. Visit the following website: https://makersuite.google.com/app/apikey
+2. Once on the website, locate and click on the option to obtain your API Key.
+Please note this piece uses a API in the beta phase that may change at any time.
+`;
+
+export const googleGeminiAuth = PieceAuth.SecretText({
+  description: markdownDescription,
+  displayName: 'API Key',
+  required: true,
+  validate: async (auth) => {
+    try {
+      await httpClient.sendRequest<{
+        data: { id: string }[];
+      }>({
+        url:
+          'https://generativelanguage.googleapis.com/v1beta/models?key=' +
+          auth.auth,
+        method: HttpMethod.GET,
+      });
+      return {
+        valid: true,
+      };
+    } catch (e: any) {
+      const extraErrorInfo = e.response?.body?.error?.message
+        ? `${e.response?.body?.error?.message} status:${e.response?.body?.error?.code}`
+        : e;
+      return {
+        valid: false,
+        error: `${extraErrorInfo}`,
+      };
+    }
+  },
+});

package/src/lib/common/common.ts

@@ -0,0 +1,121 @@
+import {
+  httpClient,
+  HttpMethod,
+  HttpResponse,
+  QueryParams,
+} from '@agnocon/pieces-common';
+import { AppConnectionValueForAuthProperty } from '@agnocon/pieces-framework';
+import { googleGeminiAuth } from '../auth';
+
+export const defaultLLM = 'gemini-1.5-flash';
+
+export const allowedLLMs = [
+  'gemini-1.5-flash',
+  'gemini-1.5-flash-8b',
+  'gemini-1.5-pro',
+  'gemini-2.0-flash',
+  'gemini-2.0-flash-lite',
+  'gemini-2.5-flash',
+  'gemini-2.5-pro',
+  'gemini-3-pro'
+];
+
+const isAllowedLLM = (model: GeminiModel): boolean =>
+  allowedLLMs.some((allowed) => model.name.startsWith(`models/${allowed}`));
+
+const isTtsModel = (model: GeminiModel): boolean =>
+  model.name.toLowerCase().includes('tts') ||
+  (model.displayName?.toLowerCase().includes('tts') ?? false);
+
+const isVeoModel = (model: GeminiModel): boolean =>
+  model.name.toLowerCase().includes('veo');
+
+const listAllModels = async ({
+  auth,
+}: {
+  auth: GeminiAuth;
+}): Promise<GeminiModel[]> => {
+  const models: GeminiModel[] = [];
+  let pageToken: string | undefined = undefined;
+
+  do {
+    const queryParams: QueryParams = {
+      key: auth.secret_text,
+      pageSize: '1000',
+    };
+    if (pageToken) {
+      queryParams['pageToken'] = pageToken;
+    }
+
+    const { body }: HttpResponse<GeminiListModelsResponse> =
+      await httpClient.sendRequest<GeminiListModelsResponse>({
+        method: HttpMethod.GET,
+        url: 'https://generativelanguage.googleapis.com/v1beta/models',
+        queryParams,
+      });
+    models.push(...(body.models ?? []));
+    pageToken = body.nextPageToken;
+  } while (pageToken);
+
+  return models;
+};
+
+const fetchModelOptions = async ({
+  auth,
+  filter,
+}: {
+  auth?: GeminiAuth;
+  filter: (model: GeminiModel) => boolean;
+}) => {
+  if (!auth) {
+    return {
+      disabled: true,
+      placeholder: 'Enter your API key first',
+      options: [],
+    };
+  }
+
+  try {
+    const models = await listAllModels({ auth });
+    const options = models.filter(filter).map((model) => ({
+      label: model.displayName ?? model.name.replace('models/', ''),
+      value: model.name.replace('models/', ''),
+    }));
+
+    return {
+      disabled: false,
+      options,
+    };
+  } catch {
+    return {
+      disabled: true,
+      options: [],
+      placeholder: "Couldn't load models, check your API key or try again.",
+    };
+  }
+};
+
+export const getGeminiModelOptions = async ({ auth }: { auth?: GeminiAuth }) =>
+  fetchModelOptions({ auth, filter: isAllowedLLM });
+
+export const getGeminiTtsModelOptions = async ({ auth }: { auth?: GeminiAuth }) =>
+  fetchModelOptions({ auth, filter: isTtsModel });
+
+export const getGeminiVideoModelOptions = async ({
+  auth,
+}: {
+  auth?: GeminiAuth;
+}) => fetchModelOptions({ auth, filter: isVeoModel });
+
+type GeminiAuth = AppConnectionValueForAuthProperty<typeof googleGeminiAuth>;
+
+type GeminiModel = {
+  name: string;
+  displayName?: string;
+  supportedGenerationMethods?: string[];
+};
+
+type GeminiListModelsResponse = {
+  models?: GeminiModel[];
+  nextPageToken?: string;
+};

package/src/lib/output-schemas.ts

@@ -0,0 +1,131 @@
+import { OutputSchema } from '@agnocon/pieces-framework';
+
+export const generateContentActionOutputSchema: OutputSchema = {
+	fields: [
+		{
+			key: 'text',
+			label: 'Generated Content',
+			value: '',
+		},
+	],
+};
+
+export const chatGeminiActionOutputSchema: OutputSchema = {
+  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',
+        },
+      ],
+    },
+  ],
+};
+
+export const generateContentFromImageActionOutputSchema: OutputSchema = {
+  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',
+        },
+      ],
+    },
+  ],
+};
+
+export const generateContentWithFilesearchActionOutputSchema: OutputSchema = {
+  fields: [
+    {
+      key: 'text',
+      label: 'Generated Content',
+      value: '',
+    },
+  ],
+};
+
+export const textToSpeechActionOutputSchema: OutputSchema = {
+  fields: [
+    {
+      key: 'audioFile',
+      label: 'Audio File URL',
+      value: '',
+      format: 'url',
+    },
+  ],
+};

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.