@workglow/google-gemini 0.2.34 → 0.2.35

package/dist/ai.js

@@ -8,7 +8,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/ai/common/Gemini_Constants.ts
 var GOOGLE_GEMINI = "GOOGLE_GEMINI";
-
 // src/ai/common/Gemini_ImageValidation.ts
 import { AiImageOutputTask, ProviderUnsupportedFeatureError } from "@workglow/ai";
 function registerGeminiImageValidator() {
@@ -20,7 +19,6 @@ function registerGeminiImageValidator() {
     }
   });
 }
-
 // src/ai/common/Gemini_ModelSchema.ts
 import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai/worker";
 var GeminiModelSchema = {
@@ -87,10 +85,9 @@ var GeminiModelConfigSchema = {
   required: [...ModelConfigSchema.required, ...GeminiModelSchema.required],
   additionalProperties: false
 };
-
 // src/ai/common/Gemini_ModelSearch.ts
 import { normalizedModelSearchQuery } from "@workglow/ai/provider-utils";
-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" },
@@ -99,36 +96,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 [];
 }
@@ -144,7 +141,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: {}
     },
@@ -161,14 +158,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,
@@ -178,40 +176,127 @@ 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/registerGemini.ts
 import { registerProviderWithWorker } from "@workglow/ai/provider-utils";
 
 // 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_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_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/registerGemini.ts
@@ -219,14 +304,562 @@ async function registerGemini(options) {
   registerGeminiImageValidator();
   await registerProviderWithWorker(new GoogleGeminiQueuedProvider, "Google Gemini", options);
 }
+// src/ai/common/Gemini_Client.ts
+import { resolveApiKey } from "@workglow/ai/provider-utils";
+var _loadPromise;
+async function loadGeminiSDK() {
+  _loadPromise ??= import("@google/generative-ai").then((mod) => mod.GoogleGenerativeAI).catch(() => {
+    _loadPromise = undefined;
+    throw new Error("@google/generative-ai is required for Gemini tasks. Install it with: bun add @google/generative-ai");
+  });
+  return _loadPromise;
+}
+function getApiKey(model) {
+  const config = model?.provider_config;
+  return resolveApiKey({
+    config,
+    envVar: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
+    providerLabel: "Google"
+  });
+}
+function getModelName(model) {
+  const name = model?.provider_config?.model_name;
+  if (!name) {
+    throw new Error("Missing model name in provider_config.model_name.");
+  }
+  return name;
+}
+
+// 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_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 });
+      }
+    }
+  }
+  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";
+function buildGeminiContents(messages, prompt) {
+  if (!messages || messages.length === 0) {
+    return [{ role: "user", parts: [{ text: prompt }] }];
+  }
+  const toolUseNames = new Map;
+  for (const msg of messages) {
+    if (msg.role !== "assistant")
+      continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use") {
+        toolUseNames.set(block.id, block.name);
+      }
+    }
+  }
+  const contents = [];
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      const parts = [];
+      for (const block of msg.content) {
+        if (block.type === "text") {
+          parts.push({ text: block.text });
+        } else if (block.type === "image") {
+          parts.push({ inlineData: { mimeType: block.mimeType, data: block.data } });
+        }
+      }
+      contents.push({ role: "user", parts });
+    } else if (msg.role === "assistant") {
+      const parts = [];
+      for (const block of msg.content) {
+        if (block.type === "text" && block.text) {
+          parts.push({ text: block.text });
+        } else if (block.type === "tool_use") {
+          parts.push({ functionCall: { name: block.name, args: block.input } });
+        }
+      }
+      if (parts.length > 0)
+        contents.push({ role: "model", parts });
+    } else if (msg.role === "tool") {
+      const parts = [];
+      for (const block of msg.content) {
+        if (block.type !== "tool_result")
+          continue;
+        const name = toolUseNames.get(block.tool_use_id) ?? "unknown";
+        const textContent = block.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+        let response;
+        try {
+          response = JSON.parse(textContent);
+        } catch {
+          response = { result: textContent };
+        }
+        parts.push({ functionResponse: { name, response } });
+      }
+      if (parts.length > 0)
+        contents.push({ role: "user", parts });
+    }
+  }
+  return contents;
+}
+function mapGeminiToolConfig(toolChoice) {
+  if (!toolChoice || toolChoice === "auto") {
+    return { functionCallingConfig: { mode: "AUTO" } };
+  }
+  if (toolChoice === "none") {
+    return { functionCallingConfig: { mode: "NONE" } };
+  }
+  if (toolChoice === "required") {
+    return { functionCallingConfig: { mode: "ANY" } };
+  }
+  return {
+    functionCallingConfig: {
+      mode: "ANY",
+      allowedFunctionNames: [toolChoice]
+    }
+  };
+}
+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) => ({
+    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.generateContentStream({ contents }, { signal });
+  let callIndex = 0;
+  for await (const chunk of result.stream) {
+    const parts = chunk.candidates?.[0]?.content?.parts ?? [];
+    for (const part of parts) {
+      if ("text" in part && part.text) {
+        emit({ type: "text-delta", port: "text", textDelta: part.text });
+      }
+      if ("functionCall" in part && part.functionCall) {
+        const id = `call_${callIndex++}`;
+        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
+          });
+        }
+      }
+    }
+  }
+  emit({ type: "finish", data: { text: "", toolCalls: [] } });
+};
+
+// 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 {
+    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 });
+        }
+      }
+    } 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) });
+  }
+};
+
+// src/ai/common/Gemini_TextRewriter.ts
+var Gemini_TextRewriter_Stream = async (input, model, signal, emit) => {
+  const GoogleGenerativeAI = await loadGeminiSDK();
+  const genAI = new GoogleGenerativeAI(getApiKey(model));
+  const genModel = genAI.getGenerativeModel({
+    model: getModelName(model),
+    systemInstruction: input.prompt
+  });
+  const result = await genModel.generateContentStream({ contents: [{ role: "user", parts: [{ text: input.text }] }] }, { 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: {} });
+};
+
+// src/ai/common/Gemini_TextSummary.ts
+var Gemini_TextSummary_Stream = async (input, model, signal, emit) => {
+  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.generateContentStream({ contents: [{ role: "user", parts: [{ text: input.text }] }] }, { 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: {} });
+};
+
+// src/ai/common/Gemini_JobRunFns.ts
+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
+};
+
+// src/ai/index.ts
+var _testOnly = {
+  GoogleGeminiQueuedProvider,
+  GEMINI_RUN_FN_SPECS,
+  GEMINI_RUN_FNS
+};
 export {
   registerGeminiImageValidator,
   registerGemini,
-  Gemini_ModelSearch,
+  _testOnly,
+  Gemini_ModelSearch_Stream,
   GeminiModelSchema,
   GeminiModelRecordSchema,
   GeminiModelConfigSchema,
-  GOOGLE_GEMINI
+  GOOGLE_GEMINI,
+  GEMINI_FALLBACK_MODELS
 };
 
-//# debugId=84E9A60003FFA1DA64756E2164756E21
+//# debugId=22A7AC7F93C851F664756E2164756E21