@redscope-ai/redscope 1.0.0

package/dist/chunk-2p369q9z.js

@@ -0,0 +1,61 @@
+// @bun
+import {
+  getClaudeAIOAuthTokens,
+  init_auth
+} from "./chunk-eemjb825.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-qfsn720k.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-s3hafnk3.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/bridge/bridgeEnv.ts
+function getRedScopeEnvWithLegacy(primaryName, legacyName) {
+  return process.env[primaryName] || process.env[legacyName] || undefined;
+}
+function getBridgeBaseUrlOverrideEnv() {
+  return getRedScopeEnvWithLegacy(REDSCOPE_BRIDGE_BASE_URL_ENV, LEGACY_BRIDGE_BASE_URL_ENV);
+}
+function getBridgeTokenOverrideEnv() {
+  return getRedScopeEnvWithLegacy(REDSCOPE_BRIDGE_OAUTH_TOKEN_ENV, LEGACY_BRIDGE_OAUTH_TOKEN_ENV);
+}
+function getBridgeSessionIngressUrl(baseUrl) {
+  return getRedScopeEnvWithLegacy(REDSCOPE_BRIDGE_SESSION_INGRESS_URL_ENV, LEGACY_BRIDGE_SESSION_INGRESS_URL_ENV) ?? baseUrl;
+}
+function isBridgeCcrV2OverrideEnabled() {
+  return isEnvTruthy(process.env[REDSCOPE_BRIDGE_USE_CCR_V2_ENV]) || isEnvTruthy(process.env[LEGACY_BRIDGE_USE_CCR_V2_ENV]);
+}
+var REDSCOPE_BRIDGE_BASE_URL_ENV = "REDSCOPE_BRIDGE_BASE_URL", LEGACY_BRIDGE_BASE_URL_ENV = "CLAUDE_BRIDGE_BASE_URL", REDSCOPE_BRIDGE_OAUTH_TOKEN_ENV = "REDSCOPE_BRIDGE_OAUTH_TOKEN", LEGACY_BRIDGE_OAUTH_TOKEN_ENV = "CLAUDE_BRIDGE_OAUTH_TOKEN", REDSCOPE_BRIDGE_SESSION_INGRESS_URL_ENV = "REDSCOPE_BRIDGE_SESSION_INGRESS_URL", LEGACY_BRIDGE_SESSION_INGRESS_URL_ENV = "CLAUDE_BRIDGE_SESSION_INGRESS_URL", REDSCOPE_BRIDGE_USE_CCR_V2_ENV = "REDSCOPE_BRIDGE_USE_CCR_V2", LEGACY_BRIDGE_USE_CCR_V2_ENV = "CLAUDE_BRIDGE_USE_CCR_V2";
+var init_bridgeEnv = __esm(() => {
+  init_envUtils();
+});
+
+// src/bridge/bridgeConfig.ts
+function getBridgeTokenOverride() {
+  return getBridgeTokenOverrideEnv();
+}
+function getBridgeBaseUrlOverride() {
+  return getBridgeBaseUrlOverrideEnv();
+}
+function getBridgeAccessToken() {
+  return getBridgeTokenOverride() ?? getClaudeAIOAuthTokens()?.accessToken;
+}
+function getBridgeBaseUrl() {
+  return getBridgeBaseUrlOverride() ?? getOauthConfig().BASE_API_URL;
+}
+function isSelfHostedBridge() {
+  return !!getBridgeBaseUrlOverride();
+}
+var init_bridgeConfig = __esm(() => {
+  init_oauth();
+  init_auth();
+  init_bridgeEnv();
+});
+
+export { getBridgeSessionIngressUrl, isBridgeCcrV2OverrideEnabled, init_bridgeEnv, getBridgeTokenOverride, getBridgeBaseUrlOverride, getBridgeAccessToken, getBridgeBaseUrl, isSelfHostedBridge, init_bridgeConfig };

package/dist/chunk-2rf6asgf.js

