@workglow/ai-provider 0.0.120 → 0.0.122

package/dist/provider-gemini/registerGeminiInline.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { AiProviderRegisterOptions } from "@workglow/ai";
+export declare function registerGeminiInline(options?: AiProviderRegisterOptions): Promise<void>;
+//# sourceMappingURL=registerGeminiInline.d.ts.map

package/dist/provider-gemini/registerGeminiInline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerGeminiInline.d.ts","sourceRoot":"","sources":["../../src/provider-gemini/registerGeminiInline.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAQ9D,wBAAsB,oBAAoB,CAAC,OAAO,CAAC,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CAM7F"}

package/dist/{anthropic/Anthropic_Worker.d.ts → provider-gemini/registerGeminiWorker.d.ts}

@@ -3,5 +3,5 @@
  * Copyright 2025 Steven Roussey <sroussey@gmail.com>
  * SPDX-License-Identifier: Apache-2.0
  */
-export declare function ANTHROPIC_WORKER_JOBRUN_REGISTER(): void;
-//# sourceMappingURL=Anthropic_Worker.d.ts.map
+export declare function registerGeminiWorker(): Promise<void>;
+//# sourceMappingURL=registerGeminiWorker.d.ts.map

package/dist/provider-gemini/registerGeminiWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerGeminiWorker.d.ts","sourceRoot":"","sources":["../../src/provider-gemini/registerGeminiWorker.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAS1D"}

package/dist/provider-gemini/runtime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Worker server and main-thread inline Gemini registration (pulls in `Gemini_JobRunFns`),
+ * plus SDK client helpers (`Gemini_Client`).
+ * Import from `@workglow/ai-provider/gemini/runtime` — not from the main `gemini` barrel.
+ *
+ * Use `export *` (not `export { … } from "…"`) so the Bun bundler keeps the module graph.
+ */
+export * from "./common/Gemini_Client";
+export * from "./registerGeminiInline";
+export * from "./registerGeminiWorker";
+//# sourceMappingURL=runtime.d.ts.map

package/dist/provider-gemini/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/provider-gemini/runtime.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC"}

package/dist/{google-gemini/index.js → provider-gemini/runtime.js}

