@amux.ai/adapter-google 0.1.1

package/dist/index.js

@@ -0,0 +1,847 @@
+// src/inbound/request-parser.ts
+function isOpenAIFormat(request) {
+  const req = request;
+  return Array.isArray(req.messages);
+}
+function parseRequest(request) {
+  if (isOpenAIFormat(request)) {
+    return parseOpenAIRequest(request);
+  }
+  return parseGeminiRequest(request);
+}
+function parseOpenAIRequest(req) {
+  const messages = [];
+  for (const msg of req.messages) {
+    messages.push({
+      role: msg.role,
+      content: parseOpenAIContent(msg.content),
+      name: msg.name,
+      toolCalls: msg.tool_calls,
+      toolCallId: msg.tool_call_id
+    });
+  }
+  const tools = req.tools?.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters
+    }
+  }));
+  let toolChoice;
+  if (req.tool_choice) {
+    if (typeof req.tool_choice === "string") {
+      toolChoice = req.tool_choice;
+    } else {
+      toolChoice = {
+        type: "function",
+        function: { name: req.tool_choice.function.name }
+      };
+    }
+  }
+  return {
+    messages,
+    model: req.model,
+    tools,
+    toolChoice,
+    stream: req.stream,
+    generation: {
+      temperature: req.temperature,
+      topP: req.top_p,
+      maxTokens: req.max_tokens,
+      stopSequences: req.stop ? Array.isArray(req.stop) ? req.stop : [req.stop] : void 0
+    },
+    raw: req
+  };
+}
+function parseOpenAIContent(content) {
+  if (content === null || content === void 0) {
+    return "";
+  }
+  if (typeof content === "string") {
+    return content;
+  }
+  return content.map((part) => {
+    if (part.type === "text") {
+      return {
+        type: "text",
+        text: part.text ?? ""
+      };
+    }
+    if (part.type === "image_url" && part.image_url) {
+      const url = part.image_url.url;
+      if (url.startsWith("data:")) {
+        const match = url.match(/^data:([^;]+);base64,(.+)$/);
+        if (match) {
+          return {
+            type: "image",
+            source: {
+              type: "base64",
+              mediaType: match[1],
+              data: match[2]
+            }
+          };
+        }
+      }
+      return {
+        type: "image",
+        source: {
+          type: "url",
+          url
+        }
+      };
+    }
+    return {
+      type: "text",
+      text: JSON.stringify(part)
+    };
+  });
+}
+function parseGeminiRequest(req) {
+  let system;
+  if (req.systemInstruction?.parts) {
+    system = req.systemInstruction.parts.map((p) => p.text).join("\n");
+  }
+  const messages = req.contents.flatMap((content) => parseGeminiContent(content));
+  const tools = req.tools?.[0]?.functionDeclarations?.map((fn) => ({
+    type: "function",
+    function: {
+      name: fn.name,
+      description: fn.description,
+      parameters: fn.parameters ? {
+        type: fn.parameters.type,
+        properties: fn.parameters.properties,
+        required: fn.parameters.required
+      } : void 0
+    }
+  }));
+  let toolChoice;
+  if (req.toolConfig?.functionCallingConfig) {
+    const mode = req.toolConfig.functionCallingConfig.mode;
+    if (mode === "AUTO") toolChoice = "auto";
+    else if (mode === "NONE") toolChoice = "none";
+    else if (mode === "ANY") toolChoice = "required";
+  }
+  return {
+    messages,
+    tools,
+    toolChoice,
+    system,
+    generation: req.generationConfig ? {
+      temperature: req.generationConfig.temperature,
+      topP: req.generationConfig.topP,
+      topK: req.generationConfig.topK,
+      maxTokens: req.generationConfig.maxOutputTokens,
+      stopSequences: req.generationConfig.stopSequences,
+      responseFormat: req.generationConfig.responseMimeType === "application/json" ? { type: "json_object" } : void 0
+    } : void 0,
+    raw: req
+  };
+}
+function parseGeminiContent(content) {
+  const role = content.role === "model" ? "assistant" : "user";
+  const parts = [];
+  const toolCalls = [];
+  const toolResults = [];
+  for (const part of content.parts) {
+    if ("text" in part) {
+      parts.push({
+        type: "text",
+        text: part.text
+      });
+    } else if ("inlineData" in part) {
+      parts.push({
+        type: "image",
+        source: {
+          type: "base64",
+          mediaType: part.inlineData.mimeType,
+          data: part.inlineData.data
+        }
+      });
+    } else if ("fileData" in part) {
+      parts.push({
+        type: "image",
+        source: {
+          type: "url",
+          url: part.fileData.fileUri
+        }
+      });
+    } else if ("functionCall" in part) {
+      toolCalls.push({
+        id: `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        type: "function",
+        function: {
+          name: part.functionCall.name,
+          arguments: JSON.stringify(part.functionCall.args)
+        }
+      });
+    } else if ("functionResponse" in part) {
+      toolResults.push({
+        role: "tool",
+        content: JSON.stringify(part.functionResponse.response),
+        toolCallId: `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        name: part.functionResponse.name
+      });
+    }
+  }
+  const messages = [];
+  if (parts.length > 0 || toolCalls.length > 0) {
+    const allText = parts.every((p) => p.type === "text");
+    const messageContent = allText && parts.length === 1 ? parts[0].text : parts.length > 0 ? parts : "";
+    const message = {
+      role,
+      content: messageContent
+    };
+    if (toolCalls.length > 0) {
+      message.toolCalls = toolCalls;
+    }
+    messages.push(message);
+  }
+  messages.push(...toolResults);
+  return messages;
+}
+
+// src/inbound/response-parser.ts
+function mapFinishReason(reason) {
+  if (!reason) return "stop";
+  const reasonMap = {
+    STOP: "stop",
+    MAX_TOKENS: "length",
+    SAFETY: "content_filter",
+    RECITATION: "content_filter",
+    OTHER: "stop"
+  };
+  return reasonMap[reason] ?? "stop";
+}
+function parseResponse(response) {
+  const res = response;
+  const choices = res.candidates.map((candidate, index) => {
+    const { contentParts, toolCalls } = parseParts(candidate.content.parts);
+    const allText = contentParts.every((p) => p.type === "text");
+    const content = allText && contentParts.length === 1 ? contentParts[0].text : contentParts;
+    return {
+      index: candidate.index ?? index,
+      message: {
+        role: "assistant",
+        content,
+        toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+      },
+      finishReason: mapFinishReason(candidate.finishReason)
+    };
+  });
+  return {
+    id: res.responseId ?? `gemini-${Date.now()}`,
+    model: res.modelVersion ?? "gemini",
+    choices,
+    usage: res.usageMetadata ? {
+      promptTokens: res.usageMetadata.promptTokenCount,
+      completionTokens: res.usageMetadata.candidatesTokenCount,
+      totalTokens: res.usageMetadata.totalTokenCount,
+      details: res.usageMetadata.cachedContentTokenCount ? { cachedTokens: res.usageMetadata.cachedContentTokenCount } : void 0
+    } : void 0,
+    raw: response
+  };
+}
+function parseParts(parts) {
+  const contentParts = [];
+  const toolCalls = [];
+  for (const part of parts) {
+    if ("text" in part) {
+      contentParts.push({
+        type: "text",
+        text: part.text
+      });
+    } else if ("functionCall" in part) {
+      toolCalls.push({
+        id: `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        type: "function",
+        function: {
+          name: part.functionCall.name,
+          arguments: JSON.stringify(part.functionCall.args)
+        }
+      });
+    }
+  }
+  return { contentParts, toolCalls };
+}
+
+// src/inbound/stream-parser.ts
+function mapFinishReason2(reason) {
+  if (!reason) return "stop";
+  const reasonMap = {
+    STOP: "stop",
+    MAX_TOKENS: "length",
+    SAFETY: "content_filter",
+    RECITATION: "content_filter",
+    OTHER: "stop",
+    // OpenAI-compatible reasons
+    stop: "stop",
+    length: "length",
+    tool_calls: "tool_calls",
+    content_filter: "content_filter"
+  };
+  return reasonMap[reason] ?? "stop";
+}
+function isOpenAIFormat2(chunk) {
+  const c = chunk;
+  return Array.isArray(c.choices) && c.choices.length > 0 && "delta" in c.choices[0];
+}
+function parseStream(chunk) {
+  if (isOpenAIFormat2(chunk)) {
+    return parseOpenAIStream(chunk);
+  }
+  return parseGeminiStream(chunk);
+}
+function parseOpenAIStream(data) {
+  if (!data.choices || data.choices.length === 0) {
+    if (data.usage) {
+      return {
+        type: "end",
+        id: data.id,
+        model: data.model,
+        usage: {
+          promptTokens: data.usage.prompt_tokens,
+          completionTokens: data.usage.completion_tokens,
+          totalTokens: data.usage.total_tokens
+        },
+        raw: data
+      };
+    }
+    return null;
+  }
+  const choice = data.choices[0];
+  if (!choice) return null;
+  const delta = choice.delta;
+  if (choice.index === 0 && !delta.content && !delta.tool_calls && !choice.finish_reason) {
+    return {
+      type: "start",
+      id: data.id,
+      model: data.model,
+      raw: data
+    };
+  }
+  if (delta.content) {
+    return {
+      type: "content",
+      id: data.id,
+      model: data.model,
+      content: {
+        type: "content",
+        delta: delta.content,
+        index: choice.index
+      },
+      raw: data
+    };
+  }
+  if (delta.tool_calls && delta.tool_calls.length > 0) {
+    const toolCall = delta.tool_calls[0];
+    if (toolCall) {
+      return {
+        type: "tool_call",
+        id: data.id,
+        model: data.model,
+        toolCall: {
+          type: "tool_call",
+          id: toolCall.id,
+          name: toolCall.function?.name,
+          arguments: toolCall.function?.arguments,
+          index: toolCall.index
+        },
+        raw: data
+      };
+    }
+  }
+  if (choice.finish_reason) {
+    return {
+      type: "end",
+      id: data.id,
+      model: data.model,
+      finishReason: mapFinishReason2(choice.finish_reason),
+      usage: data.usage ? {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens
+      } : void 0,
+      raw: data
+    };
+  }
+  return null;
+}
+function parseGeminiStream(data) {
+  if (!data.candidates || data.candidates.length === 0) {
+    if (data.usageMetadata) {
+      return {
+        type: "end",
+        model: data.modelVersion,
+        usage: {
+          promptTokens: data.usageMetadata.promptTokenCount,
+          completionTokens: data.usageMetadata.candidatesTokenCount,
+          totalTokens: data.usageMetadata.totalTokenCount
+        },
+        raw: data
+      };
+    }
+    return null;
+  }
+  const candidate = data.candidates[0];
+  if (!candidate) return null;
+  const events = [];
+  if (candidate.content?.parts) {
+    for (const part of candidate.content.parts) {
+      if ("text" in part) {
+        events.push({
+          type: "content",
+          model: data.modelVersion,
+          content: {
+            type: "content",
+            delta: part.text,
+            index: candidate.index ?? 0
+          },
+          raw: data
+        });
+      } else if ("functionCall" in part) {
+        events.push({
+          type: "tool_call",
+          model: data.modelVersion,
+          toolCall: {
+            type: "tool_call",
+            id: `call_${Date.now()}_${part.functionCall.name}`,
+            name: part.functionCall.name,
+            arguments: JSON.stringify(part.functionCall.args),
+            index: candidate.index ?? 0
+          },
+          raw: data
+        });
+      }
+    }
+  }
+  if (candidate.finishReason) {
+    events.push({
+      type: "end",
+      model: data.modelVersion,
+      finishReason: mapFinishReason2(candidate.finishReason),
+      usage: data.usageMetadata ? {
+        promptTokens: data.usageMetadata.promptTokenCount,
+        completionTokens: data.usageMetadata.candidatesTokenCount,
+        totalTokens: data.usageMetadata.totalTokenCount
+      } : void 0,
+      raw: data
+    });
+  }
+  if (events.length === 0) {
+    return null;
+  }
+  const firstEvent = events[0];
+  return events.length === 1 && firstEvent ? firstEvent : events;
+}
+
+// src/inbound/error-parser.ts
+function parseError(error) {
+  if (error && typeof error === "object" && "error" in error) {
+    const err = error.error;
+    return {
+      type: mapErrorType(err.status, err.code),
+      message: err.message,
+      code: err.status,
+      status: err.code,
+      raw: error
+    };
+  }
+  return {
+    type: "unknown",
+    message: String(error),
+    raw: error
+  };
+}
+function mapErrorType(status, code) {
+  if (code) {
+    const codeMap = {
+      400: "validation",
+      401: "authentication",
+      403: "permission",
+      404: "not_found",
+      429: "rate_limit",
+      500: "server"
+    };
+    if (codeMap[code]) return codeMap[code];
+  }
+  if (status) {
+    const statusMap = {
+      INVALID_ARGUMENT: "validation",
+      UNAUTHENTICATED: "authentication",
+      PERMISSION_DENIED: "permission",
+      NOT_FOUND: "not_found",
+      RESOURCE_EXHAUSTED: "rate_limit",
+      INTERNAL: "server"
+    };
+    if (statusMap[status]) return statusMap[status];
+  }
+  return "unknown";
+}
+
+// src/outbound/request-builder.ts
+function buildRequest(ir) {
+  const request = {
+    contents: []
+  };
+  if (ir.system) {
+    request.systemInstruction = {
+      parts: [{ text: ir.system }]
+    };
+  }
+  for (const msg of ir.messages) {
+    if (msg.role === "system") continue;
+    if (msg.role === "tool") {
+      const resultContent = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      request.contents.push({
+        role: "user",
+        parts: [{
+          functionResponse: {
+            name: msg.name ?? "unknown",
+            response: { result: resultContent }
+          }
+        }]
+      });
+      continue;
+    }
+    const content = buildContent(msg);
+    if (content) {
+      request.contents.push(content);
+    }
+  }
+  if (ir.tools && ir.tools.length > 0) {
+    request.tools = [
+      {
+        functionDeclarations: ir.tools.map((tool) => ({
+          name: tool.function.name,
+          description: tool.function.description,
+          parameters: tool.function.parameters ? {
+            type: tool.function.parameters.type ?? "object",
+            properties: tool.function.parameters.properties,
+            required: tool.function.parameters.required
+          } : void 0
+        }))
+      }
+    ];
+  }
+  if (ir.toolChoice) {
+    let mode = "AUTO";
+    if (ir.toolChoice === "none") mode = "NONE";
+    else if (ir.toolChoice === "required") mode = "ANY";
+    else if (ir.toolChoice === "auto") mode = "AUTO";
+    else if (typeof ir.toolChoice === "object") {
+      mode = "ANY";
+      request.toolConfig = {
+        functionCallingConfig: {
+          mode,
+          allowedFunctionNames: [ir.toolChoice.function.name]
+        }
+      };
+    }
+    if (!request.toolConfig) {
+      request.toolConfig = {
+        functionCallingConfig: { mode }
+      };
+    }
+  }
+  if (ir.generation) {
+    request.generationConfig = {};
+    if (ir.generation.temperature !== void 0) {
+      request.generationConfig.temperature = ir.generation.temperature;
+    }
+    if (ir.generation.topP !== void 0) {
+      request.generationConfig.topP = ir.generation.topP;
+    }
+    if (ir.generation.topK !== void 0) {
+      request.generationConfig.topK = ir.generation.topK;
+    }
+    if (ir.generation.maxTokens !== void 0) {
+      request.generationConfig.maxOutputTokens = ir.generation.maxTokens;
+    }
+    if (ir.generation.stopSequences && ir.generation.stopSequences.length > 0) {
+      request.generationConfig.stopSequences = ir.generation.stopSequences;
+    }
+    if (ir.generation.responseFormat?.type === "json_object") {
+      request.generationConfig.responseMimeType = "application/json";
+    }
+  }
+  return request;
+}
+function buildContent(msg) {
+  const role = msg.role === "assistant" ? "model" : "user";
+  const parts = [];
+  if (typeof msg.content === "string") {
+    if (msg.content) {
+      parts.push({ text: msg.content });
+    }
+  } else if (Array.isArray(msg.content)) {
+    for (const part of msg.content) {
+      if (part.type === "text") {
+        parts.push({ text: part.text });
+      } else if (part.type === "image") {
+        const imgPart = part;
+        if (imgPart.source.type === "base64") {
+          parts.push({
+            inlineData: {
+              mimeType: imgPart.source.mediaType,
+              data: imgPart.source.data
+            }
+          });
+        } else {
+          parts.push({
+            fileData: {
+              mimeType: "image/*",
+              fileUri: imgPart.source.url
+            }
+          });
+        }
+      }
+    }
+  }
+  if (msg.toolCalls && Array.isArray(msg.toolCalls)) {
+    for (const toolCall of msg.toolCalls) {
+      parts.push({
+        functionCall: {
+          name: toolCall.function.name,
+          args: JSON.parse(toolCall.function.arguments)
+        }
+      });
+    }
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return { role, parts };
+}
+
+// src/outbound/response-builder.ts
+function mapFinishReason3(reason) {
+  if (!reason) return "STOP";
+  const reasonMap = {
+    stop: "STOP",
+    length: "MAX_TOKENS",
+    tool_calls: "STOP",
+    content_filter: "SAFETY",
+    error: "OTHER"
+  };
+  return reasonMap[reason] ?? "STOP";
+}
+function buildResponse(ir) {
+  return {
+    candidates: ir.choices.map((choice) => ({
+      content: {
+        role: "model",
+        parts: buildParts(choice.message.content, choice.message.toolCalls)
+      },
+      finishReason: mapFinishReason3(choice.finishReason),
+      index: choice.index
+    })),
+    usageMetadata: ir.usage ? {
+      promptTokenCount: ir.usage.promptTokens,
+      candidatesTokenCount: ir.usage.completionTokens,
+      totalTokenCount: ir.usage.totalTokens,
+      cachedContentTokenCount: ir.usage.details?.cachedTokens
+    } : void 0,
+    responseId: ir.id,
+    modelVersion: ir.model
+  };
+}
+function buildParts(content, toolCalls) {
+  const parts = [];
+  if (typeof content === "string") {
+    if (content) {
+      parts.push({ text: content });
+    }
+  } else if (Array.isArray(content)) {
+    for (const part of content) {
+      if (part.type === "text") {
+        parts.push({ text: part.text });
+      }
+    }
+  }
+  if (toolCalls) {
+    for (const toolCall of toolCalls) {
+      parts.push({
+        functionCall: {
+          name: toolCall.function.name,
+          args: JSON.parse(toolCall.function.arguments)
+        }
+      });
+    }
+  }
+  return parts;
+}
+
+// src/outbound/stream-builder.ts
+function createStreamBuilder() {
+  let responseId = `gemini-${Date.now()}`;
+  let model = "";
+  return {
+    process(event) {
+      const events = [];
+      if (event.id) responseId = event.id;
+      if (event.model) model = event.model;
+      if (event.type === "start") {
+        return events;
+      }
+      if (event.type === "content" && event.content?.delta) {
+        events.push({
+          event: "data",
+          data: {
+            candidates: [{
+              content: {
+                role: "model",
+                parts: [{ text: event.content.delta }]
+              },
+              index: 0
+            }],
+            modelVersion: model,
+            responseId
+          }
+        });
+      }
+      if (event.type === "tool_call" && event.toolCall) {
+        if (event.toolCall.name) {
+          let args = {};
+          if (event.toolCall.arguments) {
+            try {
+              args = JSON.parse(event.toolCall.arguments);
+            } catch {
+              args = {};
+            }
+          }
+          events.push({
+            event: "data",
+            data: {
+              candidates: [{
+                content: {
+                  role: "model",
+                  parts: [{
+                    functionCall: {
+                      name: event.toolCall.name,
+                      args
+                    }
+                  }]
+                },
+                index: 0
+              }],
+              modelVersion: model,
+              responseId
+            }
+          });
+        }
+      }
+      if (event.type === "end") {
+        const finishReason = mapFinishReason4(event.finishReason);
+        const finalChunk = {
+          candidates: [{
+            content: {
+              role: "model",
+              parts: [{ text: "" }]
+            },
+            finishReason,
+            index: 0
+          }],
+          modelVersion: model,
+          responseId
+        };
+        if (event.usage) {
+          finalChunk.usageMetadata = {
+            promptTokenCount: event.usage.promptTokens ?? 0,
+            candidatesTokenCount: event.usage.completionTokens ?? 0,
+            totalTokenCount: event.usage.totalTokens ?? 0
+          };
+        }
+        events.push({ event: "data", data: finalChunk });
+      }
+      if (event.type === "error" && event.error) {
+        events.push({
+          event: "data",
+          data: {
+            error: {
+              code: 500,
+              message: event.error.message,
+              status: "INTERNAL"
+            }
+          }
+        });
+      }
+      return events;
+    }
+  };
+}
+function mapFinishReason4(reason) {
+  if (!reason) return "STOP";
+  const reasonMap = {
+    stop: "STOP",
+    length: "MAX_TOKENS",
+    tool_calls: "STOP",
+    content_filter: "SAFETY",
+    end_turn: "STOP",
+    max_tokens: "MAX_TOKENS"
+  };
+  return reasonMap[reason] ?? "STOP";
+}
+
+// src/adapter.ts
+var googleAdapter = {
+  name: "google",
+  version: "1.0.0",
+  capabilities: {
+    streaming: true,
+    tools: true,
+    vision: true,
+    multimodal: true,
+    // Supports images, audio, video, PDFs
+    systemPrompt: true,
+    // Via systemInstruction
+    toolChoice: true,
+    // Via functionCallingConfig
+    reasoning: false,
+    webSearch: false,
+    jsonMode: true,
+    logprobs: false,
+    seed: false
+  },
+  inbound: {
+    parseRequest: (request) => {
+      return parseRequest(request);
+    },
+    parseResponse: (response) => {
+      return parseResponse(response);
+    },
+    parseStream: (chunk) => {
+      return parseStream(chunk);
+    },
+    parseError: (error) => {
+      return parseError(error);
+    }
+  },
+  outbound: {
+    buildRequest: (ir) => {
+      return buildRequest(ir);
+    },
+    buildResponse: (ir) => {
+      return buildResponse(ir);
+    },
+    createStreamBuilder
+  },
+  getInfo() {
+    return {
+      name: this.name,
+      version: this.version,
+      capabilities: this.capabilities,
+      endpoint: {
+        baseUrl: "https://generativelanguage.googleapis.com",
+        chatPath: "/v1beta/models/{model}:streamGenerateContent",
+        // Use streaming endpoint
+        modelsPath: "/v1beta/models"
+      }
+    };
+  }
+};
+var geminiAdapter = googleAdapter;
+
+export { geminiAdapter, googleAdapter };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map