@rcrsr/rill-ext-gemini 0.8.2 → 0.8.4

package/dist/index.js

@@ -1,14 +1,860 @@
-/**
- * @rcrsr/rill-ext-gemini
- *
- * Extension for Google Gemini API integration with rill scripts.
- */
-// ============================================================
-// VERSION
-// ============================================================
-export const VERSION = '0.0.1';
-// ============================================================
-// EXTENSION FACTORY
-// ============================================================
-export { createGeminiExtension } from './factory.js';
-//# sourceMappingURL=index.js.map
+// src/factory.ts
+import {
+  GoogleGenAI,
+  Type
+} from "@google/genai";
+import {
+  RuntimeError as RuntimeError4,
+  emitExtensionEvent,
+  createVector,
+  isVector,
+  isCallable as isCallable2
+} from "@rcrsr/rill";
+
+// ../../shared/ext-llm/dist/validation.js
+import { RuntimeError } from "@rcrsr/rill";
+var MIN_TEMPERATURE = 0;
+var MAX_TEMPERATURE = 2;
+function validateApiKey(key) {
+  if (key === void 0) {
+    throw new Error("api_key is required");
+  }
+  if (key === "") {
+    throw new Error("api_key cannot be empty");
+  }
+}
+function validateModel(model) {
+  if (!model) {
+    throw new Error("model is required");
+  }
+}
+function validateTemperature(temperature) {
+  if (temperature === void 0) {
+    return;
+  }
+  if (temperature < MIN_TEMPERATURE || temperature > MAX_TEMPERATURE) {
+    throw new Error("temperature must be between 0 and 2");
+  }
+}
+function validateEmbedText(text) {
+  if (text === "") {
+    throw new RuntimeError("RILL-R001", "embed text cannot be empty");
+  }
+}
+function validateEmbedBatch(texts) {
+  const validated = [];
+  for (let i = 0; i < texts.length; i++) {
+    const item = texts[i];
+    if (typeof item !== "string") {
+      throw new RuntimeError("RILL-R001", "embed_batch requires list of strings");
+    }
+    if (item === "") {
+      throw new RuntimeError("RILL-R001", `embed text cannot be empty at index ${i}`);
+    }
+    validated.push(item);
+  }
+  return validated;
+}
+function validateEmbedModel(model) {
+  if (!model) {
+    throw new RuntimeError("RILL-R001", "embed_model not configured");
+  }
+}
+
+// ../../shared/ext-llm/dist/errors.js
+import { RuntimeError as RuntimeError2 } from "@rcrsr/rill";
+function mapProviderError(providerName, error, detect) {
+  const detected = detect(error);
+  if (detected !== null) {
+    const { status, message } = detected;
+    if (status !== void 0) {
+      return new RuntimeError2("RILL-R004", `${providerName} API error (HTTP ${status}): ${message}`, void 0, { cause: error });
+    }
+    return new RuntimeError2("RILL-R004", `${providerName} API error: ${message}`, void 0, { cause: error });
+  }
+  if (error instanceof Error) {
+    return new RuntimeError2("RILL-R004", `${providerName} error: ${error.message}`, void 0, { cause: error });
+  }
+  return new RuntimeError2("RILL-R004", `${providerName} error: Unknown error`, void 0, { cause: error });
+}
+
+// ../../shared/ext-llm/dist/tool-loop.js
+import { isCallable, isDict, RuntimeError as RuntimeError3 } from "@rcrsr/rill";
+async function executeToolCall(toolName, toolInput, tools, context) {
+  if (!isDict(tools)) {
+    throw new RuntimeError3("RILL-R004", "tools must be a dict mapping tool names to functions");
+  }
+  const toolsDict = tools;
+  const toolFn = toolsDict[toolName];
+  if (toolFn === void 0 || toolFn === null) {
+    throw new RuntimeError3("RILL-R004", `Unknown tool: ${toolName}`);
+  }
+  if (!isCallable(toolFn)) {
+    throw new RuntimeError3("RILL-R004", `Invalid tool input for ${toolName}: tool must be callable`);
+  }
+  if (typeof toolInput !== "object" || toolInput === null) {
+    throw new RuntimeError3("RILL-R004", `Invalid tool input for ${toolName}: input must be an object`);
+  }
+  const callable = toolFn;
+  if (callable.kind !== "runtime" && callable.kind !== "application") {
+    throw new RuntimeError3("RILL-R004", `Invalid tool input for ${toolName}: tool must be application or runtime callable`);
+  }
+  try {
+    let args;
+    if (callable.kind === "application" && callable.params) {
+      const params = callable.params;
+      const inputDict = toolInput;
+      args = params.map((param) => {
+        const value = inputDict[param.name];
+        return value !== void 0 ? value : void 0;
+      });
+    } else {
+      args = [toolInput];
+    }
+    const ctx = context ?? {
+      parent: void 0,
+      variables: /* @__PURE__ */ new Map(),
+      pipeValue: null
+    };
+    const result = callable.fn(args, ctx);
+    return result instanceof Promise ? await result : result;
+  } catch (error) {
+    if (error instanceof RuntimeError3) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new RuntimeError3("RILL-R004", `Invalid tool input for ${toolName}: ${message}`);
+  }
+}
+async function executeToolLoop(messages, tools, maxErrors, callbacks, emitEvent, maxTurns = 10, context) {
+  if (tools === void 0) {
+    throw new RuntimeError3("RILL-R004", "tools parameter is required");
+  }
+  if (!isDict(tools)) {
+    throw new RuntimeError3("RILL-R004", "tools must be a dict mapping tool names to functions");
+  }
+  const toolsDict = tools;
+  const toolDescriptors = Object.entries(toolsDict).map(([name, fn]) => {
+    const fnValue = fn;
+    if (!isCallable(fnValue)) {
+      throw new RuntimeError3("RILL-R004", `tool '${name}' must be callable function`);
+    }
+    const callable = fnValue;
+    const description = callable.kind === "application" && callable.description ? callable.description : "";
+    const properties = {};
+    const required = [];
+    if (callable.kind === "application" && callable.params) {
+      for (const param of callable.params) {
+        let jsonSchemaType;
+        switch (param.typeName) {
+          case "string":
+            jsonSchemaType = "string";
+            break;
+          case "number":
+            jsonSchemaType = "number";
+            break;
+          case "bool":
+            jsonSchemaType = "boolean";
+            break;
+          case "list":
+            jsonSchemaType = "array";
+            break;
+          case "dict":
+          case "vector":
+            jsonSchemaType = "object";
+            break;
+          case null:
+            jsonSchemaType = "string";
+            break;
+        }
+        const property = {
+          type: jsonSchemaType
+        };
+        if (param.description) {
+          property["description"] = param.description;
+        }
+        properties[param.name] = property;
+        if (param.defaultValue === null) {
+          required.push(param.name);
+        }
+      }
+    }
+    return {
+      name,
+      description,
+      input_schema: {
+        type: "object",
+        properties,
+        required
+      }
+    };
+  });
+  const providerTools = callbacks.buildTools(toolDescriptors);
+  let consecutiveErrors = 0;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  const executedToolCalls = [];
+  let currentMessages = [...messages];
+  let turnCount = 0;
+  while (turnCount < maxTurns) {
+    turnCount++;
+    let response;
+    try {
+      response = await callbacks.callAPI(currentMessages, providerTools);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new RuntimeError3("RILL-R004", `Provider API error: ${message}`, void 0, { cause: error });
+    }
+    if (typeof response === "object" && response !== null && "usage" in response) {
+      const usage = response["usage"];
+      if (typeof usage === "object" && usage !== null) {
+        const usageRecord = usage;
+        const inputTokens = typeof usageRecord["input_tokens"] === "number" ? usageRecord["input_tokens"] : 0;
+        const outputTokens = typeof usageRecord["output_tokens"] === "number" ? usageRecord["output_tokens"] : 0;
+        totalInputTokens += inputTokens;
+        totalOutputTokens += outputTokens;
+      }
+    }
+    const toolCalls = callbacks.extractToolCalls(response);
+    if (toolCalls === null || toolCalls.length === 0) {
+      return {
+        response,
+        toolCalls: executedToolCalls,
+        totalTokens: { input: totalInputTokens, output: totalOutputTokens },
+        turns: turnCount
+      };
+    }
+    const toolResults = [];
+    for (const toolCall of toolCalls) {
+      const { id, name, input } = toolCall;
+      emitEvent("tool_call", { tool_name: name, args: input });
+      const toolStartTime = Date.now();
+      try {
+        const result = await executeToolCall(name, input, tools, context);
+        const duration = Date.now() - toolStartTime;
+        toolResults.push({ id, name, result });
+        executedToolCalls.push({ name, result });
+        consecutiveErrors = 0;
+        emitEvent("tool_result", { tool_name: name, duration });
+      } catch (error) {
+        const duration = Date.now() - toolStartTime;
+        consecutiveErrors++;
+        let originalError;
+        if (error instanceof RuntimeError3) {
+          const prefix = `Invalid tool input for ${name}: `;
+          if (error.message.startsWith(prefix)) {
+            originalError = error.message.slice(prefix.length);
+          } else {
+            originalError = error.message;
+          }
+        } else if (error instanceof Error) {
+          originalError = error.message;
+        } else {
+          originalError = "Unknown error";
+        }
+        const errorResult = originalError;
+        toolResults.push({
+          id,
+          name,
+          result: errorResult,
+          error: originalError
+        });
+        emitEvent("tool_result", {
+          tool_name: name,
+          error: originalError,
+          duration
+        });
+        if (consecutiveErrors >= maxErrors) {
+          throw new RuntimeError3("RILL-R004", `Tool execution failed: ${maxErrors} consecutive errors`);
+        }
+      }
+    }
+    const toolResultMessage = callbacks.formatToolResult(toolResults);
+    currentMessages.push(toolResultMessage);
+  }
+  return {
+    response: null,
+    toolCalls: executedToolCalls,
+    totalTokens: { input: totalInputTokens, output: totalOutputTokens },
+    turns: turnCount
+  };
+}
+
+// src/factory.ts
+var DEFAULT_MAX_TOKENS = 8192;
+var detectGeminiError = (error) => {
+  if (error instanceof Error) {
+    const message = error.message;
+    const statusMatch = message.match(/\((\d{3})\)/);
+    if (statusMatch && statusMatch[1]) {
+      return {
+        status: parseInt(statusMatch[1], 10),
+        message
+      };
+    }
+    return {
+      message
+    };
+  }
+  return null;
+};
+function createGeminiExtension(config) {
+  validateApiKey(config.api_key);
+  validateModel(config.model);
+  validateTemperature(config.temperature);
+  const client = new GoogleGenAI({
+    apiKey: config.api_key
+  });
+  const factoryModel = config.model;
+  const factoryTemperature = config.temperature;
+  const factoryMaxTokens = config.max_tokens ?? DEFAULT_MAX_TOKENS;
+  const factorySystem = config.system;
+  const factoryEmbedModel = config.embed_model;
+  let abortController = new AbortController();
+  const dispose = async () => {
+    try {
+      if (abortController) {
+        abortController.abort();
+        abortController = void 0;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.warn(`Failed to abort Gemini requests: ${message}`);
+    }
+    try {
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.warn(`Failed to cleanup Gemini SDK: ${message}`);
+    }
+  };
+  const result = {
+    // IR-4: gemini::message
+    message: {
+      params: [
+        { name: "text", type: "string" },
+        { name: "options", type: "dict", defaultValue: {} }
+      ],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          const text = args[0];
+          const options = args[1] ?? {};
+          if (text.trim().length === 0) {
+            throw new RuntimeError4("RILL-R004", "prompt text cannot be empty");
+          }
+          const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
+          const maxTokens = typeof options["max_tokens"] === "number" ? options["max_tokens"] : factoryMaxTokens;
+          const contents = [
+            {
+              role: "user",
+              parts: [{ text }]
+            }
+          ];
+          const apiConfig = {};
+          if (system !== void 0) {
+            apiConfig.systemInstruction = system;
+          }
+          if (maxTokens !== void 0) {
+            apiConfig.maxOutputTokens = maxTokens;
+          }
+          if (factoryTemperature !== void 0) {
+            apiConfig.temperature = factoryTemperature;
+          }
+          const response = await client.models.generateContent({
+            model: factoryModel,
+            contents,
+            config: apiConfig
+          });
+          const content = response.text ?? "";
+          const result2 = {
+            content,
+            model: factoryModel,
+            usage: {
+              input: 0,
+              // Gemini API doesn't always provide token counts
+              output: 0
+            },
+            stop_reason: "stop",
+            id: "",
+            // Gemini API doesn't provide request IDs in the same way
+            messages: [
+              ...system ? [{ role: "system", content: system }] : [],
+              { role: "user", content: text },
+              { role: "assistant", content }
+            ]
+          };
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "gemini:message",
+            subsystem: "extension:gemini",
+            duration,
+            model: factoryModel,
+            usage: result2.usage
+          });
+          return result2;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = error instanceof RuntimeError4 ? error : mapProviderError("Gemini", error, detectGeminiError);
+          emitExtensionEvent(ctx, {
+            event: "gemini:error",
+            subsystem: "extension:gemini",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Send single message to Gemini API",
+      returnType: "dict"
+    },
+    // IR-5: gemini::messages
+    messages: {
+      params: [
+        { name: "messages", type: "list" },
+        { name: "options", type: "dict", defaultValue: {} }
+      ],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          const messages = args[0];
+          const options = args[1] ?? {};
+          if (messages.length === 0) {
+            throw new RuntimeError4(
+              "RILL-R004",
+              "messages list cannot be empty"
+            );
+          }
+          const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
+          const maxTokens = typeof options["max_tokens"] === "number" ? options["max_tokens"] : factoryMaxTokens;
+          const contents = [];
+          for (let i = 0; i < messages.length; i++) {
+            const msg = messages[i];
+            if (!msg || typeof msg !== "object" || !("role" in msg)) {
+              throw new RuntimeError4(
+                "RILL-R004",
+                "message missing required 'role' field"
+              );
+            }
+            const role = msg["role"];
+            if (role !== "user" && role !== "assistant" && role !== "tool") {
+              throw new RuntimeError4("RILL-R004", `invalid role '${role}'`);
+            }
+            if (role === "user" || role === "tool") {
+              if (!("content" in msg) || typeof msg["content"] !== "string") {
+                throw new RuntimeError4(
+                  "RILL-R004",
+                  `${role} message requires 'content'`
+                );
+              }
+              contents.push({
+                role: "user",
+                parts: [{ text: msg["content"] }]
+              });
+            } else if (role === "assistant") {
+              const hasContent = "content" in msg && msg["content"];
+              const hasToolCalls = "tool_calls" in msg && msg["tool_calls"];
+              if (!hasContent && !hasToolCalls) {
+                throw new RuntimeError4(
+                  "RILL-R004",
+                  "assistant message requires 'content' or 'tool_calls'"
+                );
+              }
+              if (hasContent) {
+                contents.push({
+                  role: "model",
+                  parts: [{ text: msg["content"] }]
+                });
+              }
+            }
+          }
+          const apiConfig = {};
+          if (system !== void 0) {
+            apiConfig.systemInstruction = system;
+          }
+          if (maxTokens !== void 0) {
+            apiConfig.maxOutputTokens = maxTokens;
+          }
+          if (factoryTemperature !== void 0) {
+            apiConfig.temperature = factoryTemperature;
+          }
+          const response = await client.models.generateContent({
+            model: factoryModel,
+            contents,
+            config: apiConfig
+          });
+          const content = response.text ?? "";
+          const fullMessages = [
+            ...messages.map((m) => {
+              const normalized = { role: m["role"] };
+              if ("content" in m) normalized["content"] = m["content"];
+              if ("tool_calls" in m) normalized["tool_calls"] = m["tool_calls"];
+              return normalized;
+            }),
+            { role: "assistant", content }
+          ];
+          const result2 = {
+            content,
+            model: factoryModel,
+            usage: {
+              input: 0,
+              // Gemini API doesn't always provide token counts
+              output: 0
+            },
+            stop_reason: "stop",
+            id: "",
+            // Gemini API doesn't provide request IDs in the same way
+            messages: fullMessages
+          };
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "gemini:messages",
+            subsystem: "extension:gemini",
+            duration,
+            model: factoryModel,
+            usage: result2.usage
+          });
+          return result2;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = error instanceof RuntimeError4 ? error : mapProviderError("Gemini", error, detectGeminiError);
+          emitExtensionEvent(ctx, {
+            event: "gemini:error",
+            subsystem: "extension:gemini",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Send multi-turn conversation to Gemini API",
+      returnType: "dict"
+    },
+    // IR-6: gemini::embed
+    embed: {
+      params: [{ name: "text", type: "string" }],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          const text = args[0];
+          validateEmbedText(text);
+          validateEmbedModel(factoryEmbedModel);
+          const response = await client.models.embedContent({
+            model: factoryEmbedModel,
+            contents: [text]
+          });
+          const embedding = response.embeddings?.[0];
+          if (!embedding || !embedding.values || embedding.values.length === 0) {
+            throw new RuntimeError4(
+              "RILL-R004",
+              "Gemini: empty embedding returned"
+            );
+          }
+          const float32Data = new Float32Array(embedding.values);
+          const vector = createVector(float32Data, factoryEmbedModel);
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "gemini:embed",
+            subsystem: "extension:gemini",
+            duration,
+            model: factoryEmbedModel,
+            dimensions: float32Data.length
+          });
+          return vector;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = error instanceof RuntimeError4 ? error : mapProviderError("Gemini", error, detectGeminiError);
+          emitExtensionEvent(ctx, {
+            event: "gemini:error",
+            subsystem: "extension:gemini",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Generate embedding vector for text",
+      returnType: "vector"
+    },
+    // IR-7: gemini::embed_batch
+    embed_batch: {
+      params: [{ name: "texts", type: "list" }],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          const texts = args[0];
+          if (texts.length === 0) {
+            return [];
+          }
+          validateEmbedModel(factoryEmbedModel);
+          const stringTexts = validateEmbedBatch(texts);
+          const response = await client.models.embedContent({
+            model: factoryEmbedModel,
+            contents: stringTexts
+          });
+          const vectors = [];
+          if (!response.embeddings || response.embeddings.length === 0) {
+            throw new RuntimeError4(
+              "RILL-R004",
+              "Gemini: empty embeddings returned"
+            );
+          }
+          for (const embedding of response.embeddings) {
+            if (!embedding || !embedding.values || embedding.values.length === 0) {
+              throw new RuntimeError4(
+                "RILL-R004",
+                "Gemini: empty embedding returned"
+              );
+            }
+            const float32Data = new Float32Array(embedding.values);
+            const vector = createVector(float32Data, factoryEmbedModel);
+            vectors.push(vector);
+          }
+          const duration = Date.now() - startTime;
+          const firstVector = vectors[0];
+          const dimensions = firstVector && isVector(firstVector) ? firstVector.data.length : 0;
+          emitExtensionEvent(ctx, {
+            event: "gemini:embed_batch",
+            subsystem: "extension:gemini",
+            duration,
+            model: factoryEmbedModel,
+            dimensions,
+            count: vectors.length
+          });
+          return vectors;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = error instanceof RuntimeError4 ? error : mapProviderError("Gemini", error, detectGeminiError);
+          emitExtensionEvent(ctx, {
+            event: "gemini:error",
+            subsystem: "extension:gemini",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Generate embedding vectors for multiple texts",
+      returnType: "list"
+    },
+    // IR-8: gemini::tool_loop
+    tool_loop: {
+      params: [
+        { name: "prompt", type: "string" },
+        { name: "options", type: "dict", defaultValue: {} }
+      ],
+      fn: async (args, ctx) => {
+        const startTime = Date.now();
+        try {
+          const prompt = args[0];
+          const options = args[1] ?? {};
+          if (prompt.trim().length === 0) {
+            throw new RuntimeError4("RILL-R004", "prompt text cannot be empty");
+          }
+          if (!("tools" in options) || !Array.isArray(options["tools"])) {
+            throw new RuntimeError4(
+              "RILL-R004",
+              "tool_loop requires 'tools' option"
+            );
+          }
+          const toolDescriptors = options["tools"];
+          const toolsDict = {};
+          for (const descriptor of toolDescriptors) {
+            const name = typeof descriptor["name"] === "string" ? descriptor["name"] : null;
+            if (!name) {
+              throw new RuntimeError4(
+                "RILL-R004",
+                "tool descriptor missing name"
+              );
+            }
+            const toolFnValue = descriptor["fn"];
+            if (!toolFnValue) {
+              throw new RuntimeError4(
+                "RILL-R004",
+                `tool '${name}' missing fn property`
+              );
+            }
+            if (!isCallable2(toolFnValue)) {
+              throw new RuntimeError4(
+                "RILL-R004",
+                `tool '${name}' fn must be callable`
+              );
+            }
+            toolsDict[name] = toolFnValue;
+          }
+          const system = typeof options["system"] === "string" ? options["system"] : factorySystem;
+          const maxTokens = typeof options["max_tokens"] === "number" ? options["max_tokens"] : factoryMaxTokens;
+          const maxTurns = typeof options["max_turns"] === "number" ? options["max_turns"] : 10;
+          const maxErrors = typeof options["max_errors"] === "number" ? options["max_errors"] : 3;
+          const initialMessages = Array.isArray(options["messages"]) && options["messages"].length > 0 ? options["messages"] : [];
+          const contents = [];
+          for (const msg of initialMessages) {
+            if (typeof msg === "object" && msg !== null && "role" in msg && "content" in msg) {
+              const role = msg["role"];
+              if (role === "user") {
+                contents.push({
+                  role: "user",
+                  parts: [{ text: msg["content"] }]
+                });
+              } else if (role === "assistant") {
+                contents.push({
+                  role: "model",
+                  parts: [{ text: msg["content"] }]
+                });
+              }
+            }
+          }
+          contents.push({
+            role: "user",
+            parts: [{ text: prompt }]
+          });
+          const callbacks = {
+            // Build Gemini FunctionDeclaration format from tool definitions
+            buildTools: (toolDefs) => {
+              return toolDefs.map((def) => {
+                const properties = {};
+                for (const [propName, propDef] of Object.entries(
+                  def.input_schema.properties
+                )) {
+                  const prop = propDef;
+                  const propType = prop["type"];
+                  let schemaType = Type.STRING;
+                  if (propType === "number") schemaType = Type.NUMBER;
+                  if (propType === "boolean") schemaType = Type.BOOLEAN;
+                  if (propType === "integer") schemaType = Type.INTEGER;
+                  if (propType === "array") schemaType = Type.ARRAY;
+                  if (propType === "object") schemaType = Type.OBJECT;
+                  properties[propName] = {
+                    type: schemaType,
+                    description: prop["description"] ?? ""
+                  };
+                }
+                return {
+                  name: def.name,
+                  description: def.description,
+                  parameters: {
+                    type: Type.OBJECT,
+                    properties,
+                    required: def.input_schema.required
+                  }
+                };
+              });
+            },
+            // Call Gemini API
+            callAPI: async (msgs, tools) => {
+              const apiConfig = {
+                ...system !== void 0 && { systemInstruction: system },
+                ...maxTokens !== void 0 && { maxOutputTokens: maxTokens },
+                ...factoryTemperature !== void 0 && {
+                  temperature: factoryTemperature
+                },
+                tools: [
+                  { functionDeclarations: tools }
+                ]
+              };
+              return await client.models.generateContent({
+                model: factoryModel,
+                contents: msgs,
+                config: apiConfig
+              });
+            },
+            // Extract tool calls from Gemini response
+            extractToolCalls: (response2) => {
+              if (!response2 || typeof response2 !== "object" || !("functionCalls" in response2)) {
+                return null;
+              }
+              const functionCalls = response2.functionCalls;
+              if (!functionCalls || functionCalls.length === 0) {
+                return null;
+              }
+              return functionCalls.map((fc) => {
+                const call = fc;
+                return {
+                  id: call.id ?? "",
+                  name: call.name ?? "",
+                  input: call.args ?? {}
+                };
+              });
+            },
+            // Format tool results into Gemini message format
+            formatToolResult: (toolResults) => {
+              const functionResponseParts = toolResults.map((tr) => ({
+                functionResponse: {
+                  name: tr.name,
+                  response: {
+                    result: tr.error ? `Error: ${tr.error}` : typeof tr.result === "string" ? tr.result : JSON.stringify(tr.result)
+                  }
+                }
+              }));
+              return {
+                role: "user",
+                parts: functionResponseParts
+              };
+            }
+          };
+          const loopResult = await executeToolLoop(
+            contents,
+            toolsDict,
+            maxErrors,
+            callbacks,
+            (event, data) => {
+              const eventMap = {
+                tool_call: "gemini:tool_call",
+                tool_result: "gemini:tool_result"
+              };
+              emitExtensionEvent(ctx, {
+                event: eventMap[event] || event,
+                subsystem: "extension:gemini",
+                ...data
+              });
+            },
+            maxTurns
+          );
+          const response = loopResult.response;
+          const content = response && typeof response === "object" && "text" in response ? response.text ?? "" : "";
+          const result2 = {
+            content,
+            model: factoryModel,
+            usage: loopResult.totalTokens,
+            stop_reason: response ? "stop" : "max_turns",
+            turns: loopResult.turns,
+            messages: [
+              ...initialMessages,
+              { role: "user", content: prompt },
+              { role: "assistant", content }
+            ]
+          };
+          const duration = Date.now() - startTime;
+          emitExtensionEvent(ctx, {
+            event: "gemini:tool_loop",
+            subsystem: "extension:gemini",
+            turns: result2.turns,
+            total_duration: duration,
+            usage: result2.usage
+          });
+          return result2;
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          const rillError = error instanceof RuntimeError4 ? error : mapProviderError("Gemini", error, detectGeminiError);
+          emitExtensionEvent(ctx, {
+            event: "gemini:error",
+            subsystem: "extension:gemini",
+            error: rillError.message,
+            duration
+          });
+          throw rillError;
+        }
+      },
+      description: "Execute tool-use loop with Gemini API",
+      returnType: "dict"
+    }
+  };
+  result.dispose = dispose;
+  return result;
+}
+
+// src/index.ts
+var VERSION = "0.0.1";
+export {
+  VERSION,
+  createGeminiExtension
+};