@omnicross/core 0.1.1 → 0.1.2

package/dist/chunk-YGXJGRFI.cjs

@@ -0,0 +1,913 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/transformer/transformers/utils/gemini.response-in.ts
+var FINISH_REASON_TO_GEMINI = {
+  stop: "STOP",
+  length: "MAX_TOKENS",
+  tool_calls: "STOP",
+  content_filter: "SAFETY",
+  // Already-lowercased Gemini reasons (pass-through from another transformer)
+  max_tokens: "MAX_TOKENS",
+  safety: "SAFETY"
+};
+function toGeminiFinishReason(openaiReason) {
+  if (!openaiReason) return null;
+  return FINISH_REASON_TO_GEMINI[openaiReason] || openaiReason.toUpperCase();
+}
+function convertOpenAIResponseToGemini(openaiData) {
+  const choice = _optionalChain([openaiData, 'access', _ => _.choices, 'optionalAccess', _2 => _2[0]]);
+  const message = _nullishCoalesce(_optionalChain([choice, 'optionalAccess', _3 => _3.message]), () => ( {}));
+  const usage = openaiData.usage;
+  const usagePromptDetails = _optionalChain([usage, 'optionalAccess', _4 => _4.prompt_tokens_details]);
+  const usageOutputDetails = _optionalChain([usage, 'optionalAccess', _5 => _5.output_tokens_details]);
+  const parts = [];
+  const thinking = message.thinking;
+  if (_optionalChain([thinking, 'optionalAccess', _6 => _6.content])) {
+    parts.push({ text: thinking.content, thought: true });
+  }
+  if (_optionalChain([thinking, 'optionalAccess', _7 => _7.signature])) {
+    parts.push({ thoughtSignature: thinking.signature });
+  }
+  if (message.content) {
+    parts.push({ text: message.content });
+  }
+  const toolCalls = message.tool_calls;
+  if (_optionalChain([toolCalls, 'optionalAccess', _8 => _8.length])) {
+    for (const tc of toolCalls) {
+      const func = tc.function;
+      let args = {};
+      try {
+        const raw = func.arguments;
+        args = typeof raw === "string" ? JSON.parse(raw) : raw;
+      } catch (e2) {
+        args = {};
+      }
+      parts.push({
+        functionCall: {
+          id: tc.id,
+          name: func.name,
+          args
+        }
+      });
+    }
+  }
+  if (parts.length === 0) {
+    parts.push({ text: "" });
+  }
+  return {
+    responseId: openaiData.id || "",
+    modelVersion: openaiData.model || "",
+    candidates: [{
+      content: { parts },
+      finishReason: toGeminiFinishReason(_optionalChain([choice, 'optionalAccess', _9 => _9.finish_reason]))
+    }],
+    usageMetadata: usage ? {
+      promptTokenCount: usage.prompt_tokens || 0,
+      candidatesTokenCount: usage.completion_tokens || 0,
+      totalTokenCount: usage.total_tokens || 0,
+      cachedContentTokenCount: _optionalChain([usagePromptDetails, 'optionalAccess', _10 => _10.cached_tokens]) || 0,
+      thoughtsTokenCount: _optionalChain([usageOutputDetails, 'optionalAccess', _11 => _11.reasoning_tokens]) || 0
+    } : void 0
+  };
+}
+function convertOpenAIStreamToGemini(openaiStream, logger) {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  let model = "";
+  let responseId = "";
+  return new ReadableStream({
+    start: async (controller) => {
+      const reader = openaiStream.getReader();
+      let buffer = "";
+      let isClosed = false;
+      const emit = (data) => {
+        if (isClosed) return;
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+        } catch (e3) {
+          isClosed = true;
+        }
+      };
+      const flushToolCalls = () => {
+        if (pendingToolCalls.size === 0) return;
+        const parts = [];
+        for (const tc of pendingToolCalls.values()) {
+          let args = {};
+          try {
+            args = JSON.parse(tc.args || "{}");
+          } catch (e4) {
+          }
+          parts.push({
+            functionCall: { id: tc.id, name: tc.name, args }
+          });
+        }
+        pendingToolCalls.clear();
+        emit({
+          responseId,
+          modelVersion: model,
+          candidates: [{ content: { parts }, finishReason: null }]
+        });
+      };
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (isClosed) break;
+            if (!line.startsWith("data:")) continue;
+            const data = line.slice(5).trim();
+            if (!data || data === "[DONE]") continue;
+            try {
+              const chunk = JSON.parse(data);
+              if (!responseId && chunk.id) responseId = chunk.id;
+              if (!model && chunk.model) model = chunk.model;
+              const choice = _optionalChain([chunk, 'access', _12 => _12.choices, 'optionalAccess', _13 => _13[0]]);
+              if (!choice) continue;
+              const delta = _nullishCoalesce(choice.delta, () => ( {}));
+              if (delta.thinking) {
+                const parts = [];
+                if (delta.thinking.content) {
+                  parts.push({ text: delta.thinking.content, thought: true });
+                }
+                if (delta.thinking.signature) {
+                  parts.push({ thoughtSignature: delta.thinking.signature });
+                }
+                if (parts.length > 0) {
+                  emit({
+                    responseId,
+                    modelVersion: model,
+                    candidates: [{ content: { parts }, finishReason: null }]
+                  });
+                }
+              }
+              if (delta.content) {
+                emit({
+                  responseId,
+                  modelVersion: model,
+                  candidates: [{
+                    content: { parts: [{ text: delta.content }] },
+                    finishReason: null
+                  }]
+                });
+              }
+              if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                  const idx = _nullishCoalesce(tc.index, () => ( 0));
+                  const existing = pendingToolCalls.get(idx);
+                  const func = tc.function;
+                  if (existing) {
+                    if (_optionalChain([func, 'optionalAccess', _14 => _14.arguments])) {
+                      existing.args += func.arguments;
+                    }
+                  } else {
+                    pendingToolCalls.set(idx, {
+                      id: tc.id || `tool_${Date.now()}_${idx}`,
+                      name: _optionalChain([func, 'optionalAccess', _15 => _15.name]) || "",
+                      args: _optionalChain([func, 'optionalAccess', _16 => _16.arguments]) || ""
+                    });
+                  }
+                }
+              }
+              if (choice.finish_reason) {
+                flushToolCalls();
+                const geminiUsage = chunk.usage ? {
+                  promptTokenCount: chunk.usage.prompt_tokens || 0,
+                  candidatesTokenCount: chunk.usage.completion_tokens || 0,
+                  totalTokenCount: chunk.usage.total_tokens || 0,
+                  cachedContentTokenCount: _optionalChain([chunk, 'access', _17 => _17.usage, 'access', _18 => _18.prompt_tokens_details, 'optionalAccess', _19 => _19.cached_tokens]) || 0,
+                  thoughtsTokenCount: _optionalChain([chunk, 'access', _20 => _20.usage, 'access', _21 => _21.output_tokens_details, 'optionalAccess', _22 => _22.reasoning_tokens]) || 0
+                } : void 0;
+                emit({
+                  responseId,
+                  modelVersion: model,
+                  candidates: [{
+                    content: { parts: [{ text: "" }] },
+                    finishReason: toGeminiFinishReason(choice.finish_reason) || "STOP"
+                  }],
+                  usageMetadata: geminiUsage
+                });
+              }
+            } catch (e) {
+              _optionalChain([logger, 'optionalAccess', _23 => _23.error, 'call', _24 => _24(`Error parsing OpenAI stream chunk for Gemini conversion: ${e}`)]);
+            }
+          }
+        }
+        flushToolCalls();
+      } catch (e) {
+        if (!isClosed) controller.error(e);
+      } finally {
+        if (!isClosed) {
+          try {
+            controller.close();
+          } catch (e5) {
+          }
+        }
+        reader.releaseLock();
+      }
+    }
+  });
+}
+async function transformResponseIn(response, logger) {
+  const contentType = _nullishCoalesce(response.headers.get("Content-Type"), () => ( ""));
+  if (contentType.includes("text/event-stream")) {
+    if (!response.body) {
+      throw new Error("Stream response body is null");
+    }
+    const geminiStream = convertOpenAIStreamToGemini(response.body, logger);
+    return new Response(geminiStream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+  const data = await response.json();
+  const geminiResponse = convertOpenAIResponseToGemini(data);
+  return new Response(JSON.stringify(geminiResponse), {
+    status: response.status,
+    statusText: response.statusText,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+// src/transformer/transformers/utils/gemini.stream.ts
+async function transformResponseOut(response, providerName, logger) {
+  const contentType = _nullishCoalesce(response.headers.get("Content-Type"), () => ( ""));
+  if (contentType.includes("application/json")) {
+    return handleJsonResponse(response, providerName, logger);
+  } else if (contentType.includes("stream") || contentType.includes("text/event-stream")) {
+    return handleStreamResponse(response, providerName, logger);
+  }
+  return response;
+}
+async function handleJsonResponse(response, providerName, logger) {
+  const jsonResponse = await response.json();
+  _optionalChain([logger, 'optionalAccess', _25 => _25.debug, 'call', _26 => _26(`${providerName} JSON response received`)]);
+  const parts = _optionalChain([jsonResponse, 'access', _27 => _27.candidates, 'optionalAccess', _28 => _28[0], 'optionalAccess', _29 => _29.content, 'optionalAccess', _30 => _30.parts]) || [];
+  let thinkingContent = "";
+  let thinkingSignature = "";
+  const nonThinkingParts = [];
+  for (const part of parts) {
+    if (part.text && part.thought === true) {
+      thinkingContent += part.text;
+    } else {
+      nonThinkingParts.push(part);
+    }
+  }
+  thinkingSignature = _nullishCoalesce(_optionalChain([parts, 'access', _31 => _31.find, 'call', _32 => _32((part) => part.thoughtSignature), 'optionalAccess', _33 => _33.thoughtSignature]), () => ( ""));
+  const toolCalls = nonThinkingParts.filter((part) => part.functionCall).map((part) => ({
+    id: _optionalChain([part, 'access', _34 => _34.functionCall, 'optionalAccess', _35 => _35.id]) || `tool_${Math.random().toString(36).substring(2, 15)}`,
+    type: "function",
+    function: {
+      name: _nullishCoalesce(_optionalChain([part, 'access', _36 => _36.functionCall, 'optionalAccess', _37 => _37.name]), () => ( "")),
+      arguments: JSON.stringify(_optionalChain([part, 'access', _38 => _38.functionCall, 'optionalAccess', _39 => _39.args]) || {})
+    }
+  }));
+  const textContent = nonThinkingParts.filter((part) => part.text).map((part) => part.text).join("\n");
+  const openAIResponse = {
+    id: _nullishCoalesce(jsonResponse.responseId, () => ( "")),
+    choices: [
+      {
+        finish_reason: (_nullishCoalesce(_optionalChain([jsonResponse, 'access', _40 => _40.candidates, 'optionalAccess', _41 => _41[0], 'optionalAccess', _42 => _42.finishReason]), () => ( ""))).toLowerCase() || null,
+        index: 0,
+        message: {
+          content: textContent,
+          role: "assistant",
+          tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
+          ...thinkingSignature && {
+            thinking: {
+              content: thinkingContent || "(no content)",
+              signature: thinkingSignature
+            }
+          }
+        }
+      }
+    ],
+    created: Math.floor(Date.now() / 1e3),
+    model: _nullishCoalesce(jsonResponse.modelVersion, () => ( "")),
+    object: "chat.completion",
+    usage: {
+      completion_tokens: _optionalChain([jsonResponse, 'access', _43 => _43.usageMetadata, 'optionalAccess', _44 => _44.candidatesTokenCount]) || 0,
+      prompt_tokens: _optionalChain([jsonResponse, 'access', _45 => _45.usageMetadata, 'optionalAccess', _46 => _46.promptTokenCount]) || 0,
+      prompt_tokens_details: {
+        cached_tokens: _optionalChain([jsonResponse, 'access', _47 => _47.usageMetadata, 'optionalAccess', _48 => _48.cachedContentTokenCount]) || 0
+      },
+      total_tokens: _optionalChain([jsonResponse, 'access', _49 => _49.usageMetadata, 'optionalAccess', _50 => _50.totalTokenCount]) || 0,
+      output_tokens_details: {
+        reasoning_tokens: _optionalChain([jsonResponse, 'access', _51 => _51.usageMetadata, 'optionalAccess', _52 => _52.thoughtsTokenCount]) || 0
+      }
+    }
+  };
+  return new Response(JSON.stringify(openAIResponse), {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+function handleStreamResponse(response, providerName, logger) {
+  if (!response.body) {
+    return response;
+  }
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let signatureSent = false;
+  let contentSent = false;
+  let hasThinkingContent = false;
+  let pendingContent = "";
+  let contentIndex = 0;
+  let toolCallIndex = -1;
+  const stream = new ReadableStream({
+    async start(controller) {
+      const reader = response.body.getReader();
+      let buffer = "";
+      const processLine = async (line) => {
+        if (!line.startsWith("data: ")) return;
+        const chunkStr = line.slice(6).trim();
+        if (!chunkStr) return;
+        _optionalChain([logger, 'optionalAccess', _53 => _53.debug, 'call', _54 => _54(`${providerName} chunk: ${chunkStr.substring(0, 100)}...`)]);
+        try {
+          const chunk = JSON.parse(chunkStr);
+          if (!_optionalChain([chunk, 'access', _55 => _55.candidates, 'optionalAccess', _56 => _56[0]])) {
+            _optionalChain([logger, 'optionalAccess', _57 => _57.debug, 'call', _58 => _58("Invalid chunk structure")]);
+            return;
+          }
+          const candidate = chunk.candidates[0];
+          const parts = _optionalChain([candidate, 'access', _59 => _59.content, 'optionalAccess', _60 => _60.parts]) || [];
+          parts.filter((part) => part.text && part.thought === true).forEach((part) => {
+            hasThinkingContent = true;
+            const thinkingChunk = createChunk({
+              responseId: chunk.responseId,
+              modelVersion: chunk.modelVersion,
+              contentIndex,
+              delta: {
+                role: "assistant",
+                content: null,
+                thinking: { content: part.text }
+              }
+            });
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(thinkingChunk)}
+
+`));
+          });
+          const signature = _optionalChain([parts, 'access', _61 => _61.find, 'call', _62 => _62((part) => part.thoughtSignature), 'optionalAccess', _63 => _63.thoughtSignature]);
+          if (signature && !signatureSent) {
+            if (!hasThinkingContent) {
+              const thinkingChunk = createChunk({
+                responseId: chunk.responseId,
+                modelVersion: chunk.modelVersion,
+                contentIndex,
+                delta: {
+                  role: "assistant",
+                  content: null,
+                  thinking: { content: "" }
+                }
+              });
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(thinkingChunk)}
+
+`));
+            }
+            const signatureChunk = createChunk({
+              responseId: chunk.responseId,
+              modelVersion: chunk.modelVersion,
+              contentIndex,
+              delta: {
+                role: "assistant",
+                content: null,
+                thinking: { signature }
+              }
+            });
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(signatureChunk)}
+
+`));
+            signatureSent = true;
+            contentIndex++;
+            if (pendingContent) {
+              const pendingChunk = createChunk({
+                responseId: chunk.responseId,
+                modelVersion: chunk.modelVersion,
+                contentIndex,
+                delta: { role: "assistant", content: pendingContent }
+              });
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(pendingChunk)}
+
+`));
+              pendingContent = "";
+              contentSent = true;
+            }
+          }
+          const toolCalls = parts.filter((part) => part.functionCall).map((part) => ({
+            id: _optionalChain([part, 'access', _64 => _64.functionCall, 'optionalAccess', _65 => _65.id]) || `ccr_tool_${Math.random().toString(36).substring(2, 15)}`,
+            type: "function",
+            function: {
+              name: _nullishCoalesce(_optionalChain([part, 'access', _66 => _66.functionCall, 'optionalAccess', _67 => _67.name]), () => ( "")),
+              arguments: JSON.stringify(_optionalChain([part, 'access', _68 => _68.functionCall, 'optionalAccess', _69 => _69.args]) || {})
+            }
+          }));
+          const textContent = parts.filter((part) => part.text && part.thought !== true).map((part) => part.text).join("\n");
+          if (!textContent && signatureSent && !contentSent) {
+            contentSent = true;
+          }
+          if (hasThinkingContent && textContent && !signatureSent) {
+            if (_optionalChain([chunk, 'access', _70 => _70.modelVersion, 'optionalAccess', _71 => _71.includes, 'call', _72 => _72("3")])) {
+              pendingContent += textContent;
+              return;
+            } else {
+              const signatureChunk = createChunk({
+                responseId: chunk.responseId,
+                modelVersion: chunk.modelVersion,
+                contentIndex,
+                delta: {
+                  role: "assistant",
+                  content: null,
+                  thinking: { signature: `ccr_${Date.now()}` }
+                }
+              });
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(signatureChunk)}
+
+`));
+              signatureSent = true;
+            }
+          }
+          if (textContent) {
+            if (!pendingContent) contentIndex++;
+            const contentChunk = createChunk({
+              responseId: chunk.responseId,
+              modelVersion: chunk.modelVersion,
+              contentIndex,
+              delta: { role: "assistant", content: textContent },
+              finishReason: candidate.finishReason,
+              usageMetadata: chunk.usageMetadata,
+              groundingMetadata: candidate.groundingMetadata
+            });
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(contentChunk)}
+
+`));
+            contentSent = true;
+          }
+          if (toolCalls.length > 0) {
+            for (const tool of toolCalls) {
+              contentIndex++;
+              toolCallIndex++;
+              const toolChunk = createChunk({
+                responseId: chunk.responseId,
+                modelVersion: chunk.modelVersion,
+                contentIndex,
+                delta: {
+                  role: "assistant",
+                  tool_calls: [{ ...tool, index: toolCallIndex }]
+                },
+                finishReason: candidate.finishReason,
+                usageMetadata: chunk.usageMetadata,
+                groundingMetadata: candidate.groundingMetadata
+              });
+              controller.enqueue(encoder.encode(`data: ${JSON.stringify(toolChunk)}
+
+`));
+            }
+            contentSent = true;
+          }
+        } catch (_error) {
+          _optionalChain([logger, 'optionalAccess', _73 => _73.error, 'call', _74 => _74(`Error parsing ${providerName} stream chunk: ${chunkStr}`)]);
+        }
+      };
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            if (buffer) await processLine(buffer);
+            break;
+          }
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            await processLine(line);
+          }
+        }
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+function createChunk(options) {
+  const {
+    responseId,
+    modelVersion,
+    contentIndex,
+    delta,
+    finishReason,
+    usageMetadata,
+    groundingMetadata
+  } = options;
+  const chunk = {
+    choices: [
+      {
+        delta,
+        finish_reason: _optionalChain([finishReason, 'optionalAccess', _75 => _75.toLowerCase, 'call', _76 => _76()]) || null,
+        index: contentIndex,
+        logprobs: null
+      }
+    ],
+    created: Math.floor(Date.now() / 1e3),
+    id: responseId || "",
+    model: modelVersion || "",
+    object: "chat.completion.chunk",
+    system_fingerprint: "fp_a49d71b8a1"
+  };
+  if (usageMetadata) {
+    chunk.usage = {
+      completion_tokens: usageMetadata.candidatesTokenCount || 0,
+      prompt_tokens: usageMetadata.promptTokenCount || 0,
+      prompt_tokens_details: {
+        cached_tokens: usageMetadata.cachedContentTokenCount || 0
+      },
+      total_tokens: usageMetadata.totalTokenCount || 0,
+      output_tokens_details: {
+        reasoning_tokens: usageMetadata.thoughtsTokenCount || 0
+      }
+    };
+  }
+  if (_optionalChain([groundingMetadata, 'optionalAccess', _77 => _77.groundingChunks, 'optionalAccess', _78 => _78.length])) {
+    const annotations = groundingMetadata.groundingChunks.map((groundingChunk, index) => {
+      const support = _optionalChain([groundingMetadata, 'access', _79 => _79.groundingSupports, 'optionalAccess', _80 => _80.find, 'call', _81 => _81(
+        (s) => _optionalChain([s, 'access', _82 => _82.groundingChunkIndices, 'optionalAccess', _83 => _83.includes, 'call', _84 => _84(index)])
+      )]);
+      return {
+        type: "url_citation",
+        url_citation: {
+          url: _optionalChain([groundingChunk, 'access', _85 => _85.web, 'optionalAccess', _86 => _86.uri]) || "",
+          title: _optionalChain([groundingChunk, 'access', _87 => _87.web, 'optionalAccess', _88 => _88.title]) || "",
+          content: _optionalChain([support, 'optionalAccess', _89 => _89.segment, 'optionalAccess', _90 => _90.text]) || "",
+          start_index: _optionalChain([support, 'optionalAccess', _91 => _91.segment, 'optionalAccess', _92 => _92.startIndex]) || 0,
+          end_index: _optionalChain([support, 'optionalAccess', _93 => _93.segment, 'optionalAccess', _94 => _94.endIndex]) || 0
+        }
+      };
+    });
+    chunk.choices[0].delta.annotations = annotations;
+  }
+  return chunk;
+}
+
+// src/transformer/transformers/utils/gemini.schema.ts
+var GeminiType = {
+  TYPE_UNSPECIFIED: "TYPE_UNSPECIFIED",
+  STRING: "STRING",
+  NUMBER: "NUMBER",
+  INTEGER: "INTEGER",
+  BOOLEAN: "BOOLEAN",
+  ARRAY: "ARRAY",
+  OBJECT: "OBJECT",
+  NULL: "NULL"
+};
+function flattenTypeArrayToAnyOf(typeList, resultingSchema) {
+  if (typeList.includes("null")) {
+    resultingSchema.nullable = true;
+  }
+  const listWithoutNull = typeList.filter((type) => type !== "null");
+  if (listWithoutNull.length === 1) {
+    const upperCaseType = listWithoutNull[0].toUpperCase();
+    resultingSchema.type = Object.values(GeminiType).includes(upperCaseType) ? upperCaseType : GeminiType.TYPE_UNSPECIFIED;
+  } else {
+    resultingSchema.anyOf = listWithoutNull.map((typeName) => {
+      const upperCaseType = typeName.toUpperCase();
+      return {
+        type: Object.values(GeminiType).includes(upperCaseType) ? upperCaseType : GeminiType.TYPE_UNSPECIFIED
+      };
+    });
+  }
+}
+function processJsonSchema(jsonSchema) {
+  const genAISchema = {};
+  const schemaFieldNames = ["items"];
+  const listSchemaFieldNames = ["anyOf"];
+  const dictSchemaFieldNames = ["properties"];
+  let workingSchema = jsonSchema;
+  if (workingSchema.type && workingSchema.anyOf) {
+    throw new Error("type and anyOf cannot be both populated.");
+  }
+  const incomingAnyOf = workingSchema.anyOf;
+  if (incomingAnyOf && Array.isArray(incomingAnyOf) && incomingAnyOf.length === 2) {
+    if (_optionalChain([incomingAnyOf, 'access', _95 => _95[0], 'optionalAccess', _96 => _96.type]) === "null") {
+      genAISchema.nullable = true;
+      workingSchema = incomingAnyOf[1];
+    } else if (_optionalChain([incomingAnyOf, 'access', _97 => _97[1], 'optionalAccess', _98 => _98.type]) === "null") {
+      genAISchema.nullable = true;
+      workingSchema = incomingAnyOf[0];
+    }
+  }
+  if (workingSchema.type && Array.isArray(workingSchema.type)) {
+    flattenTypeArrayToAnyOf(workingSchema.type, genAISchema);
+  }
+  for (const [fieldName, fieldValue] of Object.entries(workingSchema)) {
+    if (fieldValue == null) {
+      continue;
+    }
+    if (fieldName === "type") {
+      if (fieldValue === "null") {
+        throw new Error("type: null cannot be the only possible type for the field.");
+      }
+      if (Array.isArray(fieldValue)) {
+        continue;
+      }
+      const upperCaseValue = fieldValue.toUpperCase();
+      genAISchema.type = Object.values(GeminiType).includes(upperCaseValue) ? upperCaseValue : GeminiType.TYPE_UNSPECIFIED;
+    } else if (schemaFieldNames.includes(fieldName)) {
+      genAISchema[fieldName] = processJsonSchema(fieldValue);
+    } else if (listSchemaFieldNames.includes(fieldName)) {
+      const listValue = [];
+      for (const item of fieldValue) {
+        if (item.type === "null") {
+          genAISchema.nullable = true;
+          continue;
+        }
+        listValue.push(processJsonSchema(item));
+      }
+      genAISchema[fieldName] = listValue;
+    } else if (dictSchemaFieldNames.includes(fieldName)) {
+      const dictValue = {};
+      for (const [key, value] of Object.entries(fieldValue)) {
+        dictValue[key] = processJsonSchema(value);
+      }
+      genAISchema[fieldName] = dictValue;
+    } else {
+      if (fieldName === "additionalProperties") {
+        continue;
+      }
+      genAISchema[fieldName] = fieldValue;
+    }
+  }
+  return genAISchema;
+}
+function transformTool(tool) {
+  const functionDeclarations = tool.functionDeclarations;
+  if (functionDeclarations) {
+    for (const functionDeclaration of functionDeclarations) {
+      if (functionDeclaration.parameters) {
+        const params = functionDeclaration.parameters;
+        if (!Object.keys(params).includes("$schema")) {
+          functionDeclaration.parameters = processJsonSchema(params);
+        } else {
+          if (!functionDeclaration.parametersJsonSchema) {
+            functionDeclaration.parametersJsonSchema = functionDeclaration.parameters;
+            delete functionDeclaration.parameters;
+          }
+        }
+      }
+      if (functionDeclaration.response) {
+        const response = functionDeclaration.response;
+        if (!Object.keys(response).includes("$schema")) {
+          functionDeclaration.response = processJsonSchema(response);
+        } else {
+          if (!functionDeclaration.responseJsonSchema) {
+            functionDeclaration.responseJsonSchema = functionDeclaration.response;
+            delete functionDeclaration.response;
+          }
+        }
+      }
+    }
+  }
+  return tool;
+}
+
+// src/transformer/transformers/utils/gemini.util.ts
+function buildRequestBody(request) {
+  const tools = [];
+  const functionDeclarations = _optionalChain([request, 'access', _99 => _99.tools, 'optionalAccess', _100 => _100.filter, 'call', _101 => _101((tool) => tool.function.name !== "web_search"), 'optionalAccess', _102 => _102.map, 'call', _103 => _103((tool) => ({
+    name: tool.function.name,
+    description: tool.function.description,
+    parametersJsonSchema: tool.function.parameters
+  }))]);
+  if (_optionalChain([functionDeclarations, 'optionalAccess', _104 => _104.length])) {
+    tools.push(
+      transformTool({
+        functionDeclarations
+      })
+    );
+  }
+  const webSearch = _optionalChain([request, 'access', _105 => _105.tools, 'optionalAccess', _106 => _106.find, 'call', _107 => _107((tool) => tool.function.name === "web_search")]);
+  if (webSearch) {
+    tools.push({ googleSearch: {} });
+  }
+  const contents = [];
+  const toolResponses = request.messages.filter((item) => item.role === "tool");
+  request.messages.filter((item) => item.role !== "tool").forEach((message) => {
+    let role;
+    if (message.role === "assistant") {
+      role = "model";
+    } else if (["user", "system"].includes(message.role)) {
+      role = "user";
+    } else {
+      role = "user";
+    }
+    const parts = [];
+    if (typeof message.content === "string") {
+      const part = { text: message.content };
+      if (_optionalChain([message, 'access', _108 => _108.thinking, 'optionalAccess', _109 => _109.signature])) {
+        part.thoughtSignature = message.thinking.signature;
+      }
+      parts.push(part);
+    } else if (Array.isArray(message.content)) {
+      for (const content of message.content) {
+        if (content.type === "text") {
+          parts.push({ text: content.text || "" });
+        } else if (content.type === "image_url") {
+          const imageUrl = _nullishCoalesce(_optionalChain([content, 'access', _110 => _110.image_url, 'optionalAccess', _111 => _111.url]), () => ( ""));
+          if (imageUrl.startsWith("http")) {
+            parts.push({
+              file_data: {
+                mime_type: content.media_type,
+                file_uri: imageUrl
+              }
+            });
+          } else {
+            const data = imageUrl.split(",").pop() || imageUrl;
+            parts.push({
+              inlineData: {
+                mime_type: content.media_type || "image/png",
+                data
+              }
+            });
+          }
+        }
+      }
+    } else if (message.content && typeof message.content === "object") {
+      const contentObj = message.content;
+      if (contentObj.text) {
+        parts.push({ text: contentObj.text });
+      } else {
+        parts.push({ text: JSON.stringify(message.content) });
+      }
+    }
+    if (Array.isArray(message.tool_calls)) {
+      for (let index = 0; index < message.tool_calls.length; index++) {
+        const toolCall = message.tool_calls[index];
+        const functionCallPart = {
+          functionCall: {
+            id: toolCall.id || `tool_${Math.random().toString(36).substring(2, 15)}`,
+            name: toolCall.function.name,
+            args: JSON.parse(toolCall.function.arguments || "{}")
+          }
+        };
+        if (index === 0 && _optionalChain([message, 'access', _112 => _112.thinking, 'optionalAccess', _113 => _113.signature])) {
+          functionCallPart.thoughtSignature = message.thinking.signature;
+        }
+        parts.push(functionCallPart);
+      }
+    }
+    if (parts.length === 0) {
+      parts.push({ text: "" });
+    }
+    contents.push({ role, parts });
+    if (role === "model" && message.tool_calls) {
+      const functionResponses = message.tool_calls.map(
+        (tool) => {
+          const response = toolResponses.find((item) => item.tool_call_id === tool.id);
+          return {
+            functionResponse: {
+              name: _nullishCoalesce(_optionalChain([tool, 'access', _114 => _114.function, 'optionalAccess', _115 => _115.name]), () => ( "")),
+              response: { result: _optionalChain([response, 'optionalAccess', _116 => _116.content]) }
+            }
+          };
+        }
+      );
+      contents.push({
+        role: "user",
+        parts: functionResponses
+      });
+    }
+  });
+  const generationConfig = {};
+  if (_optionalChain([request, 'access', _117 => _117.reasoning, 'optionalAccess', _118 => _118.effort]) && request.reasoning.effort !== "none") {
+    generationConfig.thinkingConfig = {
+      includeThoughts: true
+    };
+    if (request.model.includes("gemini-3")) {
+      generationConfig.thinkingConfig.thinkingLevel = request.reasoning.effort;
+    } else {
+      const thinkingBudgets = request.model.includes("pro") ? [128, 32768] : [0, 24576];
+      const maxTokens = request.reasoning.max_tokens;
+      if (typeof maxTokens !== "undefined") {
+        let thinkingBudget;
+        if (maxTokens >= thinkingBudgets[0] && maxTokens <= thinkingBudgets[1]) {
+          thinkingBudget = maxTokens;
+        } else if (maxTokens < thinkingBudgets[0]) {
+          thinkingBudget = thinkingBudgets[0];
+        } else {
+          thinkingBudget = thinkingBudgets[1];
+        }
+        generationConfig.thinkingConfig.thinkingBudget = thinkingBudget;
+      }
+    }
+  }
+  const body = {
+    contents,
+    tools: tools.length > 0 ? tools : void 0,
+    generationConfig: Object.keys(generationConfig).length > 0 ? generationConfig : void 0
+  };
+  if (request.tool_choice) {
+    const toolConfig = {
+      functionCallingConfig: {}
+    };
+    if (request.tool_choice === "auto") {
+      toolConfig.functionCallingConfig.mode = "auto";
+    } else if (request.tool_choice === "none") {
+      toolConfig.functionCallingConfig.mode = "none";
+    } else if (request.tool_choice === "required") {
+      toolConfig.functionCallingConfig.mode = "any";
+    } else if (typeof request.tool_choice === "object" && _optionalChain([request, 'access', _119 => _119.tool_choice, 'access', _120 => _120.function, 'optionalAccess', _121 => _121.name])) {
+      toolConfig.functionCallingConfig.mode = "any";
+      toolConfig.functionCallingConfig.allowedFunctionNames = [
+        request.tool_choice.function.name
+      ];
+    }
+    body.toolConfig = toolConfig;
+  }
+  return body;
+}
+function transformRequestOut(request) {
+  const contents = request.contents;
+  const tools = request.tools;
+  const model = request.model;
+  const maxTokens = request.max_tokens;
+  const temperature = request.temperature;
+  const stream = request.stream;
+  const toolChoice = request.tool_choice;
+  const unifiedRequest = {
+    messages: [],
+    model,
+    max_tokens: maxTokens,
+    temperature,
+    stream,
+    tool_choice: toolChoice
+  };
+  if (Array.isArray(contents)) {
+    for (const content of contents) {
+      if (typeof content === "string") {
+        unifiedRequest.messages.push({
+          role: "user",
+          content
+        });
+      } else if ("text" in content && typeof content.text === "string") {
+        unifiedRequest.messages.push({
+          role: "user",
+          content: content.text || null
+        });
+      } else if ("role" in content && content.role === "user") {
+        const geminiContent = content;
+        unifiedRequest.messages.push({
+          role: "user",
+          content: _optionalChain([geminiContent, 'access', _122 => _122.parts, 'optionalAccess', _123 => _123.map, 'call', _124 => _124((part) => ({
+            type: "text",
+            text: part.text || ""
+          }))]) || []
+        });
+      } else if (content.role === "model") {
+        unifiedRequest.messages.push({
+          role: "assistant",
+          content: _optionalChain([content, 'access', _125 => _125.parts, 'optionalAccess', _126 => _126.map, 'call', _127 => _127((part) => ({
+            type: "text",
+            text: part.text || ""
+          }))]) || []
+        });
+      }
+    }
+  }
+  if (Array.isArray(tools)) {
+    unifiedRequest.tools = [];
+    for (const tool of tools) {
+      if (Array.isArray(tool.functionDeclarations)) {
+        for (const funcDecl of tool.functionDeclarations) {
+          unifiedRequest.tools.push({
+            type: "function",
+            function: {
+              name: funcDecl.name,
+              description: _nullishCoalesce(funcDecl.description, () => ( "")),
+              parameters: _nullishCoalesce(funcDecl.parameters, () => ( {}))
+            }
+          });
+        }
+      }
+    }
+  }
+  return unifiedRequest;
+}
+
+
+
+
+
+
+exports.transformResponseIn = transformResponseIn; exports.transformResponseOut = transformResponseOut; exports.buildRequestBody = buildRequestBody; exports.transformRequestOut = transformRequestOut;