@amux.ai/adapter-deepseek 0.1.1

package/dist/index.cjs

@@ -0,0 +1,634 @@
+'use strict';
+
+var llmBridge = require('@amux.ai/llm-bridge');
+
+// src/inbound/request-parser.ts
+function parseRequest(request) {
+  const req = request;
+  let system;
+  const messages = [];
+  for (const msg of req.messages) {
+    if (msg.role === "system") {
+      if (typeof msg.content === "string") {
+        system = system ? `${system}
+${msg.content}` : msg.content;
+      }
+    } else {
+      messages.push(parseMessage(msg));
+    }
+  }
+  const tools = req.tools?.map((tool) => parseTool(tool));
+  const toolChoice = req.tool_choice ? parseToolChoice(req.tool_choice) : void 0;
+  return {
+    messages,
+    model: req.model,
+    tools,
+    toolChoice,
+    stream: req.stream,
+    system,
+    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,
+      presencePenalty: req.presence_penalty,
+      frequencyPenalty: req.frequency_penalty,
+      responseFormat: req.response_format ? { type: req.response_format.type } : void 0,
+      logprobs: req.logprobs,
+      topLogprobs: req.top_logprobs,
+      // DeepSeek-specific: thinking mode
+      thinking: req.thinking ? { enabled: req.thinking.type === "enabled" } : void 0
+    },
+    raw: request
+  };
+}
+function parseMessage(msg) {
+  return {
+    role: msg.role,
+    content: parseContent(msg.content),
+    name: msg.name,
+    toolCalls: msg.tool_calls,
+    toolCallId: msg.tool_call_id,
+    // DeepSeek-specific: reasoning content
+    reasoningContent: msg.reasoning_content
+  };
+}
+function parseContent(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") {
+      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 parseTool(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.function.name,
+      description: tool.function.description,
+      parameters: tool.function.parameters,
+      strict: tool.function.strict
+    }
+  };
+}
+function parseToolChoice(choice) {
+  if (typeof choice === "string") {
+    return choice;
+  }
+  return {
+    type: "function",
+    function: {
+      name: choice.function.name
+    }
+  };
+}
+function parseResponse(response) {
+  const res = response;
+  const choices = res.choices.map((choice) => ({
+    index: choice.index,
+    message: {
+      role: choice.message.role,
+      content: choice.message.content ?? "",
+      toolCalls: choice.message.tool_calls,
+      // DeepSeek-specific: reasoning content
+      reasoningContent: choice.message.reasoning_content
+    },
+    finishReason: llmBridge.mapFinishReason(choice.finish_reason),
+    logprobs: choice.logprobs
+  }));
+  return {
+    id: res.id,
+    model: res.model,
+    choices,
+    created: res.created,
+    systemFingerprint: res.system_fingerprint,
+    usage: res.usage ? {
+      promptTokens: res.usage.prompt_tokens,
+      completionTokens: res.usage.completion_tokens,
+      totalTokens: res.usage.total_tokens,
+      details: {
+        reasoningTokens: res.usage.completion_tokens_details?.reasoning_tokens,
+        // DeepSeek-specific: cache tokens
+        cachedTokens: res.usage.prompt_cache_hit_tokens
+      }
+    } : void 0,
+    // Store DeepSeek-specific cache info in extensions
+    extensions: res.usage?.prompt_cache_hit_tokens !== void 0 ? {
+      deepseek: {
+        promptCacheHitTokens: res.usage.prompt_cache_hit_tokens,
+        promptCacheMissTokens: res.usage.prompt_cache_miss_tokens
+      }
+    } : void 0,
+    raw: response
+  };
+}
+
+// src/inbound/stream-parser.ts
+function mapFinishReason2(reason) {
+  const reasonMap = {
+    stop: "stop",
+    length: "length",
+    tool_calls: "tool_calls",
+    content_filter: "content_filter",
+    insufficient_system_resource: "error"
+  };
+  return reasonMap[reason] ?? "stop";
+}
+function parseStream(chunk) {
+  const data = chunk;
+  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,
+          details: {
+            reasoningTokens: data.usage.completion_tokens_details?.reasoning_tokens,
+            cachedTokens: data.usage.prompt_cache_hit_tokens
+          }
+        },
+        raw: chunk
+      };
+    }
+    return null;
+  }
+  const choice = data.choices[0];
+  if (!choice) return null;
+  const delta = choice.delta;
+  const events = [];
+  if (delta.role && !delta.content && !delta.tool_calls && !delta.reasoning_content) {
+    return {
+      type: "start",
+      id: data.id,
+      model: data.model,
+      raw: chunk
+    };
+  }
+  if (delta.reasoning_content) {
+    events.push({
+      type: "reasoning",
+      id: data.id,
+      model: data.model,
+      reasoning: {
+        type: "reasoning",
+        delta: delta.reasoning_content,
+        index: choice.index
+      },
+      raw: chunk
+    });
+  }
+  if (delta.content) {
+    events.push({
+      type: "content",
+      id: data.id,
+      model: data.model,
+      content: {
+        type: "content",
+        delta: delta.content,
+        index: choice.index
+      },
+      raw: chunk
+    });
+  }
+  if (delta.tool_calls && delta.tool_calls.length > 0) {
+    const toolCall = delta.tool_calls[0];
+    if (toolCall) {
+      events.push({
+        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: chunk
+      });
+    }
+  }
+  if (choice.finish_reason) {
+    events.push({
+      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,
+        details: {
+          reasoningTokens: data.usage.completion_tokens_details?.reasoning_tokens,
+          cachedTokens: data.usage.prompt_cache_hit_tokens
+        }
+      } : void 0,
+      raw: chunk
+    });
+  }
+  if (events.length === 0) {
+    return null;
+  }
+  const firstEvent = events[0];
+  return events.length === 1 && firstEvent ? firstEvent : events;
+}
+function parseError(error) {
+  return llmBridge.parseOpenAICompatibleError(error);
+}
+
+// src/outbound/request-builder.ts
+function buildRequest(ir) {
+  const messages = [];
+  const isReasonerModel = ir.model?.includes("reasoner");
+  if (ir.system && !isReasonerModel) {
+    messages.push({
+      role: "system",
+      content: ir.system
+    });
+  }
+  for (const msg of ir.messages) {
+    if (isReasonerModel && msg.role === "system") {
+      continue;
+    }
+    const message = {
+      role: msg.role,
+      content: buildContent(msg.content),
+      name: msg.name,
+      tool_calls: msg.toolCalls,
+      tool_call_id: msg.toolCallId
+    };
+    if (!isReasonerModel && msg.reasoningContent !== void 0) {
+      message.reasoning_content = msg.reasoningContent;
+    }
+    messages.push(message);
+  }
+  const request = {
+    model: ir.model ?? "deepseek-chat",
+    messages,
+    stream: ir.stream
+  };
+  if (ir.tools && ir.tools.length > 0) {
+    request.tools = ir.tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.function.name,
+        description: tool.function.description,
+        parameters: tool.function.parameters,
+        strict: tool.function.strict
+      }
+    }));
+  }
+  if (ir.toolChoice) {
+    request.tool_choice = ir.toolChoice;
+  }
+  if (ir.generation) {
+    if (ir.generation.temperature !== void 0) {
+      request.temperature = ir.generation.temperature;
+    }
+    if (ir.generation.topP !== void 0) {
+      request.top_p = ir.generation.topP;
+    }
+    if (ir.generation.maxTokens !== void 0) {
+      request.max_tokens = Math.min(Math.max(ir.generation.maxTokens, 1), 8192);
+    }
+    if (ir.generation.stopSequences && ir.generation.stopSequences.length > 0) {
+      request.stop = ir.generation.stopSequences;
+    }
+    if (ir.generation.presencePenalty !== void 0) {
+      request.presence_penalty = ir.generation.presencePenalty;
+    }
+    if (ir.generation.frequencyPenalty !== void 0) {
+      request.frequency_penalty = ir.generation.frequencyPenalty;
+    }
+    if (ir.generation.responseFormat) {
+      if (ir.generation.responseFormat.type === "json_object") {
+        request.response_format = { type: "json_object" };
+      }
+    }
+    if (ir.generation.logprobs !== void 0) {
+      request.logprobs = ir.generation.logprobs;
+    }
+    if (ir.generation.topLogprobs !== void 0) {
+      request.top_logprobs = ir.generation.topLogprobs;
+    }
+    if (ir.generation.thinking) {
+      request.thinking = {
+        type: ir.generation.thinking.enabled ? "enabled" : "disabled"
+      };
+    }
+  }
+  if (ir.stream) {
+    request.stream_options = { include_usage: true };
+  }
+  return request;
+}
+function buildContent(content) {
+  if (typeof content === "string") {
+    return content || null;
+  }
+  if (!content || content.length === 0) {
+    return null;
+  }
+  const allText = content.every((part) => part.type === "text");
+  if (allText) {
+    return content.map((part) => part.type === "text" ? part.text : "").join("");
+  }
+  return content.map((part) => {
+    if (part.type === "text") {
+      return { type: "text", text: part.text };
+    }
+    if (part.type === "image") {
+      const imgPart = part;
+      if (imgPart.source.type === "url") {
+        return {
+          type: "image_url",
+          image_url: { url: imgPart.source.url }
+        };
+      }
+      return {
+        type: "image_url",
+        image_url: {
+          url: `data:${imgPart.source.mediaType};base64,${imgPart.source.data}`
+        }
+      };
+    }
+    return { type: "text", text: JSON.stringify(part) };
+  });
+}
+function buildResponse(ir) {
+  return {
+    id: ir.id,
+    object: "chat.completion",
+    created: ir.created ?? Math.floor(Date.now() / 1e3),
+    model: ir.model,
+    system_fingerprint: ir.systemFingerprint,
+    choices: ir.choices.map((choice) => ({
+      index: choice.index,
+      message: {
+        role: choice.message.role,
+        content: llmBridge.contentToString(choice.message.content),
+        tool_calls: choice.message.toolCalls,
+        // DeepSeek-specific: reasoning content
+        reasoning_content: choice.message.reasoningContent
+      },
+      finish_reason: choice.finishReason ?? "stop",
+      logprobs: choice.logprobs
+    })),
+    usage: ir.usage ? {
+      prompt_tokens: ir.usage.promptTokens,
+      completion_tokens: ir.usage.completionTokens,
+      total_tokens: ir.usage.totalTokens,
+      // DeepSeek-specific: cache tokens
+      prompt_cache_hit_tokens: ir.usage.details?.cachedTokens,
+      prompt_cache_miss_tokens: ir.extensions?.deepseek?.promptCacheMissTokens,
+      completion_tokens_details: ir.usage.details?.reasoningTokens ? {
+        reasoning_tokens: ir.usage.details.reasoningTokens
+      } : void 0
+    } : void 0
+  };
+}
+
+// src/outbound/stream-builder.ts
+function createStreamBuilder() {
+  let chunkId = `chatcmpl-${Date.now()}`;
+  let model = "";
+  let created = Math.floor(Date.now() / 1e3);
+  const toolCallsState = /* @__PURE__ */ new Map();
+  return {
+    process(event) {
+      const events = [];
+      if (event.id) chunkId = event.id;
+      if (event.model) model = event.model;
+      if (event.type === "start") {
+        events.push({
+          event: "data",
+          data: {
+            id: chunkId,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{
+              index: 0,
+              delta: { role: "assistant", content: "" },
+              finish_reason: null
+            }]
+          }
+        });
+      }
+      if (event.type === "content" && event.content?.delta) {
+        events.push({
+          event: "data",
+          data: {
+            id: chunkId,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{
+              index: 0,
+              delta: { content: event.content.delta },
+              finish_reason: null
+            }]
+          }
+        });
+      }
+      if (event.type === "reasoning" && event.reasoning?.delta) {
+        events.push({
+          event: "data",
+          data: {
+            id: chunkId,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{
+              index: 0,
+              delta: { reasoning_content: event.reasoning.delta },
+              finish_reason: null
+            }]
+          }
+        });
+      }
+      if (event.type === "tool_call" && event.toolCall) {
+        const toolIndex = event.toolCall.index ?? 0;
+        const toolCallDelta = { index: toolIndex };
+        if (event.toolCall.name) {
+          toolCallDelta.id = event.toolCall.id || `call_${Date.now()}_${toolIndex}`;
+          toolCallDelta.type = "function";
+          toolCallDelta.function = { name: event.toolCall.name };
+          toolCallsState.set(toolIndex, {
+            id: toolCallDelta.id,
+            name: event.toolCall.name
+          });
+        }
+        if (event.toolCall.arguments) {
+          toolCallDelta.function = {
+            ...toolCallDelta.function,
+            arguments: event.toolCall.arguments
+          };
+        }
+        events.push({
+          event: "data",
+          data: {
+            id: chunkId,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{
+              index: 0,
+              delta: { tool_calls: [toolCallDelta] },
+              finish_reason: null
+            }]
+          }
+        });
+      }
+      if (event.type === "end") {
+        const finishReason = mapFinishReason3(event.finishReason);
+        const finalChunk = {
+          id: chunkId,
+          object: "chat.completion.chunk",
+          created,
+          model,
+          choices: [{
+            index: 0,
+            delta: {},
+            finish_reason: finishReason
+          }]
+        };
+        if (event.usage) {
+          finalChunk.usage = {
+            prompt_tokens: event.usage.promptTokens ?? 0,
+            completion_tokens: event.usage.completionTokens ?? 0,
+            total_tokens: event.usage.totalTokens ?? 0
+          };
+        }
+        events.push({ event: "data", data: finalChunk });
+      }
+      if (event.type === "error" && event.error) {
+        events.push({
+          event: "data",
+          data: {
+            error: {
+              message: event.error.message,
+              type: "server_error",
+              code: event.error.code
+            }
+          }
+        });
+      }
+      return events;
+    },
+    finalize() {
+      return [{ event: "data", data: "[DONE]" }];
+    }
+  };
+}
+function mapFinishReason3(reason) {
+  if (!reason) return "stop";
+  const reasonMap = {
+    stop: "stop",
+    length: "length",
+    tool_calls: "tool_calls",
+    content_filter: "content_filter",
+    end_turn: "stop",
+    max_tokens: "length"
+  };
+  return reasonMap[reason] ?? "stop";
+}
+
+// src/adapter.ts
+var deepseekAdapter = {
+  name: "deepseek",
+  version: "1.0.0",
+  capabilities: {
+    streaming: true,
+    tools: true,
+    vision: false,
+    multimodal: false,
+    systemPrompt: true,
+    toolChoice: true,
+    reasoning: true,
+    // DeepSeek-reasoner supports reasoning
+    webSearch: false,
+    jsonMode: true,
+    logprobs: true,
+    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.deepseek.com",
+        chatPath: "/v1/chat/completions",
+        modelsPath: "/v1/models"
+      }
+    };
+  }
+};
+
+exports.deepseekAdapter = deepseekAdapter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map