@@ -0,0 +1,151 @@
+// @bun
+import {
+  init_useTerminalSize
+} from "./chunk-gmdy2w3z.js";
+import {
+  init_format,
+  truncatePathMiddle,
+  truncateToWidth
+} from "./chunk-q1vrhh0q.js";
+import {
+  ThemedBox_default,
+  ThemedText,
+  init_src,
+  stringWidth,
+  useTerminalSize
+} from "./chunk-2g0ytd9d.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-de0qnnf7.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/components/PromptInput/PromptInputFooterSuggestions.tsx
+function getIcon(itemId) {
+  if (itemId.startsWith("file-"))
+    return "+";
+  if (itemId.startsWith("mcp-resource-"))
+    return "\u25C7";
+  if (itemId.startsWith("agent-"))
+    return "*";
+  return "+";
+}
+function isUnifiedSuggestion(itemId) {
+  return itemId.startsWith("file-") || itemId.startsWith("mcp-resource-") || itemId.startsWith("agent-");
+}
+function PromptInputFooterSuggestions({
+  suggestions,
+  selectedSuggestion,
+  maxColumnWidth: maxColumnWidthProp,
+  overlay
+}) {
+  const { rows } = useTerminalSize();
+  const maxVisibleItems = overlay ? OVERLAY_MAX_ITEMS : Math.min(6, Math.max(1, rows - 3));
+  if (suggestions.length === 0) {
+    return null;
+  }
+  const maxColumnWidth = maxColumnWidthProp ?? Math.max(...suggestions.map((item) => stringWidth(item.displayText))) + 5;
+  const startIndex = Math.max(0, Math.min(selectedSuggestion - Math.floor(maxVisibleItems / 2), suggestions.length - maxVisibleItems));
+  const endIndex = Math.min(startIndex + maxVisibleItems, suggestions.length);
+  const visibleItems = suggestions.slice(startIndex, endIndex);
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+    flexDirection: "column",
+    justifyContent: overlay ? undefined : "flex-end",
+    children: visibleItems.map((item) => /* @__PURE__ */ jsx_dev_runtime.jsxDEV(SuggestionItemRow, {
+      item,
+      maxColumnWidth,
+      isSelected: item.id === suggestions[selectedSuggestion]?.id
+    }, item.id, false, undefined, this))
+  }, undefined, false, undefined, this);
+}
+var import_react, jsx_dev_runtime, OVERLAY_MAX_ITEMS = 5, SuggestionItemRow, PromptInputFooterSuggestions_default;
+var init_PromptInputFooterSuggestions = __esm(() => {
+  init_useTerminalSize();
+  init_src();
+  init_format();
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+  SuggestionItemRow = import_react.memo(function SuggestionItemRow2({
+    item,
+    maxColumnWidth,
+    isSelected
+  }) {
+    const columns = useTerminalSize().columns;
+    const isUnified = isUnifiedSuggestion(item.id);
+    if (isUnified) {
+      const icon = getIcon(item.id);
+      const textColor2 = isSelected ? "suggestion" : undefined;
+      const dimColor = !isSelected;
+      const isFile = item.id.startsWith("file-");
+      const isMcpResource = item.id.startsWith("mcp-resource-");
+      const iconWidth = 2;
+      const paddingWidth = 4;
+      const separatorWidth = item.description ? 3 : 0;
+      let displayText2;
+      if (isFile) {
+        const descReserve = item.description ? Math.min(20, stringWidth(item.description)) : 0;
+        const maxPathLength = columns - iconWidth - paddingWidth - separatorWidth - descReserve;
+        displayText2 = truncatePathMiddle(item.displayText, maxPathLength);
+      } else if (isMcpResource) {
+        const maxDisplayTextLength = 30;
+        displayText2 = truncateToWidth(item.displayText, maxDisplayTextLength);
+      } else {
+        displayText2 = item.displayText;
+      }
+      const availableWidth = columns - iconWidth - stringWidth(displayText2) - separatorWidth - paddingWidth;
+      let lineContent;
+      if (item.description) {
+        const maxDescLength = Math.max(0, availableWidth);
+        const truncatedDesc = truncateToWidth(item.description.replace(/\s+/g, " "), maxDescLength);
+        lineContent = `${icon} ${displayText2} \u2013 ${truncatedDesc}`;
+      } else {
+        lineContent = `${icon} ${displayText2}`;
+      }
+      return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        color: textColor2,
+        dimColor,
+        wrap: "truncate",
+        children: lineContent
+      }, undefined, false, undefined, this);
+    }
+    const maxNameWidth = Math.floor(columns * 0.4);
+    const displayTextWidth = Math.min(maxColumnWidth ?? stringWidth(item.displayText) + 5, maxNameWidth);
+    const textColor = item.color || (isSelected ? "suggestion" : undefined);
+    const shouldDim = !isSelected;
+    let displayText = item.displayText;
+    if (stringWidth(displayText) > displayTextWidth - 2) {
+      displayText = truncateToWidth(displayText, displayTextWidth - 2);
+    }
+    const paddedDisplayText = displayText + " ".repeat(Math.max(0, displayTextWidth - stringWidth(displayText)));
+    const tagText = item.tag ? `[${item.tag}] ` : "";
+    const tagWidth = stringWidth(tagText);
+    const descriptionWidth = Math.max(0, columns - displayTextWidth - tagWidth - 4);
+    const truncatedDescription = item.description ? truncateToWidth(item.description.replace(/\s+/g, " "), descriptionWidth) : "";
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      wrap: "truncate",
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          color: textColor,
+          dimColor: shouldDim,
+          children: paddedDisplayText
+        }, undefined, false, undefined, this),
+        tagText ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          color: item.tag === "local" ? "ansi:yellow" : undefined,
+          dimColor: item.tag !== "local",
+          children: tagText
+        }, undefined, false, undefined, this) : null,
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          color: isSelected ? "suggestion" : undefined,
+          dimColor: !isSelected,
+          children: truncatedDescription
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  });
+  PromptInputFooterSuggestions_default = import_react.memo(PromptInputFooterSuggestions);
+});
+
+export { PromptInputFooterSuggestions, PromptInputFooterSuggestions_default, init_PromptInputFooterSuggestions };

