@omnicross/core 0.1.1 → 0.1.3

package/dist/transformer/transformers/GeminiTransformer.js

@@ -1,986 +1,7 @@
-// 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 = openaiData.choices?.[0];
-  const message = choice?.message ?? {};
-  const usage = openaiData.usage;
-  const usagePromptDetails = usage?.prompt_tokens_details;
-  const usageOutputDetails = usage?.output_tokens_details;
-  const parts = [];
-  const thinking = message.thinking;
-  if (thinking?.content) {
-    parts.push({ text: thinking.content, thought: true });
-  }
-  if (thinking?.signature) {
-    parts.push({ thoughtSignature: thinking.signature });
-  }
-  if (message.content) {
-    parts.push({ text: message.content });
-  }
-  const toolCalls = message.tool_calls;
-  if (toolCalls?.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 {
-        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(choice?.finish_reason)
-    }],
-    usageMetadata: usage ? {
-      promptTokenCount: usage.prompt_tokens || 0,
-      candidatesTokenCount: usage.completion_tokens || 0,
-      totalTokenCount: usage.total_tokens || 0,
-      cachedContentTokenCount: usagePromptDetails?.cached_tokens || 0,
-      thoughtsTokenCount: usageOutputDetails?.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 {
-          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 {
-          }
-          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 = chunk.choices?.[0];
-              if (!choice) continue;
-              const delta = 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 = tc.index ?? 0;
-                  const existing = pendingToolCalls.get(idx);
-                  const func = tc.function;
-                  if (existing) {
-                    if (func?.arguments) {
-                      existing.args += func.arguments;
-                    }
-                  } else {
-                    pendingToolCalls.set(idx, {
-                      id: tc.id || `tool_${Date.now()}_${idx}`,
-                      name: func?.name || "",
-                      args: func?.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: chunk.usage.prompt_tokens_details?.cached_tokens || 0,
-                  thoughtsTokenCount: chunk.usage.output_tokens_details?.reasoning_tokens || 0
-                } : void 0;
-                emit({
-                  responseId,
-                  modelVersion: model,
-                  candidates: [{
-                    content: { parts: [{ text: "" }] },
-                    finishReason: toGeminiFinishReason(choice.finish_reason) || "STOP"
-                  }],
-                  usageMetadata: geminiUsage
-                });
-              }
-            } catch (e) {
-              logger?.error(`Error parsing OpenAI stream chunk for Gemini conversion: ${e}`);
-            }
-          }
-        }
-        flushToolCalls();
-      } catch (e) {
-        if (!isClosed) controller.error(e);
-      } finally {
-        if (!isClosed) {
-          try {
-            controller.close();
-          } catch {
-          }
-        }
-        reader.releaseLock();
-      }
-    }
-  });
-}
-async function transformResponseIn(response, logger) {
-  const contentType = 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 = 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();
-  logger?.debug(`${providerName} JSON response received`);
-  const parts = jsonResponse.candidates?.[0]?.content?.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 = parts.find((part) => part.thoughtSignature)?.thoughtSignature ?? "";
-  const toolCalls = nonThinkingParts.filter((part) => part.functionCall).map((part) => ({
-    id: part.functionCall?.id || `tool_${Math.random().toString(36).substring(2, 15)}`,
-    type: "function",
-    function: {
-      name: part.functionCall?.name ?? "",
-      arguments: JSON.stringify(part.functionCall?.args || {})
-    }
-  }));
-  const textContent = nonThinkingParts.filter((part) => part.text).map((part) => part.text).join("\n");
-  const openAIResponse = {
-    id: jsonResponse.responseId ?? "",
-    choices: [
-      {
-        finish_reason: (jsonResponse.candidates?.[0]?.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: jsonResponse.modelVersion ?? "",
-    object: "chat.completion",
-    usage: {
-      completion_tokens: jsonResponse.usageMetadata?.candidatesTokenCount || 0,
-      prompt_tokens: jsonResponse.usageMetadata?.promptTokenCount || 0,
-      prompt_tokens_details: {
-        cached_tokens: jsonResponse.usageMetadata?.cachedContentTokenCount || 0
-      },
-      total_tokens: jsonResponse.usageMetadata?.totalTokenCount || 0,
-      output_tokens_details: {
-        reasoning_tokens: jsonResponse.usageMetadata?.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;
-        logger?.debug(`${providerName} chunk: ${chunkStr.substring(0, 100)}...`);
-        try {
-          const chunk = JSON.parse(chunkStr);
-          if (!chunk.candidates?.[0]) {
-            logger?.debug("Invalid chunk structure");
-            return;
-          }
-          const candidate = chunk.candidates[0];
-          const parts = candidate.content?.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 = parts.find((part) => part.thoughtSignature)?.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: part.functionCall?.id || `ccr_tool_${Math.random().toString(36).substring(2, 15)}`,
-            type: "function",
-            function: {
-              name: part.functionCall?.name ?? "",
-              arguments: JSON.stringify(part.functionCall?.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 (chunk.modelVersion?.includes("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) {
-          logger?.error(`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: finishReason?.toLowerCase() || 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 (groundingMetadata?.groundingChunks?.length) {
-    const annotations = groundingMetadata.groundingChunks.map((groundingChunk, index) => {
-      const support = groundingMetadata.groundingSupports?.find(
-        (s) => s.groundingChunkIndices?.includes(index)
-      );
-      return {
-        type: "url_citation",
-        url_citation: {
-          url: groundingChunk.web?.uri || "",
-          title: groundingChunk.web?.title || "",
-          content: support?.segment?.text || "",
-          start_index: support?.segment?.startIndex || 0,
-          end_index: support?.segment?.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 (incomingAnyOf[0]?.type === "null") {
-      genAISchema.nullable = true;
-      workingSchema = incomingAnyOf[1];
-    } else if (incomingAnyOf[1]?.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 = request.tools?.filter((tool) => tool.function.name !== "web_search")?.map((tool) => ({
-    name: tool.function.name,
-    description: tool.function.description,
-    parametersJsonSchema: tool.function.parameters
-  }));
-  if (functionDeclarations?.length) {
-    tools.push(
-      transformTool({
-        functionDeclarations
-      })
-    );
-  }
-  const webSearch = request.tools?.find((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 (message.thinking?.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 = content.image_url?.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 && message.thinking?.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: tool.function?.name ?? "",
-              response: { result: response?.content }
-            }
-          };
-        }
-      );
-      contents.push({
-        role: "user",
-        parts: functionResponses
-      });
-    }
-  });
-  const generationConfig = {};
-  if (request.reasoning?.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" && request.tool_choice.function?.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: geminiContent.parts?.map((part) => ({
-            type: "text",
-            text: part.text || ""
-          })) || []
-        });
-      } else if (content.role === "model") {
-        unifiedRequest.messages.push({
-          role: "assistant",
-          content: content.parts?.map((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: funcDecl.description ?? "",
-              parameters: funcDecl.parameters ?? {}
-            }
-          });
-        }
-      }
-    }
-  }
-  return unifiedRequest;
-}
-
-// src/transformer/transformers/GeminiTransformer.ts
-var GeminiTransformer = class {
-  static TransformerName = "gemini";
-  name = "gemini";
-  logger;
-  /**
-   * API endpoint pattern for Gemini
-   * :modelAndAction will be replaced with actual model and action
-   */
-  endPoint = "/v1beta/models/:modelAndAction";
-  /** Use Bearer token instead of x-goog-api-key (for relay providers) */
-  useBearer;
-  constructor(options) {
-    this.useBearer = options?.UseBearer ?? false;
-  }
-  /**
-   * Handle authentication
-   * - Official Gemini: x-goog-api-key header
-   * - Relay providers: Authorization: Bearer header
-   */
-  async auth(request, provider, _context) {
-    const headers = {};
-    if (this.useBearer) {
-      headers["authorization"] = `Bearer ${provider.apiKey}`;
-      headers["x-goog-api-key"] = void 0;
-    } else {
-      headers["x-goog-api-key"] = provider.apiKey;
-      headers["authorization"] = void 0;
-    }
-    return {
-      body: request,
-      config: { headers }
-    };
-  }
-  /**
-   * Transform request from unified format to Gemini format
-   * Also builds the correct URL for the Gemini API
-   */
-  async transformRequestIn(request, provider, _context) {
-    const body = buildRequestBody(request);
-    const action = request.stream ? "streamGenerateContent?alt=sse" : "generateContent";
-    const url = new URL(`./${request.model}:${action}`, provider.baseUrl);
-    const headers = {};
-    if (this.useBearer) {
-      headers["authorization"] = `Bearer ${provider.apiKey}`;
-      headers["x-goog-api-key"] = void 0;
-    } else {
-      headers["x-goog-api-key"] = provider.apiKey;
-      headers["Authorization"] = void 0;
-    }
-    return {
-      body,
-      config: { url, headers }
-    };
-  }
-  /**
-   * Transform incoming request to unified format
-   * (For requests coming into the Gemini endpoint)
-   */
-  async transformRequestOut(request, _context) {
-    return transformRequestOut(request);
-  }
-  /**
-   * Transform Gemini response to OpenAI-compatible format
-   */
-  async transformResponseOut(response, _context) {
-    return transformResponseOut(response, this.name, this.logger);
-  }
-  /**
-   * Transform OpenAI-compatible response back to Gemini format
-   * (For endpoint mode — returning Gemini-format responses to the client)
-   */
-  async transformResponseIn(response, _context) {
-    return transformResponseIn(response, this.logger);
-  }
-};
+import {
+  GeminiTransformer
+} from "../../chunk-C7PSERMH.js";
+import "../../chunk-S4WBV25P.js";
 export {
   GeminiTransformer
 };