@@ -1,16 +1,27 @@
-import {
-  GOOGLE_GEMINI,
-  GeminiModelConfigSchema,
-  GeminiModelRecordSchema,
-  GeminiModelSchema,
-  GoogleGeminiProvider
-} from "../index-8651nz8y.js";
-import {
-  __require
-} from "../index-6j5pq722.js";
-// src/google-gemini/common/Gemini_JobRunFns.ts
-import { buildToolDescription, filterValidToolCalls } from "@workglow/ai";
-import { getLogger, parsePartialJson } from "@workglow/util";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+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/provider-gemini/common/Gemini_Client.ts
 var _sdk;
 async function loadGeminiSDK() {
   if (!_sdk) {
@@ -37,6 +48,39 @@ function getModelName(model) {
   }
   return name;
 }
+// src/provider-gemini/common/Gemini_Constants.ts
+var GOOGLE_GEMINI = "GOOGLE_GEMINI";
+
+// src/provider-gemini/common/Gemini_ModelSearch.ts
+var GEMINI_MODELS = [
+  { label: "gemini-3.1-flash", value: "gemini-3.1-flash" },
+  { label: "gemini-3.1-pro", value: "gemini-3.1-pro" },
+  { label: "gemini-2.5-flash", value: "gemini-2.5-flash" },
+  { label: "gemini-2.5-pro", value: "gemini-2.5-pro" },
+  { label: "gemini-2.0-flash", value: "gemini-2.0-flash" },
+  { label: "gemini-1.5-pro", value: "gemini-1.5-pro" },
+  { label: "gemini-1.5-flash", value: "gemini-1.5-flash" }
+];
+var Gemini_ModelSearch = async () => {
+  const results = GEMINI_MODELS.map((m) => ({
+    id: m.value,
+    label: m.label,
+    description: "",
+    record: {
+      model_id: m.value,
+      provider: GOOGLE_GEMINI,
+      title: m.value,
+      description: "",
+      tasks: [],
+      provider_config: { model_name: m.value },
+      metadata: {}
+    },
+    raw: m
+  }));
+  return { results };
+};
+
+// src/provider-gemini/common/Gemini_Schema.ts
 function sanitizeSchemaForGemini(schema) {
   const result = {};
   for (const [key, value] of Object.entries(schema)) {
@@ -50,41 +94,110 @@ function sanitizeSchemaForGemini(schema) {
   }
   return result;
 }
-var Gemini_TextGeneration = async (input, model, update_progress, signal) => {
-  if (Array.isArray(input.prompt)) {
-    getLogger().warn("Gemini_TextGeneration: array input received; processing sequentially (no native batch support)");
-    const prompts = input.prompt;
-    const results = [];
-    for (const item of prompts) {
-      const r = await Gemini_TextGeneration({ ...input, prompt: item }, model, update_progress, signal);
-      results.push(r.text);
+
+// src/provider-gemini/common/Gemini_CountTokens.ts
+import { getLogger } from "@workglow/util/worker";
+var Gemini_CountTokens = async (input, model, onProgress, signal) => {
+  if (Array.isArray(input.text)) {
+    getLogger().warn("Gemini_CountTokens: array input received; processing sequentially (no native batch support)");
+    const texts = input.text;
+    const counts = [];
+    for (const item of texts) {
+      const r = await Gemini_CountTokens({ ...input, text: item }, model, onProgress, signal);
+      counts.push(r.count);
     }
-    return { text: results };
+    return { count: counts };
   }
-  const logger = getLogger();
-  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) });
+  const result = await genModel.countTokens(input.text);
+  return { count: result.totalTokens };
+};
+var Gemini_CountTokens_Reactive = async (input, _output, _model) => {
+  if (Array.isArray(input.text)) {
+    return { count: input.text.map((t) => Math.ceil(t.length / 4)) };
+  }
+  return { count: Math.ceil(input.text.length / 4) };
+};
+
+// src/provider-gemini/common/Gemini_ModelInfo.ts
+var Gemini_ModelInfo = async (input) => {
+  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/provider-gemini/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,
-      topP: input.topP
+      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 text generation");
-  logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
-  return { 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/provider-gemini/common/Gemini_TextEmbedding.ts
+import { getLogger as getLogger2 } from "@workglow/util/worker";
 var Gemini_TextEmbedding = async (input, model, update_progress, signal) => {
-  const logger = getLogger();
+  const logger = getLogger2();
   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");
@@ -115,54 +228,40 @@ var Gemini_TextEmbedding = async (input, model, update_progress, signal) => {
   logger.timeEnd(timerLabel, { model: model?.provider_config?.model_name });
   return { vector: new Float32Array(result.embedding.values) };
 };
-var Gemini_TextRewriter = async (input, model, update_progress, signal) => {
-  if (Array.isArray(input.text)) {
-    getLogger().warn("Gemini_TextRewriter: array input received; processing sequentially (no native batch support)");
-    const texts = input.text;
+
+// src/provider-gemini/common/Gemini_TextGeneration.ts
+import { getLogger as getLogger3 } from "@workglow/util/worker";
+var Gemini_TextGeneration = async (input, model, update_progress, signal) => {
+  if (Array.isArray(input.prompt)) {
+    getLogger3().warn("Gemini_TextGeneration: array input received; processing sequentially (no native batch support)");
+    const prompts = input.prompt;
     const results = [];
-    for (const item of texts) {
-      const r = await Gemini_TextRewriter({ ...input, text: item }, model, update_progress, signal);
+    for (const item of prompts) {
+      const r = await Gemini_TextGeneration({ ...input, prompt: item }, model, update_progress, signal);
       results.push(r.text);
     }
     return { text: results };
   }
-  update_progress(0, "Starting Gemini text rewriting");
+  const logger = getLogger3();
+  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),
-    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_TextSummary = async (input, model, update_progress, signal) => {
-  if (Array.isArray(input.text)) {
-    getLogger().warn("Gemini_TextSummary: array input received; processing sequentially (no native batch support)");
-    const texts = input.text;
-    const results = [];
-    for (const item of texts) {
-      const r = await Gemini_TextSummary({ ...input, text: item }, model, update_progress, signal);
-      results.push(r.text);
+    generationConfig: {
+      maxOutputTokens: input.maxTokens,
+      temperature: input.temperature,
+      topP: input.topP
     }
-    return { text: results };
-  }
-  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 }] }]
+    contents: [{ role: "user", parts: [{ text: input.prompt }] }]
   });
   const text = result.response.text();
-  update_progress(100, "Completed Gemini text summarization");
+  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) {
@@ -185,28 +284,40 @@ var Gemini_TextGeneration_Stream = async function* (input, model, signal) {
   }
   yield { type: "finish", data: {} };
 };
-var Gemini_TextRewriter_Stream = async function* (input, model, signal) {
+
+// src/provider-gemini/common/Gemini_TextRewriter.ts
+import { getLogger as getLogger4 } from "@workglow/util/worker";
+var Gemini_TextRewriter = async (input, model, update_progress, signal) => {
+  if (Array.isArray(input.text)) {
+    getLogger4().warn("Gemini_TextRewriter: array input received; processing sequentially (no native batch support)");
+    const texts = input.text;
+    const results = [];
+    for (const item of texts) {
+      const r = await Gemini_TextRewriter({ ...input, text: item }, model, update_progress, signal);
+      results.push(r.text);
+    }
+    return { text: results };
+  }
+  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.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: {} };
+  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_TextSummary_Stream = async function* (input, model, signal) {
+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: "Summarize the following text concisely."
+    systemInstruction: input.prompt
   });
   const result = await genModel.generateContentStream({ contents: [{ role: "user", parts: [{ text: input.text }] }] }, { signal });
   for await (const chunk of result.stream) {
@@ -217,85 +328,54 @@ var Gemini_TextSummary_Stream = async function* (input, model, signal) {
   }
   yield { type: "finish", data: {} };
 };
-var Gemini_CountTokens = async (input, model, onProgress, signal) => {
+
+// src/provider-gemini/common/Gemini_TextSummary.ts
+import { getLogger as getLogger5 } from "@workglow/util/worker";
+var Gemini_TextSummary = async (input, model, update_progress, signal) => {
   if (Array.isArray(input.text)) {
-    getLogger().warn("Gemini_CountTokens: array input received; processing sequentially (no native batch support)");
+    getLogger5().warn("Gemini_TextSummary: array input received; processing sequentially (no native batch support)");
     const texts = input.text;
-    const counts = [];
+    const results = [];
     for (const item of texts) {
-      const r = await Gemini_CountTokens({ ...input, text: item }, model, onProgress, signal);
-      counts.push(r.count);
+      const r = await Gemini_TextSummary({ ...input, text: item }, model, update_progress, signal);
+      results.push(r.text);
     }
-    return { count: counts };
-  }
-  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_Reactive = async (input, _output, _model) => {
-  if (Array.isArray(input.text)) {
-    return { count: input.text.map((t) => Math.ceil(t.length / 4)) };
+    return { text: results };
   }
-  return { count: Math.ceil(input.text.length / 4) };
-};
-var Gemini_StructuredGeneration = async (input, model, update_progress, signal, outputSchema) => {
-  update_progress(0, "Starting Gemini structured generation");
+  update_progress(0, "Starting Gemini text summarization");
   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
-    }
+    systemInstruction: "Summarize the following text concisely."
   });
   const result = await genModel.generateContent({
-    contents: [{ role: "user", parts: [{ text: input.prompt }] }]
+    contents: [{ role: "user", parts: [{ text: input.text }] }]
   });
   const text = result.response.text();
-  update_progress(100, "Completed Gemini structured generation");
-  return { object: JSON.parse(text) };
+  update_progress(100, "Completed Gemini text summarization");
+  return { text };
 };
-var Gemini_StructuredGeneration_Stream = async function* (input, model, signal, outputSchema) {
+var Gemini_TextSummary_Stream = async function* (input, model, signal) {
   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
-    }
+    systemInstruction: "Summarize the following text concisely."
   });
-  const result = await genModel.generateContentStream({ contents: [{ role: "user", parts: [{ text: input.prompt }] }] }, { signal });
-  let accumulatedJson = "";
+  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) {
-      accumulatedJson += text;
-      const partial = parsePartialJson(accumulatedJson);
-      if (partial !== undefined) {
-        yield { type: "object-delta", port: "object", objectDelta: partial };
-      }
+      yield { type: "text-delta", port: "text", textDelta: text };
     }
   }