package/dist/chunk-2vr7mqx1.js

@@ -0,0 +1,384 @@
+// @bun
+import {
+  init_SSETransport,
+  parseSSEFrames
+} from "./chunk-87ms17f6.js";
+import {
+  convertMessagesToLangfuse,
+  convertOutputToLangfuse,
+  convertToolsToLangfuse,
+  createAssistantAPIErrorMessage,
+  init_api,
+  init_convert,
+  init_messages1 as init_messages,
+  init_tracing,
+  normalizeContentFromAPI,
+  normalizeMessagesForAPI,
+  recordLLMObservation,
+  toolToAPISchema
+} from "./chunk-gmdy2w3z.js";
+import"./chunk-q0e485mg.js";
+import"./chunk-2kcgxnvp.js";
+import"./chunk-14p6wvsq.js";
+import"./chunk-6s0q1s5r.js";
+import"./chunk-3w9sye8h.js";
+import {
+  GEMINI_THOUGHT_SIGNATURE_FIELD,
+  adaptGeminiStreamToAnthropic,
+  anthropicMessagesToGemini,
+  anthropicToolChoiceToGemini,
+  anthropicToolsToGemini,
+  init_src,
+  resolveGeminiModel
+} from "./chunk-nzxfj0gq.js";
+import"./chunk-vr0n9pv9.js";
+import"./chunk-9a9g5hbj.js";
+import"./chunk-ptxteaeh.js";
+import"./chunk-w4p5t920.js";
+import"./chunk-rgyzsbs3.js";
+import"./chunk-q3b4n194.js";
+import"./chunk-kywtr3jg.js";
+import"./chunk-eewg66y1.js";
+import"./chunk-71sdcaq6.js";
+import"./chunk-9hn8e6h1.js";
+import"./chunk-7qey87th.js";
+import"./chunk-zw62m6n3.js";
+import"./chunk-1w20m7gw.js";
+import"./chunk-zzf074w3.js";
+import"./chunk-rpmntgyh.js";
+import"./chunk-24kv69g3.js";
+import"./chunk-hzxzvzw8.js";
+import"./chunk-30wnahyg.js";
+import"./chunk-ztmb7geg.js";
+import"./chunk-tbdkekz3.js";
+import"./chunk-65zbgg1n.js";
+import"./chunk-4spgkgr3.js";
+import"./chunk-60fkafk2.js";
+import"./chunk-50m3a23z.js";
+import"./chunk-6hygvrhn.js";
+import"./chunk-7tfdhkpy.js";
+import"./chunk-8gv2pjby.js";
+import"./chunk-g06pm4n9.js";
+import"./chunk-2p369q9z.js";
+import"./chunk-z0jgeax8.js";
+import"./chunk-w68wc625.js";
+import"./chunk-6hr7742d.js";
+import"./chunk-xyg1sk2w.js";
+import"./chunk-935nrvdb.js";
+import"./chunk-8zz4z1q3.js";
+import"./chunk-fncpkzs5.js";
+import"./chunk-hqxp6b72.js";
+import"./chunk-m2c3bjv1.js";
+import"./chunk-jhtccjc9.js";
+import"./chunk-7nvday0n.js";
+import"./chunk-vxbjzggp.js";
+import"./chunk-yc1stfve.js";
+import"./chunk-8yvsnrkr.js";
+import"./chunk-5mmhfbxb.js";
+import"./chunk-eemjb825.js";
+import"./chunk-ga1jkyqy.js";
+import"./chunk-y1q7rt9n.js";
+import {
+  getProxyFetchOptions,
+  init_proxy
+} from "./chunk-8kct9arg.js";
+import"./chunk-k7hexw3v.js";
+import"./chunk-trqrj23e.js";
+import"./chunk-za3k6h2h.js";
+import"./chunk-8kf8h7xf.js";
+import"./chunk-bgan4cpf.js";
+import"./chunk-jmv7k0jn.js";
+import"./chunk-hjxqmtg5.js";
+import"./chunk-bzyzrq0k.js";
+import"./chunk-vwenx8ke.js";
+import"./chunk-q2h79ncs.js";
+import"./chunk-v4ypszbb.js";
+import"./chunk-qfsn720k.js";
+import"./chunk-7qx3xhv3.js";
+import"./chunk-j9475b46.js";
+import"./chunk-fdwabr8p.js";
+import"./chunk-e4dsy4g1.js";
+import"./chunk-326zehp8.js";
+import"./chunk-kc67kt75.js";
+import"./chunk-40t1d75v.js";
+import"./chunk-dbts5q5p.js";
+import"./chunk-e3abfxpy.js";
+import"./chunk-q44zc68f.js";
+import"./chunk-fejeqe61.js";
+import"./chunk-q1vrhh0q.js";
+import"./chunk-hn4w9pkj.js";
+import"./chunk-2g0ytd9d.js";
+import"./chunk-de0qnnf7.js";
+import"./chunk-j1mep9ck.js";
+import"./chunk-6x35ffpx.js";
+import"./chunk-1zbwhcbt.js";
+import"./chunk-92bjkrf2.js";
+import"./chunk-10k5jfc5.js";
+import"./chunk-n9g24mwe.js";
+import"./chunk-e3j7m7k2.js";
+import"./chunk-hzmzwte2.js";
+import"./chunk-pdvg91cg.js";
+import"./chunk-c696122m.js";
+import"./chunk-xbj5keyy.js";
+import"./chunk-c1yc761e.js";
+import"./chunk-c5g9shkw.js";
+import"./chunk-aeysytks.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  logForDebugging
+} from "./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import"./chunk-pecy49yr.js";
+import"./chunk-azbab59e.js";
+import"./chunk-3nk9q8dr.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/services/api/gemini/client.ts
+function getGeminiBaseUrl() {
+  return (process.env.GEMINI_BASE_URL || DEFAULT_GEMINI_BASE_URL).replace(/\/+$/, "");
+}
+function getGeminiModelPath(model) {
+  const normalized = model.replace(/^\/+/, "");
+  return normalized.startsWith("models/") ? normalized : `models/${normalized}`;
+}
+async function* streamGeminiGenerateContent(params) {
+  const fetchImpl = params.fetchOverride ?? fetch;
+  const url = `${getGeminiBaseUrl()}/${getGeminiModelPath(params.model)}:streamGenerateContent?alt=sse`;
+  const response = await fetchImpl(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-goog-api-key": process.env.GEMINI_API_KEY || ""
+    },
+    body: JSON.stringify(params.body),
+    signal: params.signal,
+    ...getProxyFetchOptions({ forAnthropicAPI: false })
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Gemini API request failed (${response.status} ${response.statusText}): ${body || "empty response body"}`);
+  }
+  if (!response.body) {
+    throw new Error("Gemini API returned no response body");
+  }
+  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_DECODE_OPTS);
+      const { frames: frames2, remaining } = parseSSEFrames(buffer);
+      buffer = remaining;
+      for (const frame of frames2) {
+        if (!frame.data || frame.data === "[DONE]")
+          continue;
+        try {
+          yield JSON.parse(frame.data);
+        } catch (error) {
+          throw new Error(`Failed to parse Gemini SSE payload: ${errorMessage(error)}`);
+        }
+      }
+    }
+    buffer += decoder.decode();
+    const { frames } = parseSSEFrames(buffer);
+    for (const frame of frames) {
+      if (!frame.data || frame.data === "[DONE]")
+        continue;
+      try {
+        yield JSON.parse(frame.data);
+      } catch (error) {
+        throw new Error(`Failed to parse trailing Gemini SSE payload: ${errorMessage(error)}`);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+var DEFAULT_GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta", STREAM_DECODE_OPTS;
+var init_client = __esm(() => {
+  init_SSETransport();
+  init_errors();
+  init_proxy();
+  STREAM_DECODE_OPTS = { stream: true };
+});
+
+// src/services/api/gemini/index.ts
+import { randomUUID } from "crypto";
+async function* queryModelGemini(messages, systemPrompt, tools, signal, options, thinkingConfig) {
+  try {
+    const geminiModel = resolveGeminiModel(options.model);
+    const messagesForAPI = normalizeMessagesForAPI(messages, tools);
+    const toolSchemas = await Promise.all(tools.map((tool) => toolToAPISchema(tool, {
+      getToolPermissionContext: options.getToolPermissionContext,
+      tools,
+      agents: options.agents,
+      allowedAgentTypes: options.allowedAgentTypes,
+      model: options.model
+    })));
+    const standardTools = toolSchemas.filter((t) => {
+      const anyTool = t;
+      return anyTool.type !== "advisor_20260301" && anyTool.type !== "computer_20250124";
+    });
+    const { contents, systemInstruction } = anthropicMessagesToGemini(messagesForAPI, systemPrompt);
+    const geminiTools = anthropicToolsToGemini(standardTools);
+    const toolChoice = anthropicToolChoiceToGemini(options.toolChoice);
+    const stream = streamGeminiGenerateContent({
+      model: geminiModel,
+      signal,
+      fetchOverride: options.fetchOverride,
+      body: {
+        contents,
+        ...systemInstruction && { systemInstruction },
+        ...geminiTools.length > 0 && { tools: geminiTools },
+        ...toolChoice && {
+          toolConfig: {
+            functionCallingConfig: toolChoice
+          }
+        },
+        generationConfig: {
+          ...options.temperatureOverride !== undefined && {
+            temperature: options.temperatureOverride
+          },
+          ...thinkingConfig.type !== "disabled" && {
+            thinkingConfig: {
+              includeThoughts: true,
+              ...thinkingConfig.type === "enabled" && {
+                thinkingBudget: thinkingConfig.budgetTokens
+              }
+            }
+          }
+        }
+      }
+    });
+    logForDebugging(`[Gemini] Calling model=${geminiModel}, messages=${contents.length}, tools=${geminiTools.length}`);
+    const adaptedStream = adaptGeminiStreamToAnthropic(stream, geminiModel);
+    const contentBlocks = {};
+    const collectedMessages = [];
+    let partialMessage;
+    let ttftMs = 0;
+    const start = Date.now();
+    for await (const event of adaptedStream) {
+      switch (event.type) {
+        case "message_start":
+          partialMessage = event.message;
+          ttftMs = Date.now() - start;
+          break;
+        case "content_block_start": {
+          const idx = event.index;
+          const cb = event.content_block;
+          if (cb.type === "tool_use") {
+            contentBlocks[idx] = { ...cb, input: "" };
+          } else if (cb.type === "text") {
+            contentBlocks[idx] = { ...cb, text: "" };
+          } else if (cb.type === "thinking") {
+            contentBlocks[idx] = { ...cb, thinking: "", signature: "" };
+          } else {
+            contentBlocks[idx] = { ...cb };
+          }
+          break;
+        }
+        case "content_block_delta": {
+          const idx = event.index;
+          const delta = event.delta;
+          const block = contentBlocks[idx];
+          if (!block)
+            break;
+          if (delta.type === "text_delta") {
+            block.text = (block.text || "") + delta.text;
+          } else if (delta.type === "input_json_delta") {
+            block.input = (block.input || "") + delta.partial_json;
+          } else if (delta.type === "thinking_delta") {
+            block.thinking = (block.thinking || "") + delta.thinking;
+          } else if (delta.type === "signature_delta") {
+            if (block.type === "thinking") {
+              block.signature = delta.signature;
+            } else {
+              block[GEMINI_THOUGHT_SIGNATURE_FIELD] = delta.signature;
+            }
+          }
+          break;
+        }
+        case "content_block_stop": {
+          const idx = event.index;
+          const block = contentBlocks[idx];
+          if (!block || !partialMessage)
+            break;
+          const message = {
+            message: {
+              ...partialMessage,
+              content: normalizeContentFromAPI([block], tools, options.agentId)
+            },
+            requestId: undefined,
+            type: "assistant",
+            uuid: randomUUID(),
+            timestamp: new Date().toISOString()
+          };
+          collectedMessages.push(message);
+          yield message;
+          break;
+        }
+        case "message_delta":
+        case "message_stop":
+          break;
+      }
+      yield {
+        type: "stream_event",
+        event,
+        ...event.type === "message_start" ? { ttftMs } : undefined
+      };
+    }
+    recordLLMObservation(options.langfuseTrace ?? null, {
+      model: geminiModel,
+      provider: "gemini",
+      input: convertMessagesToLangfuse(messagesForAPI, systemPrompt),
+      output: convertOutputToLangfuse(collectedMessages),
+      usage: {
+        input_tokens: 0,
+        output_tokens: 0
+      },
+      startTime: new Date(start),
+      endTime: new Date,
+      completionStartTime: ttftMs > 0 ? new Date(start + ttftMs) : undefined,
+      tools: convertToolsToLangfuse(toolSchemas),
+      thinking: thinkingConfig.type !== "disabled" ? {
+        type: thinkingConfig.type,
+        ...thinkingConfig.type === "enabled" && {
+          budgetTokens: thinkingConfig.budgetTokens
+        }
+      } : undefined
+    });
+  } catch (error) {
+    const errorMessage2 = error instanceof Error ? error.message : String(error);
+    logForDebugging(`[Gemini] Error: ${errorMessage2}`, { level: "error" });
+    yield createAssistantAPIErrorMessage({
+      content: `API Error: ${errorMessage2}`,
+      apiError: "api_error",
+      error: error instanceof Error ? error : new Error(String(error))
+    });
+  }
+}
+var init_gemini = __esm(() => {
+  init_api();
+  init_debug();
+  init_messages();
+  init_tracing();
+  init_convert();
+  init_client();
+  init_src();
+});
+init_gemini();
+
+export {
+  queryModelGemini
+};