@kenkaiiii/gg-ai 4.3.201 → 4.3.203

package/dist/index.cjs

@@ -78,6 +78,7 @@ var ProviderError = class extends GGAIError {
 var PROVIDER_DISPLAY = {
   openai: "OpenAI",
   anthropic: "Anthropic",
+  gemini: "Gemini",
   glm: "Z.AI (GLM)",
   moonshot: "Moonshot",
   deepseek: "DeepSeek",
@@ -1975,6 +1976,449 @@ function parseCodexErrorBody(text) {
   }
 }
 
+// src/providers/gemini.ts
+var DEFAULT_CODE_ASSIST_BASE_URL = "https://cloudcode-pa.googleapis.com";
+var CODE_ASSIST_API_VERSION = "v1internal";
+var GEMINI_CLI_USER_AGENT = "google-gemini-cli";
+var GEMINI_CLI_API_CLIENT = "gemini-cli/0.0.0";
+var SYNTHETIC_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+var CODE_ASSIST_SUPPORTED_MODELS = /* @__PURE__ */ new Set([
+  "gemini-3-pro-preview",
+  "gemini-3.1-pro-preview",
+  "gemini-3.1-pro-preview-customtools",
+  "gemini-3-flash-preview",
+  "gemini-3.1-flash-lite-preview",
+  "gemini-2.5-pro",
+  "gemini-2.5-flash",
+  "gemini-2.5-flash-lite",
+  "gemma-4-31b-it",
+  "gemma-4-26b-a4b-it"
+]);
+function isJsonObject4(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function getEnvironment() {
+  return globalThis.process?.env;
+}
+function getGoogleProject(options) {
+  const env = getEnvironment();
+  return options.projectId ?? env?.GOOGLE_CLOUD_PROJECT ?? env?.GOOGLE_CLOUD_PROJECT_ID;
+}
+function getCodeAssistEndpoint(method) {
+  return new URL(`${DEFAULT_CODE_ASSIST_BASE_URL}/${CODE_ASSIST_API_VERSION}:${method}`);
+}
+function formatUnsupportedModelMessage(model) {
+  return `Gemini OAuth is configured to use the Gemini Code Assist subscription endpoint only. That endpoint does not currently expose model "${model}".`;
+}
+function formatErrorMessage(status, body, model) {
+  if (status === 404 && !CODE_ASSIST_SUPPORTED_MODELS.has(model)) {
+    return `Gemini API error (404): ${body}
+
+${formatUnsupportedModelMessage(model)}`;
+  }
+  return `Gemini API error (${status}): ${body}`;
+}
+function toSystemAndContents(messages) {
+  let systemText = "";
+  const contents = [];
+  const toolNamesById = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      systemText = systemText ? `${systemText}
+
+${msg.content}` : msg.content;
+      continue;
+    }
+    if (msg.role === "user") {
+      contents.push({
+        role: "user",
+        parts: typeof msg.content === "string" ? [{ text: msg.content }] : msg.content.map((part) => {
+          if (part.type === "text") return { text: part.text };
+          return { inlineData: { mimeType: part.mediaType, data: part.data } };
+        })
+      });
+      continue;
+    }
+    if (msg.role === "assistant") {
+      const parts = [];
+      const source = msg.content;
+      if (typeof source === "string") {
+        if (source) parts.push({ text: source });
+      } else {
+        for (const part of source) {
+          if (part.type === "text" && part.text) {
+            parts.push({ text: part.text });
+          } else if (part.type === "thinking" && part.text) {
+            parts.push({ text: part.text });
+          } else if (part.type === "tool_call") {
+            toolNamesById.set(part.id, part.name);
+            parts.push({
+              functionCall: { id: part.id, name: part.name, args: part.args },
+              thoughtSignature: SYNTHETIC_THOUGHT_SIGNATURE
+            });
+          }
+        }
+      }
+      if (parts.length > 0) contents.push({ role: "model", parts });
+      continue;
+    }
+    if (msg.role === "tool") {
+      const parts = [];
+      for (const result of msg.content) {
+        const name = toolNamesById.get(result.toolCallId) ?? result.toolCallId;
+        const content = typeof result.content === "string" ? result.content : stringifyToolContent(result.content);
+        parts.push({
+          functionResponse: {
+            id: result.toolCallId,
+            name,
+            response: {
+              content,
+              ...result.isError ? { isError: true } : {}
+            }
+          }
+        });
+      }
+      if (parts.length > 0) contents.push({ role: "user", parts });
+    }
+  }
+  return {
+    ...systemText ? { systemInstruction: { parts: [{ text: systemText }] } } : {},
+    contents
+  };
+}
+function stringifyToolContent(content) {
+  return content.map((part) => part.type === "text" ? part.text : `[image ${part.mediaType}]`).join("\n");
+}
+function toGeminiTools(tools) {
+  if (!tools?.length) return void 0;
+  return [
+    {
+      functionDeclarations: tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: sanitizeSchema(tool.rawInputSchema ?? zodToJsonSchema(tool.parameters))
+      }))
+    }
+  ];
+}
+function sanitizeSchema(schema) {
+  const clone = JSON.parse(JSON.stringify(schema));
+  stripUnsupportedSchemaFields(clone);
+  return clone;
+}
+function stripUnsupportedSchemaFields(value) {
+  if (!isJsonObject4(value)) {
+    if (Array.isArray(value)) {
+      for (const item of value) stripUnsupportedSchemaFields(item);
+    }
+    return;
+  }
+  delete value.$schema;
+  delete value.additionalProperties;
+  for (const item of Object.values(value)) {
+    if (isJsonObject4(item) || Array.isArray(item)) {
+      stripUnsupportedSchemaFields(item);
+    }
+  }
+}
+function toGeminiToolConfig(choice, tools) {
+  if (!choice || !tools?.length) return void 0;
+  if (choice === "auto") return { functionCallingConfig: { mode: "AUTO" } };
+  if (choice === "none") return { functionCallingConfig: { mode: "NONE" } };
+  if (choice === "required") return { functionCallingConfig: { mode: "ANY" } };
+  return { functionCallingConfig: { mode: "ANY", allowedFunctionNames: [choice.name] } };
+}
+function isGemini3Model(model) {
+  return /^gemini-3(?:\.|-|$)/.test(model);
+}
+function toGemini3ThinkingLevel(level) {
+  switch (level) {
+    case "low":
+      return "LOW";
+    case "medium":
+      return "MEDIUM";
+    case "high":
+    case "xhigh":
+      return "HIGH";
+  }
+}
+function toThinkingBudget(level) {
+  switch (level) {
+    case "low":
+      return 1024;
+    case "medium":
+      return 8192;
+    case "high":
+    case "xhigh":
+      return 8192;
+  }
+}
+function toThinkingConfig(model, level) {
+  if (!level) return void 0;
+  if (isGemini3Model(model)) {
+    return {
+      includeThoughts: true,
+      thinkingLevel: toGemini3ThinkingLevel(level)
+    };
+  }
+  return {
+    includeThoughts: true,
+    thinkingBudget: toThinkingBudget(level)
+  };
+}
+function buildGenerateRequest(options) {
+  const downgradedMessages = downgradeUnsupportedImages(options.messages, options.supportsImages);
+  const { systemInstruction, contents } = toSystemAndContents(downgradedMessages);
+  const tools = toGeminiTools(options.tools);
+  const toolConfig = toGeminiToolConfig(options.toolChoice, options.tools);
+  const thinkingConfig = toThinkingConfig(options.model, options.thinking);
+  const generationConfig = {
+    ...options.maxTokens ? { maxOutputTokens: options.maxTokens } : {},
+    ...options.temperature != null && !options.thinking ? { temperature: options.temperature } : {},
+    ...options.topP != null ? { topP: options.topP } : {},
+    ...options.stop ? { stopSequences: options.stop } : {},
+    ...thinkingConfig ? { thinkingConfig } : {}
+  };
+  return {
+    contents,
+    ...systemInstruction ? { systemInstruction } : {},
+    ...tools ? { tools } : {},
+    ...toolConfig ? { toolConfig } : {},
+    ...Object.keys(generationConfig).length > 0 ? { generationConfig } : {}
+  };
+}
+function buildCodeAssistRequest(options, request, projectId) {
+  return {
+    model: options.model,
+    ...projectId ? { project: projectId } : {},
+    user_prompt_id: crypto.randomUUID(),
+    request
+  };
+}
+function buildRequestPlan(options, method) {
+  if (!CODE_ASSIST_SUPPORTED_MODELS.has(options.model)) {
+    throw new ProviderError("gemini", formatUnsupportedModelMessage(options.model));
+  }
+  const projectId = getGoogleProject(options);
+  const request = buildGenerateRequest(options);
+  return {
+    url: getCodeAssistEndpoint(method),
+    headers: {
+      Authorization: `Bearer ${options.apiKey}`,
+      "Content-Type": "application/json",
+      "User-Agent": GEMINI_CLI_USER_AGENT,
+      "X-Goog-Api-Client": GEMINI_CLI_API_CLIENT
+    },
+    body: buildCodeAssistRequest(options, request, projectId)
+  };
+}
+function normalizeGeminiStopReason(reason) {
+  switch (reason) {
+    case "MAX_TOKENS":
+      return "max_tokens";
+    case "STOP":
+      return "stop_sequence";
+    case "SAFETY":
+    case "RECITATION":
+    case "BLOCKLIST":
+    case "PROHIBITED_CONTENT":
+    case "SPII":
+      return "refusal";
+    default:
+      return "end_turn";
+  }
+}
+function parseSseEvents(buffer) {
+  const events = [];
+  let cursor = 0;
+  while (true) {
+    const next = buffer.indexOf("\n\n", cursor);
+    if (next === -1) break;
+    const raw = buffer.slice(cursor, next);
+    cursor = next + 2;
+    let eventName;
+    const dataLines = [];
+    for (const line of raw.split("\n")) {
+      if (line.startsWith("event:")) {
+        eventName = line.slice("event:".length).trim();
+      } else if (line.startsWith("data:")) {
+        dataLines.push(line.slice("data:".length).trimStart());
+      }
+    }
+    if (dataLines.length > 0) {
+      events.push({ event: eventName, data: dataLines.join("\n") });
+    }
+  }
+  return { events, remaining: buffer.slice(cursor) };
+}
+async function* streamSse(response) {
+  if (!response.body) return;
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
+      const parsed2 = parseSseEvents(buffer);
+      buffer = parsed2.remaining;
+      for (const event of parsed2.events) {
+        if (event.data === "[DONE]") continue;
+        yield JSON.parse(event.data);
+      }
+    }
+    buffer += decoder.decode().replace(/\r\n/g, "\n");
+    const parsed = parseSseEvents(buffer + "\n\n");
+    for (const event of parsed.events) {
+      if (event.data === "[DONE]") continue;
+      yield JSON.parse(event.data);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function candidatesFromResponse(response) {
+  return response.response?.candidates ?? response.candidates;
+}
+function usageFromResponse(response) {
+  return response.response?.usageMetadata ?? response.usageMetadata;
+}
+function partsFromResponse(response) {
+  return candidatesFromResponse(response)?.[0]?.content?.parts ?? [];
+}
+function finishReasonFromResponse(response) {
+  return candidatesFromResponse(response)?.[0]?.finishReason;
+}
+function readTextPart(part) {
+  return "text" in part ? { text: part.text, thought: part.thought === true } : void 0;
+}
+function readFunctionCallPart(part) {
+  if (!("functionCall" in part)) return void 0;
+  return {
+    ...part.functionCall.id ? { id: part.functionCall.id } : {},
+    name: part.functionCall.name,
+    args: isJsonObject4(part.functionCall.args) ? part.functionCall.args : {}
+  };
+}
+function makeToolCallId(index, providerId) {
+  return providerId ?? `gemini_call_${index}_${crypto.randomUUID().replace(/-/g, "")}`;
+}
+function streamGemini(options) {
+  return new StreamResult(runStream4(options));
+}
+async function* runStream4(options) {
+  const useStreaming = options.streaming !== false;
+  const method = useStreaming ? "streamGenerateContent" : "generateContent";
+  const plan = buildRequestPlan(options, method);
+  if (useStreaming) plan.url.searchParams.set("alt", "sse");
+  let response;
+  try {
+    response = await fetch(plan.url, {
+      method: "POST",
+      headers: plan.headers,
+      body: JSON.stringify(plan.body),
+      signal: options.signal
+    });
+  } catch (err) {
+    throw toError3(err);
+  }
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new ProviderError("gemini", formatErrorMessage(response.status, text, options.model), {
+      statusCode: response.status
+    });
+  }
+  const contentParts = [];
+  const pendingToolCalls = [];
+  let textAccum = "";
+  let thinkingAccum = "";
+  let stopReason = "end_turn";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheRead = 0;
+  let toolIndex = 0;
+  const handleResponse = function* (chunk) {
+    const usage = usageFromResponse(chunk);
+    if (usage) {
+      inputTokens = usage.promptTokenCount ?? inputTokens;
+      outputTokens = usage.candidatesTokenCount ?? outputTokens;
+      cacheRead = usage.cachedContentTokenCount ?? cacheRead;
+    }
+    const reason = finishReasonFromResponse(chunk);
+    if (reason) stopReason = normalizeGeminiStopReason(reason);
+    for (const part of partsFromResponse(chunk)) {
+      const textPart = readTextPart(part);
+      if (textPart) {
+        if (textPart.thought) {
+          thinkingAccum += textPart.text;
+          yield { type: "thinking_delta", text: textPart.text };
+        } else {
+          textAccum += textPart.text;
+          yield { type: "text_delta", text: textPart.text };
+        }
+        continue;
+      }
+      const functionCall = readFunctionCallPart(part);
+      if (functionCall) {
+        const id = makeToolCallId(toolIndex++, functionCall.id);
+        const argsJson = JSON.stringify(functionCall.args);
+        pendingToolCalls.push({
+          type: "tool_call",
+          id,
+          name: functionCall.name,
+          args: functionCall.args
+        });
+        yield { type: "toolcall_delta", id, name: functionCall.name, argsJson };
+      }
+    }
+  };
+  try {
+    if (useStreaming) {
+      for await (const chunk of streamSse(response)) {
+        yield* handleResponse(chunk);
+      }
+    } else {
+      const chunk = await response.json();
+      yield* handleResponse(chunk);
+    }
+  } catch (err) {
+    throw toError3(err);
+  }
+  if (thinkingAccum) contentParts.push({ type: "thinking", text: thinkingAccum });
+  if (textAccum) contentParts.push({ type: "text", text: textAccum });
+  for (const toolCall of pendingToolCalls) {
+    contentParts.push(toolCall);
+    yield {
+      type: "toolcall_done",
+      id: toolCall.id,
+      name: toolCall.name,
+      args: toolCall.args
+    };
+  }
+  if (pendingToolCalls.length > 0) stopReason = "tool_use";
+  const adjustedInputTokens = Math.max(0, inputTokens - cacheRead);
+  const streamResponse = {
+    message: {
+      role: "assistant",
+      content: contentParts.length > 0 ? contentParts : textAccum
+    },
+    stopReason,
+    usage: {
+      inputTokens: adjustedInputTokens,
+      outputTokens,
+      ...cacheRead > 0 ? { cacheRead } : {}
+    }
+  };
+  yield { type: "done", stopReason };
+  return streamResponse;
+}
+function toError3(err) {
+  if (err instanceof ProviderError) return err;
+  if (err instanceof Error) return new ProviderError("gemini", err.message, { cause: err });
+  return new ProviderError("gemini", String(err));
+}
+
 // src/provider-registry.ts
 var ProviderRegistryImpl = class {
   providers = /* @__PURE__ */ new Map();
@@ -2031,6 +2475,9 @@ providerRegistry.register("openai", {
     return streamOpenAI(options);
   }
 });
+providerRegistry.register("gemini", {
+  stream: (options) => streamGemini(options)
+});
 providerRegistry.register("glm", {
   stream: (options) => streamOpenAI({
     ...options,