@workglow/google-gemini 0.2.33 → 0.2.35

package/dist/ai-runtime.js

@@ -35,6 +35,233 @@ function getModelName(model) {
 // src/ai/registerGeminiInline.ts
 import { registerProviderInline } from "@workglow/ai/provider-utils";
 
+// src/ai/common/Gemini_CapabilitySets.ts
+var GEMINI_TEXT_GENERATION = ["text.generation"];
+var GEMINI_TOOL_USE = ["text.generation", "tool-use"];
+var GEMINI_JSON_MODE = ["text.generation", "json-mode"];
+var GEMINI_TEXT_REWRITER = ["text.rewriter"];
+var GEMINI_TEXT_SUMMARY = ["text.summary"];
+var GEMINI_TEXT_EMBEDDING = ["text.embedding"];
+var GEMINI_IMAGE_GENERATION = ["image.generation"];
+var GEMINI_IMAGE_EDITING = ["image.editing"];
+var GEMINI_COUNT_TOKENS = ["model.count-tokens"];
+var GEMINI_MODEL_SEARCH = ["model.search"];
+var GEMINI_MODEL_INFO = ["model.info"];
+var GEMINI_CAPABILITY_SETS = [
+  GEMINI_TEXT_GENERATION,
+  GEMINI_TOOL_USE,
+  GEMINI_JSON_MODE,
+  GEMINI_TEXT_REWRITER,
+  GEMINI_TEXT_SUMMARY,
+  GEMINI_TEXT_EMBEDDING,
+  GEMINI_IMAGE_GENERATION,
+  GEMINI_IMAGE_EDITING,
+  GEMINI_COUNT_TOKENS,
+  GEMINI_MODEL_SEARCH,
+  GEMINI_MODEL_INFO
+];
+
+// src/ai/common/Gemini_Schema.ts
+function sanitizeSchemaForGemini(schema) {
+  const result = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "additionalProperties")
+      continue;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = sanitizeSchemaForGemini(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/ai/common/Gemini_CountTokens.ts
+var Gemini_CountTokens_Stream = async (input, model, signal, emit) => {
+  const GoogleGenerativeAI = await loadGeminiSDK();
+  const genAI = new GoogleGenerativeAI(getApiKey(model));
+  const genModel = genAI.getGenerativeModel({ model: getModelName(model) });
+  const result = await genModel.countTokens(input.text);
+  emit({ type: "finish", data: { count: result.totalTokens } });
+};
+var Gemini_CountTokens_Preview = async (input, _model) => {
+  return { count: Math.ceil(input.text.length / 4) };
+};
+
+// src/ai/common/Gemini_ImageEdit.ts
+import { ImageGenerationContentPolicyError, ImageGenerationProviderError } from "@workglow/ai";
+import { getLogger } from "@workglow/util/worker";
+import { dataUriToImageValue, imageValueToPngBytes } from "@workglow/ai/provider-utils";
+function modelIdOf(model) {
+  return model?.model_id ?? model?.provider_config?.model_name ?? "gemini";
+}
+async function decodeInlineImage(mimeType, data) {
+  return dataUriToImageValue(`data:${mimeType};base64,${data}`);
+}
+async function gpuImageToInlinePart(image) {
+  if (typeof image === "string" && image.startsWith("data:")) {
+    const base642 = image.replace(/^data:[^;]+;base64,/, "");
+    return { inlineData: { mimeType: "image/png", data: base642 } };
+  }
+  const bytes = await imageValueToPngBytes(image);
+  let base64;
+  if (typeof Buffer !== "undefined") {
+    base64 = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+  } else {
+    let binary = "";
+    for (let i = 0;i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    base64 = btoa(binary);
+  }
+  return { inlineData: { mimeType: "image/png", data: base64 } };
+}
+var Gemini_ImageEdit_Stream = async (input, model, signal, emit) => {
+  const logger = getLogger();
+  const timer = `gemini:ImageEdit:${modelIdOf(model)}`;
+  logger.time(timer, { model: modelIdOf(model) });
+  try {
+    const GoogleGenerativeAI = await loadGeminiSDK();
+    const genAI = new GoogleGenerativeAI(getApiKey(model));
+    const modelName = getModelName(model);
+    const genModel = genAI.getGenerativeModel({ model: modelName });
+    const primaryPart = await gpuImageToInlinePart(input.image);
+    const additionalParts = input.additionalImages && input.additionalImages.length > 0 ? await Promise.all(input.additionalImages.map((g) => gpuImageToInlinePart(g))) : [];
+    const parts = [{ text: input.prompt }, primaryPart, ...additionalParts];
+    try {
+      const result = await genModel.generateContent({ contents: [{ role: "user", parts }] }, {
+        signal
+      });
+      const response = result.response;
+      if (!response.candidates || response.candidates.length === 0 || response.promptFeedback?.blockReason) {
+        const reason = response.promptFeedback?.blockReason ?? "SAFETY";
+        throw new ImageGenerationContentPolicyError(modelIdOf(model), `Blocked: ${reason}`);
+      }
+      const candidateParts = response.candidates[0]?.content?.parts ?? [];
+      const imagePart = candidateParts.find((p) => p.inlineData && p.inlineData.mimeType && p.inlineData.data);
+      if (!imagePart) {
+        throw new ImageGenerationProviderError(modelIdOf(model), "No image part in response (Gemini did not return an inline image)");
+      }
+      const image = await decodeInlineImage(imagePart.inlineData.mimeType, imagePart.inlineData.data);
+      emit({ type: "snapshot", data: { image } });
+      emit({ type: "finish", data: {} });
+    } catch (err) {
+      if (err instanceof ImageGenerationProviderError || err instanceof ImageGenerationContentPolicyError) {
+        throw err;
+      }
+      const msg = err instanceof Error ? err.message : "unknown error";
+      if (/safety|policy|moderation|blocked|SAFETY|PROHIBITED/i.test(msg)) {
+        throw new ImageGenerationContentPolicyError(modelIdOf(model), msg);
+      }
+      throw new ImageGenerationProviderError(modelIdOf(model), msg, { cause: err });
+    }
+  } finally {
+    logger.timeEnd(timer, { model: modelIdOf(model) });
+  }
+};
+
+// src/ai/common/Gemini_ImageGenerate.ts
+import { ImageGenerationContentPolicyError as ImageGenerationContentPolicyError2, ImageGenerationProviderError as ImageGenerationProviderError2 } from "@workglow/ai";
+import { getLogger as getLogger2 } from "@workglow/util/worker";
+import { dataUriToImageValue as dataUriToImageValue2 } from "@workglow/ai/provider-utils";
+function modelIdOf2(model) {
+  return model?.model_id ?? model?.provider_config?.model_name ?? "gemini";
+}
+async function decodeInlineImage2(mimeType, data) {
+  return dataUriToImageValue2(`data:${mimeType};base64,${data}`);
+}
+var Gemini_ImageGenerate_Stream = async (input, model, signal, emit) => {
+  const logger = getLogger2();
+  const timer = `gemini:ImageGenerate:${modelIdOf2(model)}`;
+  logger.time(timer, { model: modelIdOf2(model) });
+  try {
+    const GoogleGenerativeAI = await loadGeminiSDK();
+    const genAI = new GoogleGenerativeAI(getApiKey(model));
+    const modelName = getModelName(model);
+    const genModel = genAI.getGenerativeModel({ model: modelName });
+    const parts = [{ text: input.prompt }];
+    try {
+      const result = await genModel.generateContent({ contents: [{ role: "user", parts }] }, {
+        signal
+      });
+      const response = result.response;
+      if (!response.candidates || response.candidates.length === 0 || response.promptFeedback?.blockReason) {
+        const reason = response.promptFeedback?.blockReason ?? "SAFETY";
+        throw new ImageGenerationContentPolicyError2(modelIdOf2(model), `Blocked: ${reason}`);
+      }
+      const candidateParts = response.candidates[0]?.content?.parts ?? [];
+      const imagePart = candidateParts.find((p) => p.inlineData && p.inlineData.mimeType && p.inlineData.data);
+      if (!imagePart) {
+        throw new ImageGenerationProviderError2(modelIdOf2(model), "No image part in response (Gemini did not return an inline image)");
+      }
+      const image = await decodeInlineImage2(imagePart.inlineData.mimeType, imagePart.inlineData.data);
+      emit({ type: "snapshot", data: { image } });
+      emit({ type: "finish", data: {} });
+    } catch (err) {
+      if (err instanceof ImageGenerationProviderError2 || err instanceof ImageGenerationContentPolicyError2) {
+        throw err;
+      }
+      const msg = err instanceof Error ? err.message : "unknown error";
+      if (/safety|policy|moderation|blocked|SAFETY|PROHIBITED/i.test(msg)) {
+        throw new ImageGenerationContentPolicyError2(modelIdOf2(model), msg);
+      }
+      throw new ImageGenerationProviderError2(modelIdOf2(model), msg, { cause: err });
+    }
+  } finally {
+    logger.timeEnd(timer, { model: modelIdOf2(model) });
+  }
+};
+
+// src/ai/common/Gemini_ModelInfo.ts
+var GEMINI_EMBEDDING_DIMENSIONS = {
+  "text-embedding-004": { native_dimensions: 768, mrl: true },
+  "embedding-001": { native_dimensions: 768, mrl: false }
+};
+var Gemini_ModelInfo_Stream = async (input, model, _signal, emit) => {
+  if (input.detail === "dimensions") {
+    const pc = model?.provider_config;
+    let native_dimensions = typeof pc?.native_dimensions === "number" ? pc.native_dimensions : undefined;
+    let mrl = typeof pc?.mrl === "boolean" ? pc.mrl : undefined;
+    if (native_dimensions === undefined) {
+      const modelName = pc?.model_name ?? "";
+      const known = GEMINI_EMBEDDING_DIMENSIONS[modelName];
+      if (known) {
+        native_dimensions = known.native_dimensions;
+        mrl = mrl ?? known.mrl;
+      }
+    }
+    emit({
+      type: "finish",
+      data: {
+        model: input.model,
+        is_local: false,
+        is_remote: true,
+        supports_browser: true,
+        supports_node: true,
+        is_cached: false,
+        is_loaded: false,
+        file_sizes: null,
+        ...native_dimensions !== undefined ? { native_dimensions } : {},
+        ...mrl !== undefined ? { mrl } : {}
+      }
+    });
+    return;
+  }
+  emit({
+    type: "finish",
+    data: {
+      model: input.model,
+      is_local: false,
+      is_remote: true,
+      supports_browser: true,
+      supports_node: true,
+      is_cached: false,
+      is_loaded: false,
+      file_sizes: null
+    }
+  });
+};
+
 // src/ai/common/Gemini_ModelSearch.ts
 import { normalizedModelSearchQuery } from "@workglow/ai/provider-utils";
 
@@ -42,7 +269,7 @@ import { normalizedModelSearchQuery } from "@workglow/ai/provider-utils";
 var GOOGLE_GEMINI = "GOOGLE_GEMINI";
 
 // src/ai/common/Gemini_ModelSearch.ts
-var GEMINI_MODELS = [
+var GEMINI_FALLBACK_MODELS = [
   { label: "gemini-3.1-pro-preview", value: "gemini-3.1-pro-preview" },
   { label: "gemini-3-flash-preview", value: "gemini-3-flash-preview" },
   { label: "gemini-3.1-flash-lite-preview", value: "gemini-3.1-flash-lite-preview" },
@@ -51,36 +278,36 @@ var GEMINI_MODELS = [
   {
     label: "gemini-embedding-2",
     value: "gemini-embedding-2",
-    tasks: ["TextEmbeddingTask"]
+    capabilities: ["text.embedding"]
   },
   {
     label: "gemini-embedding-001",
     value: "gemini-embedding-001",
-    tasks: ["TextEmbeddingTask"]
+    capabilities: ["text.embedding"]
   },
   {
     label: "gemini-3.1-flash-image-preview",
     value: "gemini-3.1-flash-image-preview",
-    tasks: ["ImageGenerateTask", "ImageEditTask"]
+    capabilities: ["image.generation", "image.editing"]
   },
   {
     label: "gemini-3-pro-image-preview",
     value: "gemini-3-pro-image-preview",
-    tasks: ["ImageGenerateTask", "ImageEditTask"]
+    capabilities: ["image.generation", "image.editing"]
   },
   {
     label: "imagen-4.0-generate-001",
     value: "imagen-4.0-generate-001",
-    tasks: ["ImageGenerateTask"]
+    capabilities: ["image.generation"]
   }
 ];
-function tasksForGeminiApiModel(model, id) {
-  const staticEntry = GEMINI_MODELS.find((m) => m.value === id);
-  if (staticEntry?.tasks)
-    return [...staticEntry.tasks];
+function capabilitiesForGeminiApiModel(model, id) {
+  const staticEntry = GEMINI_FALLBACK_MODELS.find((m) => m.value === id);
+  if (staticEntry?.capabilities)
+    return [...staticEntry.capabilities];
   const methods = model.supportedGenerationMethods ?? [];
   if (methods.some((method) => method.toLowerCase().includes("embed"))) {
-    return ["TextEmbeddingTask"];
+    return ["text.embedding"];
   }
   return [];
 }
@@ -96,7 +323,7 @@ function mapGeminiModel(model) {
       provider: GOOGLE_GEMINI,
       title,
       description: model.description ?? "",
-      tasks: tasksForGeminiApiModel(model, id),
+      capabilities: capabilitiesForGeminiApiModel(model, id),
       provider_config: { model_name: id },
       metadata: {}
     },
@@ -113,14 +340,15 @@ async function listGeminiModels(credentialKey, signal) {
   const body = await response.json();
   return (body.models ?? []).map(mapGeminiModel);
 }
-var Gemini_ModelSearch = async (input, _model, _onProgress, signal) => {
+var Gemini_ModelSearch_Stream = async (input, _model, signal, emit) => {
   const q = normalizedModelSearchQuery(input.query);
   if (input.credential_key) {
     const models = await listGeminiModels(input.credential_key, signal);
     const results2 = q ? models.filter((m) => m.id.toLowerCase().includes(q) || m.label.toLowerCase().includes(q)) : models;
-    return { results: results2 };
+    emit({ type: "finish", data: { results: results2 } });
+    return;
   }
-  const filtered = q ? GEMINI_MODELS.filter((m) => m.value.toLowerCase().includes(q) || m.label.toLowerCase().includes(q)) : GEMINI_MODELS;
+  const filtered = q ? GEMINI_FALLBACK_MODELS.filter((m) => m.value.toLowerCase().includes(q) || m.label.toLowerCase().includes(q)) : GEMINI_FALLBACK_MODELS;
   const results = filtered.map((m) => ({
     id: m.value,
     label: m.label,
@@ -130,29 +358,95 @@ var Gemini_ModelSearch = async (input, _model, _onProgress, signal) => {
       provider: GOOGLE_GEMINI,
       title: m.value,
       description: "",
-      tasks: m.tasks ? [...m.tasks] : [],
+      capabilities: m.capabilities ? [...m.capabilities] : [],
       provider_config: { model_name: m.value },
       metadata: {}
     },
     raw: m
   }));
-  return { results };
+  emit({ type: "finish", data: { results } });
 };
 
-// src/ai/common/Gemini_Schema.ts
-function sanitizeSchemaForGemini(schema) {
-  const result = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (key === "additionalProperties")
-      continue;
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      result[key] = sanitizeSchemaForGemini(value);
-    } else {
-      result[key] = value;
+// src/ai/common/Gemini_StructuredGeneration.ts
+import { parsePartialJson } from "@workglow/util/worker";
+var Gemini_StructuredGeneration_Stream = async (input, model, signal, emit, outputSchema) => {
+  const GoogleGenerativeAI = await loadGeminiSDK();
+  const genAI = new GoogleGenerativeAI(getApiKey(model));
+  const schema = input.outputSchema ?? outputSchema;
+  const sanitizedSchema = sanitizeSchemaForGemini(schema);
+  const genModel = genAI.getGenerativeModel({
+    model: getModelName(model),
+    generationConfig: {
+      responseMimeType: "application/json",
+      responseSchema: sanitizedSchema,
+      maxOutputTokens: input.maxTokens,
+      temperature: input.temperature
+    }
+  });
+  const result = await genModel.generateContentStream({ contents: [{ role: "user", parts: [{ text: input.prompt }] }] }, { signal });
+  let accumulatedJson = "";
+  for await (const chunk of result.stream) {
+    const text = chunk.text();
+    if (text) {
+      accumulatedJson += text;
+      const partial = parsePartialJson(accumulatedJson);
+      if (partial !== undefined) {
+        emit({ type: "object-delta", port: "object", objectDelta: partial });
+      }
     }
   }
-  return result;
-}
+  let finalObject;
+  try {
+    finalObject = JSON.parse(accumulatedJson);
+  } catch {
+    finalObject = parsePartialJson(accumulatedJson) ?? {};
+  }
+  emit({ type: "finish", data: { object: finalObject } });
+};
+
+// src/ai/common/Gemini_TextEmbedding.ts
+import { getLogger as getLogger3 } from "@workglow/util/worker";
+var Gemini_TextEmbedding_Stream = async (input, model, _signal, emit) => {
+  const logger = getLogger3();
+  const timerLabel = `gemini:TextEmbedding:${model?.provider_config?.model_name}`;
+  logger.time(timerLabel, { model: model?.provider_config?.model_name });
+  try {
+    const GoogleGenerativeAI = await loadGeminiSDK();
+    const genAI = new GoogleGenerativeAI(getApiKey(model));
+    const embeddingModel = genAI.getGenerativeModel({
+      model: getModelName(model)
+    });
+    const taskType = model?.provider_config?.embedding_task_type || "RETRIEVAL_DOCUMENT";
+    if (Array.isArray(input.text)) {
+      const result2 = await embeddingModel.batchEmbedContents({
+        requests: input.text.map((t) => ({
+          content: { role: "user", parts: [{ text: t }] },
+          taskType
+        }))
+      });
+      emit({
+        type: "finish",
+        data: {
+          vector: result2.embeddings.map((e) => new Float32Array(e.values))
+        }
+      });
+      return;
+    }
+    const result = await embeddingModel.embedContent({
+      content: { role: "user", parts: [{ text: input.text }] },
+      taskType
+    });
+    emit({
+      type: "finish",
+      data: { vector: new Float32Array(result.embedding.values) }
+    });
+  } finally {
+    logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
+  }
+};
+
+// src/ai/common/Gemini_TextGeneration.ts
+import { getLogger as getLogger4 } from "@workglow/util/worker";
 
 // src/ai/common/Gemini_ToolCalling.ts
 import { buildToolDescription, filterValidToolCalls } from "@workglow/ai/worker";
@@ -231,49 +525,7 @@ function mapGeminiToolConfig(toolChoice) {
     }
   };
 }
-var Gemini_ToolCalling = async (input, model, update_progress, signal) => {
-  update_progress(0, "Starting Gemini tool calling");
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const functionDeclarations = input.tools.map((t) => ({
-    name: t.name,
-    description: buildToolDescription(t),
-    parameters: sanitizeSchemaForGemini(t.inputSchema)
-  }));
-  const toolConfig = mapGeminiToolConfig(input.toolChoice);
-  const genModel = genAI.getGenerativeModel({
-    model: getModelName(model),
-    tools: [{ functionDeclarations }],
-    toolConfig,
-    systemInstruction: input.systemPrompt || undefined,
-    generationConfig: {
-      maxOutputTokens: input.maxTokens,
-      temperature: input.temperature
-    }
-  });
-  const contents = buildGeminiContents(input.messages, input.prompt);
-  const result = await genModel.generateContent({ contents });
-  const parts = result.response.candidates?.[0]?.content?.parts ?? [];
-  const textParts = [];
-  const toolCalls = [];
-  let callIndex = 0;
-  for (const part of parts) {
-    if ("text" in part && part.text) {
-      textParts.push(part.text);
-    }
-    if ("functionCall" in part && part.functionCall) {
-      const id = `call_${callIndex++}`;
-      toolCalls.push({
-        id,
-        name: part.functionCall.name,
-        input: part.functionCall.args ?? {}
-      });
-    }
-  }
-  update_progress(100, "Completed Gemini tool calling");
-  return { text: textParts.join(""), toolCalls: filterValidToolCalls(toolCalls, input.tools) };
-};
-var Gemini_ToolCalling_Stream = async function* (input, model, signal) {
+var Gemini_ToolCalling_Stream = async (input, model, signal, emit) => {
   const GoogleGenerativeAI = await loadGeminiSDK();
   const genAI = new GoogleGenerativeAI(getApiKey(model));
   const functionDeclarations = input.tools.map((t) => ({
@@ -299,414 +551,83 @@ var Gemini_ToolCalling_Stream = async function* (input, model, signal) {
     const parts = chunk.candidates?.[0]?.content?.parts ?? [];
     for (const part of parts) {
       if ("text" in part && part.text) {
-        yield { type: "text-delta", port: "text", textDelta: part.text };
+        emit({ type: "text-delta", port: "text", textDelta: part.text });
       }
       if ("functionCall" in part && part.functionCall) {
         const id = `call_${callIndex++}`;
-        yield {
-          type: "object-delta",
-          port: "toolCalls",
-          objectDelta: [
-            {
-              id,
-              name: part.functionCall.name,
-              input: part.functionCall.args ?? {}
-            }
-          ]
-        };
+        const validated = filterValidToolCalls([
+          {
+            id,
+            name: part.functionCall.name,
+            input: part.functionCall.args ?? {}
+          }
+        ], input.tools);
+        if (validated.length > 0) {
+          emit({
+            type: "object-delta",
+            port: "toolCalls",
+            objectDelta: validated
+          });
+        }
       }
     }
   }
-  yield { type: "finish", data: { text: "", toolCalls: [] } };
-};
-
-// src/ai/common/Gemini_Chat.ts
-var Gemini_Chat = async (input, model, update_progress, signal) => {
-  update_progress(0, "Gemini chat turn");
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const genModel = genAI.getGenerativeModel({
-    model: getModelName(model),
-    systemInstruction: input.systemPrompt || undefined,
-    generationConfig: {
-      maxOutputTokens: input.maxTokens,
-      temperature: input.temperature
-    }
-  });
-  const contents = buildGeminiContents(input.messages, input.prompt);
-  const result = await genModel.generateContent({ contents });
-  const text = result.response.text() ?? "";
-  update_progress(100, "Turn complete");
-  return { text };
-};
-var Gemini_Chat_Stream = async function* (input, model, signal) {
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const genModel = genAI.getGenerativeModel({
-    model: getModelName(model),
-    systemInstruction: input.systemPrompt || undefined,
-    generationConfig: {
-      maxOutputTokens: input.maxTokens,
-      temperature: input.temperature
-    }
-  });
-  const contents = buildGeminiContents(input.messages, input.prompt);
-  const result = await genModel.generateContentStream({ contents }, { signal });
-  for await (const chunk of result.stream) {
-    const text = chunk.text();
-    if (text) {
-      yield { type: "text-delta", port: "text", textDelta: text };
-    }
-  }
-  yield { type: "finish", data: {} };
-};
-
-// src/ai/common/Gemini_CountTokens.ts
-var Gemini_CountTokens = async (input, model, onProgress, signal) => {
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const genModel = genAI.getGenerativeModel({ model: getModelName(model) });
-  const result = await genModel.countTokens(input.text);
-  return { count: result.totalTokens };
-};
-var Gemini_CountTokens_Preview = async (input, _model) => {
-  return { count: Math.ceil(input.text.length / 4) };
+  emit({ type: "finish", data: { text: "", toolCalls: [] } });
 };
 
-// src/ai/common/Gemini_ImageEdit.ts
-import { ImageGenerationContentPolicyError, ImageGenerationProviderError } from "@workglow/ai";
-import { getLogger } from "@workglow/util/worker";
-import { dataUriToImageValue, imageValueToPngBytes } from "@workglow/ai/provider-utils";
-function modelIdOf(model) {
-  return model?.model_id ?? model?.provider_config?.model_name ?? "gemini";
-}
-async function decodeInlineImage(mimeType, data) {
-  return dataUriToImageValue(`data:${mimeType};base64,${data}`);
-}
-async function gpuImageToInlinePart(image) {
-  if (typeof image === "string" && image.startsWith("data:")) {
-    const base642 = image.replace(/^data:[^;]+;base64,/, "");
-    return { inlineData: { mimeType: "image/png", data: base642 } };
-  }
-  const bytes = await imageValueToPngBytes(image);
-  let base64;
-  if (typeof Buffer !== "undefined") {
-    base64 = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
-  } else {
-    let binary = "";
-    for (let i = 0;i < bytes.byteLength; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    base64 = btoa(binary);
-  }
-  return { inlineData: { mimeType: "image/png", data: base64 } };
-}
-var Gemini_ImageEdit = async (input, model, update_progress, signal) => {
-  const logger = getLogger();
-  const timer = `gemini:ImageEdit:${modelIdOf(model)}`;
-  logger.time(timer, { model: modelIdOf(model) });
-  update_progress(0, "Starting Gemini image edit");
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const modelName = getModelName(model);
-  const genModel = genAI.getGenerativeModel({ model: modelName });
-  const primaryPart = await gpuImageToInlinePart(input.image);
-  const additionalParts = input.additionalImages && input.additionalImages.length > 0 ? await Promise.all(input.additionalImages.map((g) => gpuImageToInlinePart(g))) : [];
-  const parts = [{ text: input.prompt }, primaryPart, ...additionalParts];
-  try {
-    const result = await genModel.generateContent({ contents: [{ role: "user", parts }] }, {
-      signal
-    });
-    const response = result.response;
-    if (!response.candidates || response.candidates.length === 0 || response.promptFeedback?.blockReason) {
-      const reason = response.promptFeedback?.blockReason ?? "SAFETY";
-      throw new ImageGenerationContentPolicyError(modelIdOf(model), `Blocked: ${reason}`);
-    }
-    const candidateParts = response.candidates[0]?.content?.parts ?? [];
-    const imagePart = candidateParts.find((p) => p.inlineData && p.inlineData.mimeType && p.inlineData.data);
-    if (!imagePart) {
-      throw new ImageGenerationProviderError(modelIdOf(model), "No image part in response (Gemini did not return an inline image)");
-    }
-    const image = await decodeInlineImage(imagePart.inlineData.mimeType, imagePart.inlineData.data);
-    update_progress(100, "Completed Gemini image edit");
-    logger.timeEnd(timer, { model: modelIdOf(model) });
-    return { image };
-  } catch (err) {
-    if (err instanceof ImageGenerationProviderError || err instanceof ImageGenerationContentPolicyError) {
-      throw err;
-    }
-    const msg = err instanceof Error ? err.message : "unknown error";
-    if (/safety|policy|moderation|blocked|SAFETY|PROHIBITED/i.test(msg)) {
-      throw new ImageGenerationContentPolicyError(modelIdOf(model), msg);
-    }
-    throw new ImageGenerationProviderError(modelIdOf(model), msg, { cause: err });
-  }
-};
-var Gemini_ImageEdit_Stream = async function* (input, model, signal) {
-  const noop = () => {};
-  const result = await Gemini_ImageEdit(input, model, noop, signal);
-  yield { type: "snapshot", data: result };
-  yield { type: "finish", data: {} };
-};
-
-// src/ai/common/Gemini_ImageGenerate.ts
-import { ImageGenerationContentPolicyError as ImageGenerationContentPolicyError2, ImageGenerationProviderError as ImageGenerationProviderError2 } from "@workglow/ai";
-import { getLogger as getLogger2 } from "@workglow/util/worker";
-import { dataUriToImageValue as dataUriToImageValue2 } from "@workglow/ai/provider-utils";
-function modelIdOf2(model) {
-  return model?.model_id ?? model?.provider_config?.model_name ?? "gemini";
-}
-async function decodeInlineImage2(mimeType, data) {
-  return dataUriToImageValue2(`data:${mimeType};base64,${data}`);
-}
-var Gemini_ImageGenerate = async (input, model, update_progress, signal) => {
-  const logger = getLogger2();
-  const timer = `gemini:ImageGenerate:${modelIdOf2(model)}`;
-  logger.time(timer, { model: modelIdOf2(model) });
-  update_progress(0, "Starting Gemini image generation");
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const modelName = getModelName(model);
-  const genModel = genAI.getGenerativeModel({ model: modelName });
-  const parts = [{ text: input.prompt }];
+// src/ai/common/Gemini_TextGeneration.ts
+var Gemini_TextGeneration_Stream = async (input, model, signal, emit) => {
+  const logger = getLogger4();
+  const timerLabel = `gemini:TextGeneration:${getModelName(model)}`;
+  logger.time(timerLabel, { model: getModelName(model) });
   try {
-    const result = await genModel.generateContent({ contents: [{ role: "user", parts }] }, {
-      signal
-    });
-    const response = result.response;
-    if (!response.candidates || response.candidates.length === 0 || response.promptFeedback?.blockReason) {
-      const reason = response.promptFeedback?.blockReason ?? "SAFETY";
-      throw new ImageGenerationContentPolicyError2(modelIdOf2(model), `Blocked: ${reason}`);
-    }
-    const candidateParts = response.candidates[0]?.content?.parts ?? [];
-    const imagePart = candidateParts.find((p) => p.inlineData && p.inlineData.mimeType && p.inlineData.data);
-    if (!imagePart) {
-      throw new ImageGenerationProviderError2(modelIdOf2(model), "No image part in response (Gemini did not return an inline image)");
-    }
-    const image = await decodeInlineImage2(imagePart.inlineData.mimeType, imagePart.inlineData.data);
-    update_progress(100, "Completed Gemini image generation");
-    logger.timeEnd(timer, { model: modelIdOf2(model) });
-    return { image };
-  } catch (err) {
-    if (err instanceof ImageGenerationProviderError2 || err instanceof ImageGenerationContentPolicyError2) {
-      throw err;
-    }
-    const msg = err instanceof Error ? err.message : "unknown error";
-    if (/safety|policy|moderation|blocked|SAFETY|PROHIBITED/i.test(msg)) {
-      throw new ImageGenerationContentPolicyError2(modelIdOf2(model), msg);
-    }
-    throw new ImageGenerationProviderError2(modelIdOf2(model), msg, { cause: err });
-  }
-};
-var Gemini_ImageGenerate_Stream = async function* (input, model, signal) {
-  const noop = () => {};
-  const result = await Gemini_ImageGenerate(input, model, noop, signal);
-  yield { type: "snapshot", data: result };
-  yield { type: "finish", data: {} };
-};
-
-// src/ai/common/Gemini_ModelInfo.ts
-var GEMINI_EMBEDDING_DIMENSIONS = {
-  "text-embedding-004": { native_dimensions: 768, mrl: true },
-  "embedding-001": { native_dimensions: 768, mrl: false }
-};
-var Gemini_ModelInfo = async (input, model) => {
-  if (input.detail === "dimensions") {
-    const pc = model?.provider_config;
-    let native_dimensions = typeof pc?.native_dimensions === "number" ? pc.native_dimensions : undefined;
-    let mrl = typeof pc?.mrl === "boolean" ? pc.mrl : undefined;
-    if (native_dimensions === undefined) {
-      const modelName = pc?.model_name ?? "";
-      const known = GEMINI_EMBEDDING_DIMENSIONS[modelName];
-      if (known) {
-        native_dimensions = known.native_dimensions;
-        mrl = mrl ?? known.mrl;
+    signal?.throwIfAborted?.();
+    const unified = input;
+    const hasMessages = Array.isArray(unified.messages) && unified.messages.length > 0;
+    const GoogleGenerativeAI = await loadGeminiSDK();
+    const genAI = new GoogleGenerativeAI(getApiKey(model));
+    if (hasMessages) {
+      const genModel = genAI.getGenerativeModel({
+        model: getModelName(model),
+        systemInstruction: unified.systemPrompt || undefined,
+        generationConfig: {
+          maxOutputTokens: input.maxTokens,
+          temperature: input.temperature
+        }
+      });
+      const contents = buildGeminiContents(unified.messages, unified.prompt ?? "");
+      const result = await genModel.generateContentStream({ contents }, { signal });
+      for await (const chunk of result.stream) {
+        const text = chunk.text();
+        if (text) {
+          emit({ type: "text-delta", port: "text", textDelta: text });
+        }
       }
-    }
-    return {
-      model: input.model,
-      is_local: false,
-      is_remote: true,
-      supports_browser: true,
-      supports_node: true,
-      is_cached: false,
-      is_loaded: false,
-      file_sizes: null,
-      ...native_dimensions !== undefined ? { native_dimensions } : {},
-      ...mrl !== undefined ? { mrl } : {}
-    };
-  }
-  return {
-    model: input.model,
-    is_local: false,
-    is_remote: true,
-    supports_browser: true,
-    supports_node: true,
-    is_cached: false,
-    is_loaded: false,
-    file_sizes: null
-  };
-};
-
-// src/ai/common/Gemini_StructuredGeneration.ts
-import { parsePartialJson } from "@workglow/util/worker";
-var Gemini_StructuredGeneration = async (input, model, update_progress, signal, outputSchema) => {
-  update_progress(0, "Starting Gemini structured generation");
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const schema = input.outputSchema ?? outputSchema;
-  const sanitizedSchema = sanitizeSchemaForGemini(schema);
-  const genModel = genAI.getGenerativeModel({
-    model: getModelName(model),
-    generationConfig: {
-      responseMimeType: "application/json",
-      responseSchema: sanitizedSchema,
-      maxOutputTokens: input.maxTokens,
-      temperature: input.temperature
-    }
-  });
-  const result = await genModel.generateContent({
-    contents: [{ role: "user", parts: [{ text: input.prompt }] }]
-  });
-  const text = result.response.text();
-  update_progress(100, "Completed Gemini structured generation");
-  return { object: JSON.parse(text) };
-};
-var Gemini_StructuredGeneration_Stream = async function* (input, model, signal, outputSchema) {
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const schema = input.outputSchema ?? outputSchema;
-  const sanitizedSchema = sanitizeSchemaForGemini(schema);
-  const genModel = genAI.getGenerativeModel({
-    model: getModelName(model),
-    generationConfig: {
-      responseMimeType: "application/json",
-      responseSchema: sanitizedSchema,
-      maxOutputTokens: input.maxTokens,
-      temperature: input.temperature
-    }
-  });
-  const result = await genModel.generateContentStream({ contents: [{ role: "user", parts: [{ text: input.prompt }] }] }, { signal });
-  let accumulatedJson = "";
-  for await (const chunk of result.stream) {
-    const text = chunk.text();
-    if (text) {
-      accumulatedJson += text;
-      const partial = parsePartialJson(accumulatedJson);
-      if (partial !== undefined) {
-        yield { type: "object-delta", port: "object", objectDelta: partial };
+    } else {
+      const genModel = genAI.getGenerativeModel({
+        model: getModelName(model),
+        generationConfig: {
+          maxOutputTokens: input.maxTokens,
+          temperature: input.temperature,
+          topP: input.topP
+        }
+      });
+      const result = await genModel.generateContentStream({ contents: [{ role: "user", parts: [{ text: input.prompt }] }] }, { signal });
+      for await (const chunk of result.stream) {
+        const text = chunk.text();
+        if (text) {
+          emit({ type: "text-delta", port: "text", textDelta: text });
+        }
       }
     }
+    emit({ type: "finish", data: {} });
+  } finally {
+    logger.timeEnd(timerLabel, { model: getModelName(model) });
   }
-  let finalObject;
-  try {
-    finalObject = JSON.parse(accumulatedJson);
-  } catch {
-    finalObject = parsePartialJson(accumulatedJson) ?? {};
-  }
-  yield { type: "finish", data: { object: finalObject } };
-};
-
-// src/ai/common/Gemini_TextEmbedding.ts
-import { getLogger as getLogger3 } from "@workglow/util/worker";
-var Gemini_TextEmbedding = async (input, model, update_progress, signal) => {
-  const logger = getLogger3();
-  const timerLabel = `gemini:TextEmbedding:${model?.provider_config?.model_name}`;
-  logger.time(timerLabel, { model: model?.provider_config?.model_name });
-  update_progress(0, "Starting Gemini text embedding");
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const embeddingModel = genAI.getGenerativeModel({
-    model: getModelName(model)
-  });
-  const taskType = model?.provider_config?.embedding_task_type || "RETRIEVAL_DOCUMENT";
-  if (Array.isArray(input.text)) {
-    const result2 = await embeddingModel.batchEmbedContents({
-      requests: input.text.map((t) => ({
-        content: { role: "user", parts: [{ text: t }] },
-        taskType
-      }))
-    });
-    update_progress(100, "Completed Gemini text embedding");
-    logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name, batch: true });
-    return {
-      vector: result2.embeddings.map((e) => new Float32Array(e.values))
-    };
-  }
-  const result = await embeddingModel.embedContent({
-    content: { role: "user", parts: [{ text: input.text }] },
-    taskType
-  });
-  update_progress(100, "Completed Gemini text embedding");
-  logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
-  return { vector: new Float32Array(result.embedding.values) };
-};
-
-// src/ai/common/Gemini_TextGeneration.ts
-import { getLogger as getLogger4 } from "@workglow/util/worker";
-var Gemini_TextGeneration = async (input, model, update_progress, signal) => {
-  signal?.throwIfAborted?.();
-  const logger = getLogger4();
-  const timerLabel = `gemini:TextGeneration:${model?.provider_config?.model_name}`;
-  logger.time(timerLabel, { model: model?.provider_config?.model_name });
-  update_progress(0, "Starting Gemini text generation");
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const genModel = genAI.getGenerativeModel({
-    model: getModelName(model),
-    generationConfig: {
-      maxOutputTokens: input.maxTokens,
-      temperature: input.temperature,
-      topP: input.topP
-    }
-  });
-  const result = await genModel.generateContent({
-    contents: [{ role: "user", parts: [{ text: input.prompt }] }]
-  }, { signal });
-  const text = result.response.text();
-  update_progress(100, "Completed Gemini text generation");
-  logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
-  return { text };
-};
-var Gemini_TextGeneration_Stream = async function* (input, model, signal) {
-  signal?.throwIfAborted?.();
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const genModel = genAI.getGenerativeModel({
-    model: getModelName(model),
-    generationConfig: {
-      maxOutputTokens: input.maxTokens,
-      temperature: input.temperature,
-      topP: input.topP
-    }
-  });
-  const result = await genModel.generateContentStream({ contents: [{ role: "user", parts: [{ text: input.prompt }] }] }, { signal });
-  for await (const chunk of result.stream) {
-    const text = chunk.text();
-    if (text) {
-      yield { type: "text-delta", port: "text", textDelta: text };
-    }
-  }
-  yield { type: "finish", data: {} };
 };
 
 // src/ai/common/Gemini_TextRewriter.ts
-var Gemini_TextRewriter = async (input, model, update_progress, signal) => {
-  update_progress(0, "Starting Gemini text rewriting");
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const genModel = genAI.getGenerativeModel({
-    model: getModelName(model),
-    systemInstruction: input.prompt
-  });
-  const result = await genModel.generateContent({
-    contents: [{ role: "user", parts: [{ text: input.text }] }]
-  });
-  const text = result.response.text();
-  update_progress(100, "Completed Gemini text rewriting");
-  return { text };
-};
-var Gemini_TextRewriter_Stream = async function* (input, model, signal) {
+var Gemini_TextRewriter_Stream = async (input, model, signal, emit) => {
   const GoogleGenerativeAI = await loadGeminiSDK();
   const genAI = new GoogleGenerativeAI(getApiKey(model));
   const genModel = genAI.getGenerativeModel({
@@ -717,29 +638,14 @@ var Gemini_TextRewriter_Stream = async function* (input, model, signal) {
   for await (const chunk of result.stream) {
     const text = chunk.text();
     if (text) {
-      yield { type: "text-delta", port: "text", textDelta: text };
+      emit({ type: "text-delta", port: "text", textDelta: text });
     }
   }
-  yield { type: "finish", data: {} };
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/common/Gemini_TextSummary.ts
-var Gemini_TextSummary = async (input, model, update_progress, signal) => {
-  update_progress(0, "Starting Gemini text summarization");
-  const GoogleGenerativeAI = await loadGeminiSDK();
-  const genAI = new GoogleGenerativeAI(getApiKey(model));
-  const genModel = genAI.getGenerativeModel({
-    model: getModelName(model),
-    systemInstruction: "Summarize the following text concisely."
-  });
-  const result = await genModel.generateContent({
-    contents: [{ role: "user", parts: [{ text: input.text }] }]
-  });
-  const text = result.response.text();
-  update_progress(100, "Completed Gemini text summarization");
-  return { text };
-};
-var Gemini_TextSummary_Stream = async function* (input, model, signal) {
+var Gemini_TextSummary_Stream = async (input, model, signal, emit) => {
   const GoogleGenerativeAI = await loadGeminiSDK();
   const genAI = new GoogleGenerativeAI(getApiKey(model));
   const genModel = genAI.getGenerativeModel({
@@ -750,37 +656,26 @@ var Gemini_TextSummary_Stream = async function* (input, model, signal) {
   for await (const chunk of result.stream) {
     const text = chunk.text();
     if (text) {
-      yield { type: "text-delta", port: "text", textDelta: text };
+      emit({ type: "text-delta", port: "text", textDelta: text });
     }
   }
-  yield { type: "finish", data: {} };
+  emit({ type: "finish", data: {} });
 };
 
 // src/ai/common/Gemini_JobRunFns.ts
-var GEMINI_TASKS = {
-  AiChatTask: Gemini_Chat,
-  CountTokensTask: Gemini_CountTokens,
-  ModelInfoTask: Gemini_ModelInfo,
-  TextGenerationTask: Gemini_TextGeneration,
-  TextEmbeddingTask: Gemini_TextEmbedding,
-  TextRewriterTask: Gemini_TextRewriter,
-  TextSummaryTask: Gemini_TextSummary,
-  StructuredGenerationTask: Gemini_StructuredGeneration,
-  ToolCallingTask: Gemini_ToolCalling,
-  ModelSearchTask: Gemini_ModelSearch,
-  ImageGenerateTask: Gemini_ImageGenerate,
-  ImageEditTask: Gemini_ImageEdit
-};
-var GEMINI_STREAM_TASKS = {
-  AiChatTask: Gemini_Chat_Stream,
-  TextGenerationTask: Gemini_TextGeneration_Stream,
-  TextRewriterTask: Gemini_TextRewriter_Stream,
-  TextSummaryTask: Gemini_TextSummary_Stream,
-  StructuredGenerationTask: Gemini_StructuredGeneration_Stream,
-  ToolCallingTask: Gemini_ToolCalling_Stream,
-  ImageGenerateTask: Gemini_ImageGenerate_Stream,
-  ImageEditTask: Gemini_ImageEdit_Stream
-};
+var GEMINI_RUN_FNS = [
+  { serves: GEMINI_TEXT_GENERATION, runFn: Gemini_TextGeneration_Stream },
+  { serves: GEMINI_TOOL_USE, runFn: Gemini_ToolCalling_Stream },
+  { serves: GEMINI_JSON_MODE, runFn: Gemini_StructuredGeneration_Stream },
+  { serves: GEMINI_TEXT_REWRITER, runFn: Gemini_TextRewriter_Stream },
+  { serves: GEMINI_TEXT_SUMMARY, runFn: Gemini_TextSummary_Stream },
+  { serves: GEMINI_TEXT_EMBEDDING, runFn: Gemini_TextEmbedding_Stream },
+  { serves: GEMINI_IMAGE_GENERATION, runFn: Gemini_ImageGenerate_Stream },
+  { serves: GEMINI_IMAGE_EDITING, runFn: Gemini_ImageEdit_Stream },
+  { serves: GEMINI_COUNT_TOKENS, runFn: Gemini_CountTokens_Stream },
+  { serves: GEMINI_MODEL_SEARCH, runFn: Gemini_ModelSearch_Stream },
+  { serves: GEMINI_MODEL_INFO, runFn: Gemini_ModelInfo_Stream }
+];
 var GEMINI_PREVIEW_TASKS = {
   CountTokensTask: Gemini_CountTokens_Preview
 };
@@ -788,25 +683,87 @@ var GEMINI_PREVIEW_TASKS = {
 // src/ai/GoogleGeminiQueuedProvider.ts
 import { AiProvider } from "@workglow/ai";
 import { createCloudProviderClass } from "@workglow/ai/provider-utils";
-var GEMINI_TASK_TYPES = [
-  "CountTokensTask",
-  "ModelInfoTask",
-  "TextGenerationTask",
-  "TextEmbeddingTask",
-  "TextRewriterTask",
-  "TextSummaryTask",
-  "StructuredGenerationTask",
-  "ToolCallingTask",
-  "ModelSearchTask",
-  "ImageGenerateTask",
-  "ImageEditTask"
-];
 
+// src/ai/common/Gemini_Capabilities.ts
+var GEMINI_RUN_FN_SPECS = GEMINI_CAPABILITY_SETS.map((serves) => ({ serves }));
+function geminiWorkerRunFnSpecs() {
+  return GEMINI_RUN_FN_SPECS;
+}
+function inferGeminiCapabilities(model) {
+  const id = String(model.model_id ?? model.provider_config?.model_name ?? "");
+  if (/^text-embedding/i.test(id) || /^embedding-\d/i.test(id) || /^gemini-embedding/i.test(id)) {
+    return ["text.embedding", "model.info", "model.search"];
+  }
+  if (/^imagen-/i.test(id)) {
+    return ["image.generation", "model.info", "model.search"];
+  }
+  if (/^gemini-.*-image-/i.test(id)) {
+    return ["image.generation", "image.editing", "model.info", "model.search"];
+  }
+  if (/^gemini-pro-vision$/i.test(id)) {
+    return [
+      "text.generation",
+      "text.rewriter",
+      "text.summary",
+      "tool-use",
+      "json-mode",
+      "vision-input",
+      "model.info",
+      "model.search"
+    ];
+  }
+  if (/^gemini-1\.0-pro($|-(?!vision))/i.test(id)) {
+    return [
+      "text.generation",
+      "text.rewriter",
+      "text.summary",
+      "tool-use",
+      "json-mode",
+      "model.info",
+      "model.search"
+    ];
+  }
+  if (/^gemini-pro$/i.test(id)) {
+    return [
+      "text.generation",
+      "text.rewriter",
+      "text.summary",
+      "tool-use",
+      "json-mode",
+      "model.info",
+      "model.search"
+    ];
+  }
+  if (/^gemini-(?:1\.5|2\.[05]|2\.5|3(?:\.\d+)?-)/i.test(id)) {
+    return [
+      "text.generation",
+      "text.rewriter",
+      "text.summary",
+      "tool-use",
+      "json-mode",
+      "vision-input",
+      "model.count-tokens",
+      "model.info",
+      "model.search"
+    ];
+  }
+  const declared = model.capabilities ?? [];
+  if (declared.length > 0)
+    return declared;
+  return ["model.search", "model.info"];
+}
+
+// src/ai/GoogleGeminiQueuedProvider.ts
 class GoogleGeminiQueuedProvider extends createCloudProviderClass(AiProvider, {
   name: GOOGLE_GEMINI,
-  displayName: "Google Gemini",
-  taskTypes: GEMINI_TASK_TYPES
+  displayName: "Google Gemini"
 }) {
+  inferCapabilities(model) {
+    return inferGeminiCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return geminiWorkerRunFnSpecs();
+  }
 }
 
 // src/ai/common/Gemini_ImageValidation.ts
@@ -824,7 +781,7 @@ function registerGeminiImageValidator() {
 // src/ai/registerGeminiInline.ts
 async function registerGeminiInline(options) {
   registerGeminiImageValidator();
-  await registerProviderInline(new GoogleGeminiQueuedProvider(GEMINI_TASKS, GEMINI_STREAM_TASKS, GEMINI_PREVIEW_TASKS), "Google Gemini", options);
+  await registerProviderInline(new GoogleGeminiQueuedProvider(GEMINI_RUN_FNS, GEMINI_PREVIEW_TASKS), "Google Gemini", options);
 }
 
 // src/ai/registerGeminiWorker.ts
@@ -833,30 +790,21 @@ import { registerProviderWorker } from "@workglow/ai/provider-utils";
 // src/ai/GoogleGeminiProvider.ts
 import { AiProvider as AiProvider2 } from "@workglow/ai/worker";
 import { createCloudProviderClass as createCloudProviderClass2 } from "@workglow/ai/provider-utils";
-var GEMINI_TASK_TYPES2 = [
-  "CountTokensTask",
-  "ModelInfoTask",
-  "TextGenerationTask",
-  "TextEmbeddingTask",
-  "TextRewriterTask",
-  "TextSummaryTask",
-  "StructuredGenerationTask",
-  "ToolCallingTask",
-  "ModelSearchTask",
-  "ImageGenerateTask",
-  "ImageEditTask"
-];
-
 class GoogleGeminiProvider extends createCloudProviderClass2(AiProvider2, {
   name: GOOGLE_GEMINI,
-  displayName: "Google Gemini",
-  taskTypes: GEMINI_TASK_TYPES2
+  displayName: "Google Gemini"
 }) {
+  inferCapabilities(model) {
+    return inferGeminiCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return geminiWorkerRunFnSpecs();
+  }
 }
 
 // src/ai/registerGeminiWorker.ts
 async function registerGeminiWorker() {
-  await registerProviderWorker((ws) => new GoogleGeminiProvider(GEMINI_TASKS, GEMINI_STREAM_TASKS, GEMINI_PREVIEW_TASKS).registerOnWorkerServer(ws), "Google Gemini");
+  await registerProviderWorker((ws) => new GoogleGeminiProvider(GEMINI_RUN_FNS, GEMINI_PREVIEW_TASKS).registerOnWorkerServer(ws), "Google Gemini");
 }
 export {
   registerGeminiWorker,
@@ -866,4 +814,4 @@ export {
   getApiKey
 };
 
-//# debugId=D11D66D2FAE6785964756E2164756E21
+//# debugId=606191234522930264756E2164756E21