ai-sdk-provider-gemini-cli-agentic 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,689 @@
+'use strict';
+
+var provider = require('@ai-sdk/provider');
+var child_process = require('child_process');
+var crypto = require('crypto');
+var providerUtils = require('@ai-sdk/provider-utils');
+var zod = require('zod');
+
+// src/gemini-cli-provider.ts
+
+// src/stream-parser.ts
+function parseStreamJsonLine(line) {
+  try {
+    const event = JSON.parse(line);
+    if (!event.type || typeof event.type !== "string") return null;
+    return event;
+  } catch {
+    return null;
+  }
+}
+function isInitEvent(event) {
+  return event.type === "init";
+}
+function isMessageEvent(event) {
+  return event.type === "message";
+}
+function isToolUseEvent(event) {
+  return event.type === "tool_use";
+}
+function isToolResultEvent(event) {
+  return event.type === "tool_result";
+}
+function isResultEvent(event) {
+  return event.type === "result";
+}
+function isErrorEvent(event) {
+  return event.type === "error";
+}
+function createEmptyUsage() {
+  return {
+    inputTokens: {
+      total: 0,
+      noCache: 0,
+      cacheRead: 0,
+      cacheWrite: 0
+    },
+    outputTokens: {
+      total: 0,
+      text: void 0,
+      reasoning: void 0
+    },
+    raw: void 0
+  };
+}
+function convertStatsToUsage(stats) {
+  const inputTotal = stats.input_tokens ?? stats.input ?? 0;
+  const outputTotal = stats.output_tokens ?? 0;
+  const cached = stats.cached ?? 0;
+  return {
+    inputTokens: {
+      total: inputTotal,
+      noCache: inputTotal - cached,
+      cacheRead: cached,
+      cacheWrite: 0
+    },
+    outputTokens: {
+      total: outputTotal,
+      text: void 0,
+      reasoning: void 0
+    },
+    raw: stats
+  };
+}
+
+// src/message-mapper.ts
+function isTextPart(p) {
+  return typeof p === "object" && p !== null && "type" in p && p.type === "text" && "text" in p && typeof p.text === "string";
+}
+function isToolItem(p) {
+  if (typeof p !== "object" || p === null) return false;
+  const obj = p;
+  if (typeof obj.toolName !== "string") return false;
+  const out = obj.output;
+  if (!out || out.type !== "text" && out.type !== "json") return false;
+  if (out.type === "text" && typeof out.value !== "string") return false;
+  return true;
+}
+function mapMessagesToPrompt(prompt) {
+  const warnings = [];
+  const parts = [];
+  let systemText;
+  for (const msg of prompt) {
+    if (msg.role === "system") {
+      systemText = typeof msg.content === "string" ? msg.content : String(msg.content);
+      continue;
+    }
+    if (msg.role === "user") {
+      if (typeof msg.content === "string") {
+        parts.push(`Human: ${msg.content}`);
+      } else if (Array.isArray(msg.content)) {
+        const text = msg.content.filter(isTextPart).map((p) => p.text).join("\n");
+        if (text) parts.push(`Human: ${text}`);
+      }
+      continue;
+    }
+    if (msg.role === "assistant") {
+      if (typeof msg.content === "string") {
+        parts.push(`Assistant: ${msg.content}`);
+      } else if (Array.isArray(msg.content)) {
+        const text = msg.content.filter(isTextPart).map((p) => p.text).join("\n");
+        if (text) parts.push(`Assistant: ${text}`);
+      }
+      continue;
+    }
+    if (msg.role === "tool") {
+      if (Array.isArray(msg.content)) {
+        for (const maybeTool of msg.content) {
+          if (!isToolItem(maybeTool)) continue;
+          const value = maybeTool.output.type === "text" ? maybeTool.output.value : JSON.stringify(maybeTool.output.value);
+          parts.push(`Tool Result (${maybeTool.toolName}): ${value}`);
+        }
+      }
+      continue;
+    }
+  }
+  let promptText = "";
+  if (systemText) promptText += systemText + "\n\n";
+  promptText += parts.join("\n\n");
+  return { promptText, ...warnings.length ? { warnings } : {} };
+}
+
+// src/logger.ts
+var defaultLogger = {
+  debug: (message) => console.debug(`[DEBUG] ${message}`),
+  info: (message) => console.info(`[INFO] ${message}`),
+  warn: (message) => console.warn(`[WARN] ${message}`),
+  error: (message) => console.error(`[ERROR] ${message}`)
+};
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+function getLogger(logger) {
+  if (logger === false) {
+    return noopLogger;
+  }
+  if (logger === void 0) {
+    return defaultLogger;
+  }
+  return logger;
+}
+function createVerboseLogger(logger, verbose = false) {
+  if (verbose) {
+    return logger;
+  }
+  return {
+    debug: () => {
+    },
+    info: () => {
+    },
+    warn: logger.warn.bind(logger),
+    error: logger.error.bind(logger)
+  };
+}
+function createAPICallError({
+  message,
+  code,
+  exitCode,
+  stderr,
+  promptExcerpt,
+  isRetryable = false
+}) {
+  const data = { code, exitCode, stderr, promptExcerpt };
+  return new provider.APICallError({
+    message,
+    isRetryable,
+    url: "gemini-cli://exec",
+    requestBodyValues: promptExcerpt ? { prompt: promptExcerpt } : void 0,
+    data
+  });
+}
+function createAuthenticationError(message) {
+  return new provider.LoadAPIKeyError({
+    message: message || 'Authentication failed. Run "gemini" to authenticate.'
+  });
+}
+function isAuthenticationError(err) {
+  if (err instanceof provider.LoadAPIKeyError) return true;
+  if (err instanceof provider.APICallError) {
+    const data = err.data;
+    if (data?.exitCode === 401) return true;
+  }
+  return false;
+}
+var geminiCliProviderOptionsSchema = zod.z.object({
+  approvalMode: zod.z.enum(["default", "auto_edit", "yolo"]).optional(),
+  yolo: zod.z.boolean().optional(),
+  sandbox: zod.z.boolean().optional(),
+  includeDirectories: zod.z.array(zod.z.string().min(1)).optional(),
+  allowedTools: zod.z.array(zod.z.string().min(1)).optional(),
+  allowedMcpServerNames: zod.z.array(zod.z.string().min(1)).optional()
+}).strict();
+function mapGeminiFinishReason(status) {
+  switch (status) {
+    case "success":
+      return { unified: "stop", raw: status };
+    case "error":
+      return { unified: "error", raw: status };
+    default:
+      return { unified: "stop", raw: status };
+  }
+}
+var GeminiCliLanguageModel = class {
+  specificationVersion = "v3";
+  provider = "gemini-cli";
+  defaultObjectGenerationMode = "json";
+  supportsImageUrls = false;
+  supportedUrls = {};
+  supportsStructuredOutputs = false;
+  modelId;
+  settings;
+  logger;
+  sessionId;
+  constructor(options) {
+    this.modelId = options.id;
+    this.settings = options.settings ?? {};
+    const baseLogger = getLogger(this.settings.logger);
+    this.logger = createVerboseLogger(baseLogger, this.settings.verbose ?? false);
+    if (!this.modelId || this.modelId.trim() === "") {
+      throw new provider.NoSuchModelError({ modelId: this.modelId, modelType: "languageModel" });
+    }
+  }
+  mergeSettings(providerOptions) {
+    if (!providerOptions) return this.settings;
+    return {
+      ...this.settings,
+      approvalMode: providerOptions.approvalMode ?? this.settings.approvalMode,
+      yolo: providerOptions.yolo ?? this.settings.yolo,
+      sandbox: providerOptions.sandbox ?? this.settings.sandbox,
+      includeDirectories: providerOptions.includeDirectories ?? this.settings.includeDirectories,
+      allowedTools: providerOptions.allowedTools ?? this.settings.allowedTools,
+      allowedMcpServerNames: providerOptions.allowedMcpServerNames ?? this.settings.allowedMcpServerNames
+    };
+  }
+  buildArgs(promptText, settings = this.settings) {
+    const cmd = settings.geminiPath ?? "gemini";
+    const args = [];
+    args.push("--output-format", "stream-json");
+    if (this.modelId && this.modelId !== "auto") {
+      args.push("-m", this.modelId);
+    }
+    if (settings.yolo) {
+      args.push("--yolo");
+    } else if (settings.approvalMode) {
+      args.push("--approval-mode", settings.approvalMode);
+    }
+    if (settings.sandbox) {
+      args.push("--sandbox");
+    }
+    if (settings.includeDirectories?.length) {
+      for (const dir of settings.includeDirectories) {
+        args.push("--include-directories", dir);
+      }
+    }
+    if (settings.allowedTools?.length) {
+      args.push("--allowed-tools", ...settings.allowedTools);
+    }
+    if (settings.allowedMcpServerNames?.length) {
+      args.push("--allowed-mcp-server-names", ...settings.allowedMcpServerNames);
+    }
+    if (settings.resume) {
+      if (typeof settings.resume === "string") {
+        args.push("--resume", settings.resume);
+      } else {
+        args.push("--resume", "latest");
+      }
+    }
+    args.push(promptText);
+    const env = {
+      ...process.env,
+      ...settings.env || {}
+    };
+    return { cmd, args, env, cwd: settings.cwd };
+  }
+  mapWarnings(options) {
+    const unsupported = [];
+    const add = (setting, name) => {
+      if (setting !== void 0) {
+        unsupported.push({
+          type: "unsupported",
+          feature: name,
+          details: `Gemini CLI does not support ${name}; it will be ignored.`
+        });
+      }
+    };
+    add(options.temperature, "temperature");
+    add(options.topP, "topP");
+    add(options.topK, "topK");
+    add(options.presencePenalty, "presencePenalty");
+    add(options.frequencyPenalty, "frequencyPenalty");
+    add(options.stopSequences?.length ? options.stopSequences : void 0, "stopSequences");
+    return unsupported;
+  }
+  handleSpawnError(err, promptExcerpt) {
+    const e = err && typeof err === "object" ? err : void 0;
+    const message = String((e?.message ?? err) || "Failed to run Gemini CLI");
+    if (/login|auth|unauthorized/i.test(message)) {
+      return createAuthenticationError(message);
+    }
+    return createAPICallError({
+      message,
+      code: typeof e?.code === "string" ? e.code : void 0,
+      promptExcerpt
+    });
+  }
+  async doGenerate(options) {
+    this.logger.debug(`[gemini-cli] Starting doGenerate request with model: ${this.modelId}`);
+    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(options.prompt);
+    const promptExcerpt = promptText.slice(0, 200);
+    const warnings = [
+      ...this.mapWarnings(options),
+      ...mappingWarnings?.map((m) => ({ type: "other", message: m })) || []
+    ];
+    const providerOptions = await providerUtils.parseProviderOptions({
+      provider: this.provider,
+      providerOptions: options.providerOptions,
+      schema: geminiCliProviderOptionsSchema
+    });
+    const effectiveSettings = this.mergeSettings(providerOptions);
+    const { cmd, args, env, cwd } = this.buildArgs(promptText, effectiveSettings);
+    this.logger.debug(`[gemini-cli] Executing: ${cmd} ${args.slice(0, -1).join(" ")} [prompt]`);
+    let text = "";
+    let usage = createEmptyUsage();
+    let finishReason = { unified: "stop", raw: void 0 };
+    const content = [];
+    const toolResults = /* @__PURE__ */ new Map();
+    const child = child_process.spawn(cmd, args, { env, cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let onAbort;
+    if (options.abortSignal) {
+      if (options.abortSignal.aborted) {
+        child.kill("SIGTERM");
+        throw options.abortSignal.reason ?? new Error("Request aborted");
+      }
+      onAbort = () => child.kill("SIGTERM");
+      options.abortSignal.addEventListener("abort", onAbort, { once: true });
+    }
+    const startTime = Date.now();
+    try {
+      await new Promise((resolve, reject) => {
+        let stderr = "";
+        child.stderr.on("data", (d) => stderr += String(d));
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+          const lines = chunk.split(/\r?\n/).filter(Boolean);
+          for (const line of lines) {
+            const event = parseStreamJsonLine(line);
+            if (!event) continue;
+            this.logger.debug(`[gemini-cli] Event: ${event.type}`);
+            if (isInitEvent(event)) {
+              this.sessionId = event.session_id;
+              this.logger.debug(`[gemini-cli] Session: ${this.sessionId}`);
+            }
+            if (isMessageEvent(event) && event.role === "assistant" && event.content) {
+              if (event.delta) {
+                text += event.content;
+              } else {
+                text = event.content;
+              }
+            }
+            if (isToolUseEvent(event)) {
+              toolResults.set(event.tool_id, { toolName: event.tool_name });
+              content.push({
+                type: "tool-call",
+                toolCallId: event.tool_id,
+                toolName: event.tool_name,
+                input: JSON.stringify(event.parameters)
+              });
+            }
+            if (isToolResultEvent(event)) {
+              const toolInfo = toolResults.get(event.tool_id);
+              content.push({
+                type: "tool-result",
+                toolCallId: event.tool_id,
+                toolName: toolInfo?.toolName ?? "unknown",
+                result: event.output,
+                isError: event.status === "error"
+              });
+            }
+            if (isResultEvent(event)) {
+              if (event.stats) {
+                usage = convertStatsToUsage(event.stats);
+              }
+              finishReason = mapGeminiFinishReason(event.status);
+            }
+            if (isErrorEvent(event)) {
+              reject(
+                createAPICallError({
+                  message: event.error,
+                  stderr,
+                  promptExcerpt
+                })
+              );
+            }
+          }
+        });
+        child.on("error", (e) => {
+          this.logger.error(`[gemini-cli] Spawn error: ${String(e)}`);
+          reject(this.handleSpawnError(e, promptExcerpt));
+        });
+        child.on("close", (code) => {
+          const duration = Date.now() - startTime;
+          if (code === 0) {
+            this.logger.info(`[gemini-cli] Completed in ${duration}ms`);
+            resolve();
+          } else {
+            this.logger.error(`[gemini-cli] Exited with code ${code}`);
+            reject(
+              createAPICallError({
+                message: `Gemini CLI exited with code ${code}`,
+                exitCode: code ?? void 0,
+                stderr,
+                promptExcerpt
+              })
+            );
+          }
+        });
+      });
+    } finally {
+      if (options.abortSignal && onAbort) {
+        options.abortSignal.removeEventListener("abort", onAbort);
+      }
+    }
+    if (text) {
+      content.unshift({ type: "text", text });
+    }
+    return {
+      content: content.length > 0 ? content : [{ type: "text", text: "" }],
+      usage,
+      finishReason,
+      warnings,
+      response: { id: providerUtils.generateId(), timestamp: /* @__PURE__ */ new Date(), modelId: this.modelId },
+      request: { body: promptText },
+      providerMetadata: {
+        "gemini-cli": { ...this.sessionId ? { sessionId: this.sessionId } : {} }
+      }
+    };
+  }
+  async doStream(options) {
+    this.logger.debug(`[gemini-cli] Starting doStream request with model: ${this.modelId}`);
+    const { promptText, warnings: mappingWarnings } = mapMessagesToPrompt(options.prompt);
+    const promptExcerpt = promptText.slice(0, 200);
+    const warnings = [
+      ...this.mapWarnings(options),
+      ...mappingWarnings?.map((m) => ({ type: "other", message: m })) || []
+    ];
+    const providerOptions = await providerUtils.parseProviderOptions({
+      provider: this.provider,
+      providerOptions: options.providerOptions,
+      schema: geminiCliProviderOptionsSchema
+    });
+    const effectiveSettings = this.mergeSettings(providerOptions);
+    const { cmd, args, env, cwd } = this.buildArgs(promptText, effectiveSettings);
+    this.logger.debug(`[gemini-cli] Streaming: ${cmd} ${args.slice(0, -1).join(" ")} [prompt]`);
+    const model = this;
+    const abortSignal = options.abortSignal;
+    const stream = new ReadableStream({
+      start(controller) {
+        const startTime = Date.now();
+        const child = child_process.spawn(cmd, args, { env, cwd, stdio: ["ignore", "pipe", "pipe"] });
+        controller.enqueue({ type: "stream-start", warnings });
+        let stderr = "";
+        let lastUsage;
+        let textId;
+        let lastStatus;
+        const toolResults = /* @__PURE__ */ new Map();
+        const onAbort = () => child.kill("SIGTERM");
+        if (abortSignal) {
+          if (abortSignal.aborted) {
+            child.kill("SIGTERM");
+            controller.error(abortSignal.reason ?? new Error("Request aborted"));
+            return;
+          }
+          abortSignal.addEventListener("abort", onAbort, { once: true });
+        }
+        child.stderr.on("data", (d) => stderr += String(d));
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+          const lines = chunk.split(/\r?\n/).filter(Boolean);
+          for (const line of lines) {
+            const event = parseStreamJsonLine(line);
+            if (!event) continue;
+            model.logger.debug(`[gemini-cli] Stream event: ${event.type}`);
+            if (isInitEvent(event)) {
+              model.sessionId = event.session_id;
+              controller.enqueue({
+                type: "response-metadata",
+                id: crypto.randomUUID(),
+                timestamp: /* @__PURE__ */ new Date(),
+                modelId: event.model ?? model.modelId
+              });
+              continue;
+            }
+            if (isMessageEvent(event) && event.role === "assistant" && event.content) {
+              if (!textId) {
+                textId = crypto.randomUUID();
+                controller.enqueue({ type: "text-start", id: textId });
+              }
+              controller.enqueue({
+                type: "text-delta",
+                id: textId,
+                delta: event.content
+              });
+              continue;
+            }
+            if (isToolUseEvent(event)) {
+              toolResults.set(event.tool_id, { toolName: event.tool_name });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: event.tool_id,
+                toolName: event.tool_name,
+                input: JSON.stringify(event.parameters),
+                providerExecuted: true
+              });
+              continue;
+            }
+            if (isToolResultEvent(event)) {
+              const toolInfo = toolResults.get(event.tool_id);
+              controller.enqueue({
+                type: "tool-result",
+                toolCallId: event.tool_id,
+                toolName: toolInfo?.toolName ?? "unknown",
+                result: event.output,
+                isError: event.status === "error"
+              });
+              continue;
+            }
+            if (isResultEvent(event)) {
+              if (event.stats) {
+                lastUsage = convertStatsToUsage(event.stats);
+              }
+              lastStatus = event.status;
+              continue;
+            }
+            if (isErrorEvent(event)) {
+              controller.error(
+                createAPICallError({
+                  message: event.error,
+                  stderr,
+                  promptExcerpt
+                })
+              );
+              return;
+            }
+          }
+        });
+        child.on("error", (e) => {
+          model.logger.error(`[gemini-cli] Stream spawn error: ${String(e)}`);
+          if (abortSignal) {
+            abortSignal.removeEventListener("abort", onAbort);
+          }
+          controller.error(model.handleSpawnError(e, promptExcerpt));
+        });
+        child.on("close", (code) => {
+          const duration = Date.now() - startTime;
+          if (abortSignal) {
+            abortSignal.removeEventListener("abort", onAbort);
+          }
+          if (textId) {
+            controller.enqueue({ type: "text-end", id: textId });
+          }
+          if (code === 0) {
+            model.logger.info(`[gemini-cli] Stream completed in ${duration}ms`);
+            controller.enqueue({
+              type: "finish",
+              finishReason: mapGeminiFinishReason(lastStatus),
+              usage: lastUsage ?? createEmptyUsage()
+            });
+            controller.close();
+          } else {
+            model.logger.error(`[gemini-cli] Stream exited with code ${code}`);
+            controller.error(
+              createAPICallError({
+                message: `Gemini CLI exited with code ${code}`,
+                exitCode: code ?? void 0,
+                stderr,
+                promptExcerpt
+              })
+            );
+          }
+        });
+      },
+      cancel() {
+      }
+    });
+    return { stream, request: { body: promptText } };
+  }
+};
+var loggerFunctionSchema = zod.z.object({
+  debug: zod.z.function(),
+  info: zod.z.function(),
+  warn: zod.z.function(),
+  error: zod.z.function()
+});
+var settingsSchema = zod.z.object({
+  geminiPath: zod.z.string().optional(),
+  cwd: zod.z.string().optional(),
+  includeDirectories: zod.z.array(zod.z.string().min(1)).optional(),
+  approvalMode: zod.z.enum(["default", "auto_edit", "yolo"]).optional(),
+  yolo: zod.z.boolean().optional(),
+  sandbox: zod.z.boolean().optional(),
+  allowedTools: zod.z.array(zod.z.string().min(1)).optional(),
+  allowedMcpServerNames: zod.z.array(zod.z.string().min(1)).optional(),
+  resume: zod.z.union([zod.z.string(), zod.z.boolean()]).optional(),
+  model: zod.z.string().optional(),
+  env: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  verbose: zod.z.boolean().optional(),
+  logger: zod.z.union([zod.z.literal(false), loggerFunctionSchema]).optional()
+}).strict();
+function validateSettings(settings) {
+  const warnings = [];
+  const errors = [];
+  const result = settingsSchema.safeParse(settings);
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      const path = issue.path.join(".");
+      errors.push(`${path}: ${issue.message}`);
+    }
+    return { valid: false, warnings, errors };
+  }
+  const s = settings;
+  if (s.yolo && s.approvalMode && s.approvalMode !== "yolo") {
+    warnings.push("Both yolo and approvalMode are set. yolo takes precedence.");
+  }
+  return { valid: true, warnings, errors };
+}
+function validateModelId(modelId) {
+  if (!modelId || modelId.trim() === "") {
+    return "Model ID cannot be empty";
+  }
+  return void 0;
+}
+
+// src/gemini-cli-provider.ts
+function createGeminiCli(options = {}) {
+  const logger = getLogger(options.defaultSettings?.logger);
+  if (options.defaultSettings) {
+    const v = validateSettings(options.defaultSettings);
+    if (!v.valid) {
+      throw new Error(`Invalid default settings: ${v.errors.join(", ")}`);
+    }
+    for (const w of v.warnings) logger.warn(`Gemini CLI Provider: ${w}`);
+  }
+  const createModel = (modelId, settings = {}) => {
+    const merged = { ...options.defaultSettings, ...settings };
+    const v = validateSettings(merged);
+    if (!v.valid) throw new Error(`Invalid settings: ${v.errors.join(", ")}`);
+    for (const w of v.warnings) logger.warn(`Gemini CLI: ${w}`);
+    return new GeminiCliLanguageModel({ id: modelId, settings: merged });
+  };
+  const provider$1 = function(modelId, settings) {
+    if (new.target) throw new Error("The Gemini CLI provider function cannot be called with new.");
+    return createModel(modelId, settings);
+  };
+  provider$1.languageModel = createModel;
+  provider$1.chat = createModel;
+  provider$1.embeddingModel = ((modelId) => {
+    throw new provider.NoSuchModelError({ modelId, modelType: "embeddingModel" });
+  });
+  provider$1.imageModel = ((modelId) => {
+    throw new provider.NoSuchModelError({ modelId, modelType: "imageModel" });
+  });
+  return provider$1;
+}
+var geminiCli = createGeminiCli();
+
+exports.GeminiCliLanguageModel = GeminiCliLanguageModel;
+exports.createAPICallError = createAPICallError;
+exports.createAuthenticationError = createAuthenticationError;
+exports.createGeminiCli = createGeminiCli;
+exports.geminiCli = geminiCli;
+exports.isAuthenticationError = isAuthenticationError;
+exports.validateModelId = validateModelId;
+exports.validateSettings = validateSettings;