@workglow/google-gemini 0.2.28

package/dist/ai-provider-runtime.js

@@ -0,0 +1,871 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/ai-provider/common/Gemini_Client.ts
+var _sdk;
+async function loadGeminiSDK() {
+  if (!_sdk) {
+    try {
+      _sdk = await import("@google/generative-ai");
+    } catch {
+      throw new Error("@google/generative-ai is required for Gemini tasks. Install it with: bun add @google/generative-ai");
+    }
+  }
+  return _sdk.GoogleGenerativeAI;
+}
+function getApiKey(model) {
+  const config = model?.provider_config;
+  const apiKey = config?.credential_key || config?.api_key || (typeof process !== "undefined" ? process.env?.GOOGLE_API_KEY || process.env?.GEMINI_API_KEY : undefined);
+  if (!apiKey) {
+    throw new Error("Missing Google API key: set provider_config.credential_key or the GOOGLE_API_KEY / GEMINI_API_KEY environment variable.");
+  }
+  return apiKey;
+}
+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-provider/registerGeminiInline.ts
+import { registerProviderInline } from "@workglow/ai-provider/common";
+
+// src/ai-provider/common/Gemini_ModelSearch.ts
+import { normalizedModelSearchQuery } from "@workglow/ai-provider/common";
+
+// src/ai-provider/common/Gemini_Constants.ts
+var GOOGLE_GEMINI = "GOOGLE_GEMINI";
+
+// src/ai-provider/common/Gemini_ModelSearch.ts
+var GEMINI_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" },
+  { label: "gemini-2.5-flash", value: "gemini-2.5-flash" },
+  { label: "gemini-2.5-pro", value: "gemini-2.5-pro" },
+  {
+    label: "gemini-embedding-2",
+    value: "gemini-embedding-2",
+    tasks: ["TextEmbeddingTask"]
+  },
+  {
+    label: "gemini-embedding-001",
+    value: "gemini-embedding-001",
+    tasks: ["TextEmbeddingTask"]
+  },
+  {
+    label: "gemini-3.1-flash-image-preview",
+    value: "gemini-3.1-flash-image-preview",
+    tasks: ["ImageGenerateTask", "ImageEditTask"]
+  },
+  {
+    label: "gemini-3-pro-image-preview",
+    value: "gemini-3-pro-image-preview",
+    tasks: ["ImageGenerateTask", "ImageEditTask"]
+  },
+  {
+    label: "imagen-4.0-generate-001",
+    value: "imagen-4.0-generate-001",
+    tasks: ["ImageGenerateTask"]
+  }
+];
+function tasksForGeminiApiModel(model, id) {
+  const staticEntry = GEMINI_MODELS.find((m) => m.value === id);
+  if (staticEntry?.tasks)
+    return [...staticEntry.tasks];
+  const methods = model.supportedGenerationMethods ?? [];
+  if (methods.some((method) => method.toLowerCase().includes("embed"))) {
+    return ["TextEmbeddingTask"];
+  }
+  return [];
+}
+function mapGeminiModel(model) {
+  const id = model.name.startsWith("models/") ? model.name.slice("models/".length) : model.name;
+  const title = model.displayName || id;
+  return {
+    id,
+    label: model.displayName ? `${id}  ${model.displayName}` : id,
+    description: model.description ?? "",
+    record: {
+      model_id: id,
+      provider: GOOGLE_GEMINI,
+      title,
+      description: model.description ?? "",
+      tasks: tasksForGeminiApiModel(model, id),
+      provider_config: { model_name: id },
+      metadata: {}
+    },
+    raw: model
+  };
+}
+async function listGeminiModels(credentialKey, signal) {
+  const params = new URLSearchParams({ key: credentialKey });
+  const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?${params}`, {
+    signal
+  });
+  if (!response.ok)
+    throw new Error(`Gemini API returned ${response.status}`);
+  const body = await response.json();
+  return (body.models ?? []).map(mapGeminiModel);
+}
+var Gemini_ModelSearch = async (input, _model, _onProgress, signal) => {
+  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 };
+  }
+  const filtered = q ? GEMINI_MODELS.filter((m) => m.value.toLowerCase().includes(q) || m.label.toLowerCase().includes(q)) : GEMINI_MODELS;
+  const results = filtered.map((m) => ({
+    id: m.value,
+    label: m.label,
+    description: "",
+    record: {
+      model_id: m.value,
+      provider: GOOGLE_GEMINI,
+      title: m.value,
+      description: "",
+      tasks: m.tasks ? [...m.tasks] : [],
+      provider_config: { model_name: m.value },
+      metadata: {}
+    },
+    raw: m
+  }));
+  return { results };
+};
+
+// src/ai-provider/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-provider/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 = 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) {
+  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) {
+        yield { 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 ?? {}
+            }
+          ]
+        };
+      }
+    }
+  }
+  yield { type: "finish", data: { text: "", toolCalls: [] } };
+};
+
+// src/ai-provider/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-provider/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) };
+};
+
+// src/ai-provider/common/Gemini_ImageEdit.ts
+import { ImageGenerationContentPolicyError, ImageGenerationProviderError } from "@workglow/ai";
+import { getLogger } from "@workglow/util/worker";
+import { dataUriToImageValue, imageValueToPngBytes } from "@workglow/ai-provider/common";
+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-provider/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/common";
+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 }];
+  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-provider/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;
+      }
+    }
+    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-provider/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 };
+      }
+    }
+  }
+  let finalObject;
+  try {
+    finalObject = JSON.parse(accumulatedJson);
+  } catch {
+    finalObject = parsePartialJson(accumulatedJson) ?? {};
+  }
+  yield { type: "finish", data: { object: finalObject } };
+};
+
+// src/ai-provider/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-provider/common/Gemini_TextGeneration.ts
+import { getLogger as getLogger4 } from "@workglow/util/worker";
+var Gemini_TextGeneration = async (input, model, update_progress, signal) => {
+  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 }] }]
+  });
+  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) {
+  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-provider/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) {
+  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) {
+      yield { type: "text-delta", port: "text", textDelta: text };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/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) {
+  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) {
+      yield { type: "text-delta", port: "text", textDelta: text };
+    }
+  }
+  yield { type: "finish", data: {} };
+};
+
+// src/ai-provider/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_PREVIEW_TASKS = {
+  CountTokensTask: Gemini_CountTokens_Preview
+};
+
+// src/ai-provider/GoogleGeminiQueuedProvider.ts
+import { AiProvider } from "@workglow/ai";
+class GoogleGeminiQueuedProvider extends AiProvider {
+  name = GOOGLE_GEMINI;
+  displayName = "Google Gemini";
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "CountTokensTask",
+    "ModelInfoTask",
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "StructuredGenerationTask",
+    "ToolCallingTask",
+    "ModelSearchTask",
+    "ImageGenerateTask",
+    "ImageEditTask"
+  ];
+  constructor(tasks, streamTasks, previewTasks) {
+    super(tasks, streamTasks, previewTasks);
+  }
+}
+
+// src/ai-provider/common/Gemini_ImageValidation.ts
+import { AiImageOutputTask, ProviderUnsupportedFeatureError } from "@workglow/ai";
+function registerGeminiImageValidator() {
+  AiImageOutputTask.registerProviderImageValidator(GOOGLE_GEMINI, (taskType, input, model) => {
+    if (taskType !== "ImageEditTask")
+      return;
+    if (input["mask"] !== undefined && input["mask"] !== null) {
+      throw new ProviderUnsupportedFeatureError("mask", model.model_id ?? "gemini", "Gemini does not support mask-based inpainting; remove the mask or use OpenAI gpt-image-2");
+    }
+  });
+}
+
+// src/ai-provider/registerGeminiInline.ts
+async function registerGeminiInline(options) {
+  registerGeminiImageValidator();
+  await registerProviderInline(new GoogleGeminiQueuedProvider(GEMINI_TASKS, GEMINI_STREAM_TASKS, GEMINI_PREVIEW_TASKS), "Google Gemini", options);
+}
+
+// src/ai-provider/registerGeminiWorker.ts
+import { registerProviderWorker } from "@workglow/ai-provider/common";
+
+// src/ai-provider/GoogleGeminiProvider.ts
+import { AiProvider as AiProvider2 } from "@workglow/ai/worker";
+class GoogleGeminiProvider extends AiProvider2 {
+  name = GOOGLE_GEMINI;
+  displayName = "Google Gemini";
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "CountTokensTask",
+    "ModelInfoTask",
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "StructuredGenerationTask",
+    "ToolCallingTask",
+    "ModelSearchTask",
+    "ImageGenerateTask",
+    "ImageEditTask"
+  ];
+  constructor(tasks, streamTasks, previewTasks) {
+    super(tasks, streamTasks, previewTasks);
+  }
+}
+
+// src/ai-provider/registerGeminiWorker.ts
+async function registerGeminiWorker() {
+  await registerProviderWorker((ws) => new GoogleGeminiProvider(GEMINI_TASKS, GEMINI_STREAM_TASKS, GEMINI_PREVIEW_TASKS).registerOnWorkerServer(ws), "Google Gemini");
+}
+export {
+  registerGeminiWorker,
+  registerGeminiInline,
+  loadGeminiSDK,
+  getModelName,
+  getApiKey
+};
+
+//# debugId=77A1873DA035E57D64756E2164756E21