@amux.ai/adapter-anthropic 0.1.1

package/dist/index.cjs

@@ -0,0 +1,724 @@
+'use strict';
+
+// src/inbound/request-parser.ts
+function parseRequest(request) {
+  const req = request;
+  const messages = [];
+  for (const msg of req.messages) {
+    const parsed = parseMessage(msg);
+    messages.push(...parsed);
+  }
+  return {
+    messages,
+    model: req.model,
+    // Set system directly in IR instead of adding to messages
+    system: req.system,
+    tools: req.tools?.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema
+      }
+    })),
+    toolChoice: req.tool_choice ? req.tool_choice.type === "any" ? "required" : req.tool_choice.type === "auto" ? "auto" : req.tool_choice.name ? { type: "function", function: { name: req.tool_choice.name } } : void 0 : void 0,
+    stream: req.stream,
+    generation: {
+      maxTokens: req.max_tokens,
+      temperature: req.temperature,
+      topP: req.top_p,
+      topK: req.top_k,
+      stopSequences: req.stop_sequences
+    },
+    metadata: {
+      userId: req.metadata?.user_id
+    },
+    raw: request
+  };
+}
+function parseMessage(msg) {
+  if (typeof msg.content === "string") {
+    return [{
+      role: msg.role,
+      content: msg.content
+    }];
+  }
+  const contentParts = [];
+  const toolCalls = [];
+  const toolResults = [];
+  for (const part of msg.content) {
+    if (part.type === "tool_use") {
+      toolCalls.push({
+        id: part.id,
+        type: "function",
+        function: {
+          name: part.name,
+          arguments: JSON.stringify(part.input)
+        }
+      });
+    } else if (part.type === "tool_result") {
+      toolResults.push({
+        role: "tool",
+        content: typeof part.content === "string" ? part.content : JSON.stringify(part.content),
+        toolCallId: part.tool_use_id
+      });
+    } else {
+      contentParts.push(parseContentPart(part));
+    }
+  }
+  const messages = [];
+  if (contentParts.length > 0 || toolCalls.length > 0) {
+    const message = {
+      role: msg.role,
+      content: contentParts.length === 1 && contentParts[0]?.type === "text" ? contentParts[0].text : contentParts.length > 0 ? contentParts : ""
+    };
+    if (toolCalls.length > 0) {
+      message.toolCalls = toolCalls;
+    }
+    messages.push(message);
+  }
+  messages.push(...toolResults);
+  return messages;
+}
+function parseContentPart(part) {
+  switch (part.type) {
+    case "text":
+      return {
+        type: "text",
+        text: part.text
+      };
+    case "image":
+      return {
+        type: "image",
+        source: part.source.data ? {
+          type: "base64",
+          mediaType: part.source.media_type ?? "image/jpeg",
+          data: part.source.data
+        } : {
+          type: "url",
+          url: part.source.url ?? ""
+        }
+      };
+    default:
+      return {
+        type: "text",
+        text: JSON.stringify(part)
+      };
+  }
+}
+
+// src/inbound/response-parser.ts
+function parseResponse(response) {
+  const res = response;
+  const contentParts = [];
+  const toolCalls = [];
+  for (const part of res.content) {
+    if (part.type === "tool_use") {
+      toolCalls.push({
+        id: part.id,
+        type: "function",
+        function: {
+          name: part.name,
+          arguments: JSON.stringify(part.input)
+        }
+      });
+    } else {
+      contentParts.push(parseContentPart2(part));
+    }
+  }
+  const message = {
+    role: "assistant",
+    content: contentParts.length === 1 && contentParts[0]?.type === "text" ? contentParts[0].text : contentParts.length > 0 ? contentParts : ""
+  };
+  if (toolCalls.length > 0) {
+    message.toolCalls = toolCalls;
+  }
+  const choice = {
+    index: 0,
+    message,
+    finishReason: mapStopReason(res.stop_reason)
+  };
+  return {
+    id: res.id,
+    model: res.model,
+    choices: [choice],
+    usage: {
+      promptTokens: res.usage.input_tokens,
+      completionTokens: res.usage.output_tokens,
+      totalTokens: res.usage.input_tokens + res.usage.output_tokens
+    },
+    raw: response
+  };
+}
+function parseContentPart2(part) {
+  switch (part.type) {
+    case "text":
+      return {
+        type: "text",
+        text: part.text
+      };
+    default:
+      return {
+        type: "text",
+        text: JSON.stringify(part)
+      };
+  }
+}
+function mapStopReason(reason) {
+  if (!reason) return "stop";
+  const reasonMap = {
+    "end_turn": "stop",
+    "max_tokens": "length",
+    "stop_sequence": "stop",
+    "tool_use": "tool_calls"
+  };
+  return reasonMap[reason] ?? "stop";
+}
+
+// src/inbound/stream-parser.ts
+function parseStream(chunk) {
+  const event = chunk;
+  switch (event.type) {
+    case "message_start":
+      return {
+        type: "start",
+        id: event.message?.id,
+        model: event.message?.model,
+        raw: chunk
+      };
+    case "content_block_start":
+      if (event.content_block?.type === "text") {
+        return {
+          type: "content",
+          content: {
+            type: "content",
+            delta: "",
+            index: event.index
+          },
+          raw: chunk
+        };
+      }
+      if (event.content_block?.type === "tool_use") {
+        return {
+          type: "tool_call",
+          toolCall: {
+            type: "tool_call",
+            id: event.content_block.id,
+            name: event.content_block.name,
+            index: event.index
+          },
+          raw: chunk
+        };
+      }
+      return null;
+    case "content_block_delta":
+      if (event.delta?.type === "text_delta" && event.delta.text !== void 0) {
+        return {
+          type: "content",
+          content: {
+            type: "content",
+            delta: event.delta.text,
+            index: event.index
+          },
+          raw: chunk
+        };
+      }
+      if (event.delta?.type === "input_json_delta" && event.delta.partial_json !== void 0) {
+        return {
+          type: "tool_call",
+          toolCall: {
+            type: "tool_call",
+            arguments: event.delta.partial_json,
+            index: event.index
+          },
+          raw: chunk
+        };
+      }
+      return null;
+    case "content_block_stop":
+      return null;
+    case "message_delta":
+      if (event.delta?.stop_reason) {
+        return {
+          type: "end",
+          finishReason: mapStopReason2(event.delta.stop_reason),
+          raw: chunk
+        };
+      }
+      return null;
+    case "message_stop":
+      return {
+        type: "end",
+        raw: chunk
+      };
+    default:
+      return null;
+  }
+}
+function mapStopReason2(reason) {
+  const reasonMap = {
+    "end_turn": "stop",
+    "max_tokens": "length",
+    "stop_sequence": "stop",
+    "tool_use": "tool_calls"
+  };
+  return reasonMap[reason] ?? "stop";
+}
+
+// src/inbound/error-parser.ts
+function parseError(error) {
+  if (error && typeof error === "object") {
+    if ("type" in error && error.type === "error" && "error" in error) {
+      const err = error.error;
+      return {
+        type: mapErrorType(err.type),
+        message: err.message,
+        code: err.type,
+        raw: error
+      };
+    }
+    if ("error" in error) {
+      const err = error.error;
+      return {
+        type: mapErrorType(err.type),
+        message: err.message,
+        code: err.type,
+        raw: error
+      };
+    }
+  }
+  return {
+    type: "unknown",
+    message: String(error),
+    raw: error
+  };
+}
+function mapErrorType(type) {
+  if (!type) return "unknown";
+  const typeMap = {
+    invalid_request_error: "validation",
+    authentication_error: "authentication",
+    permission_error: "permission",
+    not_found_error: "not_found",
+    rate_limit_error: "rate_limit",
+    api_error: "api",
+    overloaded_error: "server"
+  };
+  return typeMap[type] ?? "unknown";
+}
+
+// src/outbound/request-builder.ts
+function buildRequest(ir) {
+  let system = ir.system;
+  const messages = [];
+  for (const msg of ir.messages) {
+    if (msg.role === "system") {
+      if (!system) {
+        system = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      }
+    } else {
+      messages.push(msg);
+    }
+  }
+  return {
+    model: ir.model ?? "claude-3-5-sonnet-20241022",
+    messages: messages.map((msg) => buildMessage(msg)),
+    system,
+    tools: ir.tools?.map((tool) => ({
+      name: tool.function.name,
+      description: tool.function.description,
+      input_schema: tool.function.parameters ?? { type: "object", properties: {} }
+    })),
+    tool_choice: ir.toolChoice ? typeof ir.toolChoice === "string" ? ir.toolChoice === "required" ? { type: "any" } : { type: ir.toolChoice } : { type: "tool", name: ir.toolChoice.function.name } : void 0,
+    max_tokens: ir.generation?.maxTokens ?? 4096,
+    temperature: ir.generation?.temperature,
+    top_p: ir.generation?.topP,
+    top_k: ir.generation?.topK,
+    stop_sequences: ir.generation?.stopSequences,
+    stream: ir.stream,
+    metadata: ir.metadata?.userId ? {
+      user_id: ir.metadata.userId
+    } : void 0
+  };
+}
+function buildMessage(msg) {
+  const content = [];
+  if (typeof msg.content === "string") {
+    if (msg.content) {
+      content.push({ type: "text", text: msg.content });
+    }
+  } else if (Array.isArray(msg.content)) {
+    for (const part of msg.content) {
+      content.push(buildContentPart(part));
+    }
+  }
+  if (msg.role === "tool" && msg.toolCallId) {
+    const resultContent = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    return {
+      role: "user",
+      content: [{
+        type: "tool_result",
+        tool_use_id: msg.toolCallId,
+        content: resultContent
+      }]
+    };
+  }
+  if (msg.toolCalls && msg.toolCalls.length > 0) {
+    for (const toolCall of msg.toolCalls) {
+      content.push({
+        type: "tool_use",
+        id: toolCall.id,
+        name: toolCall.function.name,
+        input: JSON.parse(toolCall.function.arguments)
+      });
+    }
+  }
+  if (content.length === 0) {
+    content.push({ type: "text", text: "" });
+  }
+  const firstContent = content[0];
+  const simplifiedContent = content.length === 1 && firstContent?.type === "text" ? firstContent.text : content;
+  return {
+    role: msg.role === "user" ? "user" : "assistant",
+    content: simplifiedContent
+  };
+}
+function buildContentPart(part) {
+  switch (part.type) {
+    case "text":
+      return {
+        type: "text",
+        text: part.text
+      };
+    case "image":
+      return {
+        type: "image",
+        source: part.source.type === "base64" ? {
+          type: "base64",
+          media_type: part.source.mediaType,
+          data: part.source.data
+        } : {
+          type: "url",
+          url: part.source.url
+        }
+      };
+    default:
+      return {
+        type: "text",
+        text: JSON.stringify(part)
+      };
+  }
+}
+
+// src/outbound/response-builder.ts
+function buildResponse(ir) {
+  const choice = ir.choices[0];
+  if (!choice) {
+    throw new Error("No choices in response");
+  }
+  const content = buildContent(choice.message);
+  return {
+    id: ir.id,
+    type: "message",
+    role: "assistant",
+    content,
+    model: ir.model,
+    stop_reason: mapFinishReason(choice.finishReason),
+    stop_sequence: null,
+    usage: {
+      input_tokens: ir.usage?.promptTokens ?? 0,
+      output_tokens: ir.usage?.completionTokens ?? 0
+    }
+  };
+}
+function buildContent(message) {
+  const content = [];
+  if (typeof message.content === "string") {
+    if (message.content) {
+      content.push({ type: "text", text: message.content });
+    }
+  } else if (Array.isArray(message.content)) {
+    for (const part of message.content) {
+      content.push(buildContentPart2(part));
+    }
+  }
+  if (message.toolCalls && message.toolCalls.length > 0) {
+    for (const toolCall of message.toolCalls) {
+      content.push({
+        type: "tool_use",
+        id: toolCall.id,
+        name: toolCall.function.name,
+        input: JSON.parse(toolCall.function.arguments)
+      });
+    }
+  }
+  if (content.length === 0) {
+    content.push({ type: "text", text: "" });
+  }
+  return content;
+}
+function buildContentPart2(part) {
+  switch (part.type) {
+    case "text":
+      return {
+        type: "text",
+        text: part.text
+      };
+    default:
+      return {
+        type: "text",
+        text: JSON.stringify(part)
+      };
+  }
+}
+function mapFinishReason(reason) {
+  if (!reason) return "end_turn";
+  const reasonMap = {
+    "stop": "end_turn",
+    "length": "max_tokens",
+    "tool_calls": "tool_use"
+  };
+  return reasonMap[reason] ?? "end_turn";
+}
+
+// src/outbound/stream-builder.ts
+function createStreamBuilder() {
+  let hasStarted = false;
+  let messageId = `msg_${Date.now()}`;
+  let model = "";
+  let contentIndex = 0;
+  let currentBlockType = null;
+  let outputTokens = 0;
+  return {
+    process(event) {
+      const events = [];
+      const ensureStarted = () => {
+        if (!hasStarted) {
+          hasStarted = true;
+          if (event.id) messageId = event.id;
+          if (event.model) model = event.model;
+          events.push({
+            event: "message_start",
+            data: {
+              type: "message_start",
+              message: {
+                id: messageId,
+                type: "message",
+                role: "assistant",
+                content: [],
+                model,
+                stop_reason: null,
+                stop_sequence: null,
+                usage: { input_tokens: 0, output_tokens: 0 }
+              }
+            }
+          });
+        }
+      };
+      if (event.type === "start") {
+        ensureStarted();
+      }
+      if (event.type === "reasoning" && event.reasoning?.delta) {
+        ensureStarted();
+        if (currentBlockType !== "thinking") {
+          if (currentBlockType !== null) {
+            events.push({
+              event: "content_block_stop",
+              data: { type: "content_block_stop", index: contentIndex }
+            });
+            contentIndex++;
+          }
+          events.push({
+            event: "content_block_start",
+            data: {
+              type: "content_block_start",
+              index: contentIndex,
+              content_block: { type: "thinking", thinking: "" }
+            }
+          });
+          currentBlockType = "thinking";
+        }
+        events.push({
+          event: "content_block_delta",
+          data: {
+            type: "content_block_delta",
+            index: contentIndex,
+            delta: { type: "thinking_delta", thinking: event.reasoning.delta }
+          }
+        });
+      }
+      if (event.type === "content" && event.content?.delta) {
+        ensureStarted();
+        if (currentBlockType !== "text") {
+          if (currentBlockType !== null) {
+            events.push({
+              event: "content_block_stop",
+              data: { type: "content_block_stop", index: contentIndex }
+            });
+            contentIndex++;
+          }
+          events.push({
+            event: "content_block_start",
+            data: {
+              type: "content_block_start",
+              index: contentIndex,
+              content_block: { type: "text", text: "" }
+            }
+          });
+          currentBlockType = "text";
+        }
+        events.push({
+          event: "content_block_delta",
+          data: {
+            type: "content_block_delta",
+            index: contentIndex,
+            delta: { type: "text_delta", text: event.content.delta }
+          }
+        });
+      }
+      if (event.type === "tool_call" && event.toolCall) {
+        ensureStarted();
+        if (event.toolCall.name) {
+          if (currentBlockType !== null) {
+            events.push({
+              event: "content_block_stop",
+              data: { type: "content_block_stop", index: contentIndex }
+            });
+            contentIndex++;
+          }
+          events.push({
+            event: "content_block_start",
+            data: {
+              type: "content_block_start",
+              index: contentIndex,
+              content_block: {
+                type: "tool_use",
+                id: event.toolCall.id || `toolu_${Date.now()}`,
+                name: event.toolCall.name,
+                input: {}
+              }
+            }
+          });
+          currentBlockType = "tool_use";
+        }
+        if (event.toolCall.arguments) {
+          events.push({
+            event: "content_block_delta",
+            data: {
+              type: "content_block_delta",
+              index: contentIndex,
+              delta: { type: "input_json_delta", partial_json: event.toolCall.arguments }
+            }
+          });
+        }
+      }
+      if (event.type === "end") {
+        if (event.usage) {
+          if (event.usage.completionTokens) outputTokens = event.usage.completionTokens;
+        }
+        if (currentBlockType !== null) {
+          events.push({
+            event: "content_block_stop",
+            data: { type: "content_block_stop", index: contentIndex }
+          });
+        }
+        const stopReason = mapFinishReason2(event.finishReason);
+        events.push({
+          event: "message_delta",
+          data: {
+            type: "message_delta",
+            delta: { stop_reason: stopReason, stop_sequence: null },
+            usage: { output_tokens: outputTokens }
+          }
+        });
+        events.push({
+          event: "message_stop",
+          data: { type: "message_stop" }
+        });
+      }
+      if (event.type === "error" && event.error) {
+        events.push({
+          event: "error",
+          data: {
+            type: "error",
+            error: {
+              type: "api_error",
+              message: event.error.message
+            }
+          }
+        });
+      }
+      return events;
+    }
+  };
+}
+function mapFinishReason2(reason) {
+  if (!reason) return "end_turn";
+  const reasonMap = {
+    stop: "end_turn",
+    length: "max_tokens",
+    tool_calls: "tool_use",
+    content_filter: "end_turn"
+  };
+  return reasonMap[reason] ?? "end_turn";
+}
+
+// src/adapter.ts
+var anthropicAdapter = {
+  name: "anthropic",
+  version: "1.0.0",
+  capabilities: {
+    streaming: true,
+    tools: true,
+    vision: true,
+    multimodal: true,
+    systemPrompt: true,
+    toolChoice: true,
+    reasoning: true,
+    // Extended thinking
+    webSearch: false,
+    jsonMode: false,
+    // Anthropic doesn't have native JSON mode
+    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://api.anthropic.com",
+        chatPath: "/v1/messages",
+        modelsPath: "/v1/models"
+      }
+    };
+  }
+};
+
+exports.anthropicAdapter = anthropicAdapter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map