-  let finalObject;
-  try {
-    finalObject = JSON.parse(accumulatedJson);
-  } catch {
-    finalObject = parsePartialJson(accumulatedJson) ?? {};
-  }
-  yield { type: "finish", data: { object: finalObject } };
+  yield { type: "finish", data: {} };
 };
+
+// src/provider-gemini/common/Gemini_ToolCalling.ts
+import { buildToolDescription, filterValidToolCalls } from "@workglow/ai/worker";
+import { getLogger as getLogger6 } from "@workglow/util/worker";
 function buildGeminiContents(input) {
   const inputMessages = input.messages;
   if (!inputMessages || inputMessages.length === 0) {
@@ -387,7 +467,7 @@ function mapGeminiToolConfig(toolChoice) {
 }
 var Gemini_ToolCalling = async (input, model, update_progress, signal) => {
   if (Array.isArray(input.prompt)) {
-    getLogger().warn("Gemini_ToolCalling: array input received; processing sequentially (no native batch support)");
+    getLogger6().warn("Gemini_ToolCalling: array input received; processing sequentially (no native batch support)");
     const prompts = input.prompt;
     const texts = [];
     const toolCallsList = [];
@@ -487,18 +567,8 @@ var Gemini_ToolCalling_Stream = async function* (input, model, signal) {
     data: { text: accumulatedText, toolCalls: validToolCalls }
   };
 };
-var Gemini_ModelInfo = async (input) => {
-  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/provider-gemini/common/Gemini_JobRunFns.ts
 var GEMINI_TASKS = {
   CountTokensTask: Gemini_CountTokens,
   ModelInfoTask: Gemini_ModelInfo,
@@ -507,7 +577,8 @@ var GEMINI_TASKS = {
   TextRewriterTask: Gemini_TextRewriter,
   TextSummaryTask: Gemini_TextSummary,
   StructuredGenerationTask: Gemini_StructuredGeneration,
-  ToolCallingTask: Gemini_ToolCalling
+  ToolCallingTask: Gemini_ToolCalling,
+  ModelSearchTask: Gemini_ModelSearch
 };
 var GEMINI_STREAM_TASKS = {
   TextGenerationTask: Gemini_TextGeneration_Stream,
@@ -519,38 +590,75 @@ var GEMINI_STREAM_TASKS = {
 var GEMINI_REACTIVE_TASKS = {
   CountTokensTask: Gemini_CountTokens_Reactive
 };
-// src/google-gemini/Gemini_Worker.ts
-import { getLogger as getLogger2, globalServiceRegistry, WORKER_SERVER } from "@workglow/util";
-function GEMINI_WORKER_JOBRUN_REGISTER() {
+
+// src/provider-gemini/GoogleGeminiQueuedProvider.ts
+import {
+  QueuedAiProvider
+} from "@workglow/ai";
+class GoogleGeminiQueuedProvider extends QueuedAiProvider {
+  name = GOOGLE_GEMINI;
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "CountTokensTask",
+    "ModelInfoTask",
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "StructuredGenerationTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, reactiveTasks) {
+    super(tasks, streamTasks, reactiveTasks);
+  }
+}
+
+// src/provider-gemini/registerGeminiInline.ts
+async function registerGeminiInline(options) {
+  await new GoogleGeminiQueuedProvider(GEMINI_TASKS, GEMINI_STREAM_TASKS, GEMINI_REACTIVE_TASKS).register(options ?? {});
+}
+// src/provider-gemini/registerGeminiWorker.ts
+import { getLogger as getLogger7, globalServiceRegistry, WORKER_SERVER } from "@workglow/util/worker";
+
+// src/provider-gemini/GoogleGeminiProvider.ts
+import {
+  AiProvider
+} from "@workglow/ai/worker";
+class GoogleGeminiProvider extends AiProvider {
+  name = GOOGLE_GEMINI;
+  isLocal = false;
+  supportsBrowser = true;
+  taskTypes = [
+    "CountTokensTask",
+    "ModelInfoTask",
+    "TextGenerationTask",
+    "TextEmbeddingTask",
+    "TextRewriterTask",
+    "TextSummaryTask",
+    "StructuredGenerationTask",
+    "ToolCallingTask",
+    "ModelSearchTask"
+  ];
+  constructor(tasks, streamTasks, reactiveTasks) {
+    super(tasks, streamTasks, reactiveTasks);
+  }
+}
+
+// src/provider-gemini/registerGeminiWorker.ts
+async function registerGeminiWorker() {
   const workerServer = globalServiceRegistry.get(WORKER_SERVER);
   new GoogleGeminiProvider(GEMINI_TASKS, GEMINI_STREAM_TASKS, GEMINI_REACTIVE_TASKS).registerOnWorkerServer(workerServer);
   workerServer.sendReady();
-  getLogger2().info("GEMINI_WORKER_JOBRUN registered");
+  getLogger7().info("Google Gemini worker job run functions registered");
 }
 export {
-  GoogleGeminiProvider,
-  Gemini_ToolCalling_Stream,
-  Gemini_ToolCalling,
-  Gemini_TextSummary_Stream,
-  Gemini_TextSummary,
-  Gemini_TextRewriter_Stream,
-  Gemini_TextRewriter,
-  Gemini_TextGeneration_Stream,
-  Gemini_TextGeneration,
-  Gemini_TextEmbedding,
-  Gemini_StructuredGeneration_Stream,
-  Gemini_StructuredGeneration,
-  Gemini_ModelInfo,
-  Gemini_CountTokens_Reactive,
-  Gemini_CountTokens,
-  GeminiModelSchema,
-  GeminiModelRecordSchema,
-  GeminiModelConfigSchema,
-  GOOGLE_GEMINI,
-  GEMINI_WORKER_JOBRUN_REGISTER,
-  GEMINI_TASKS,
-  GEMINI_STREAM_TASKS,
-  GEMINI_REACTIVE_TASKS
+  registerGeminiWorker,
+  registerGeminiInline,
+  loadGeminiSDK,
+  getModelName,
+  getApiKey
 };
 
-//# debugId=951B337FD24F757C64756E2164756E21
+//# debugId=FEC0D39AEF2629A364756E2164756E21