"""Provide service-layer logic for deepseek client. P0-0: ``chat()`` now accepts an optional ``tools`` list and parses ``tool_calls`` from the model response so that callers can dispatch tool invocations. """ import time from typing import List, Dict, Optional, Generator from loguru import logger import httpx from .base_client import BaseLLMClient, LLMResponse, LLMConfig, LLMProvider from .tool_types import Tool, ToolCall # Keep provider-specific behavior explicit so debugging stays straightforward. class DeepSeekClient(BaseLLMClient): """Represent the Deep Seek Client type.""" SUPPORTED_MODELS = [ "deepseek-chat", "deepseek-coder", "deepseek-reasoner", "deepseek-v3", "deepseek-v3.2", "deepseek-v4-flash" ] def __init__(self, config: LLMConfig): """Initialize the Deep Seek Client instance.""" if config.provider != LLMProvider.DEEPSEEK: raise ValueError(f"配置provider应为DEEPSEEK，实际为{config.provider}") super().__init__(config) self._init_client() def _init_client(self): """Handle init client for this module for the Deep Seek Client instance.""" self._client = httpx.Client( base_url=self.config.base_url, headers={ "Authorization": f"Bearer {self.config.api_key}", "Content-Type": "application/json" }, timeout=self.config.timeout ) logger.info(f"DeepSeek客户端初始化完成: {self.config.base_url} - {self.config.model}") def chat( self, messages: List[Dict[str, str]], max_tokens: Optional[int] = None, temperature: Optional[float] = None, tools: Optional[List[Tool]] = None, **kwargs ) -> LLMResponse: """Handle chat for the Deep Seek Client instance. When ``tools`` is provided the request includes the tool definitions and ``tool_choice="auto"``; any tool_calls returned by the model are parsed into ``LLMResponse.tool_calls``. """ import json start_time = time.time() try: payload: Dict = { "model": self.config.model, "messages": messages, "max_tokens": max_tokens or self.config.max_tokens, "temperature": temperature or self.config.temperature, "top_p": kwargs.get("top_p", self.config.top_p), "stream": False } # P0-0: inject tool definitions when provided. if tools: payload["tools"] = [t.to_openai_format() for t in tools] payload["tool_choice"] = "auto" response = self._client.post("/chat/completions", json=payload) response.raise_for_status() data = response.json() latency_ms = int((time.time() - start_time) * 1000) choices = data.get("choices", [{}]) message = choices[0].get("message", {}) # P0-0: parse tool_calls returned by the model. raw_tool_calls = message.get("tool_calls") or [] parsed_tool_calls: List[ToolCall] = [] for tc in raw_tool_calls: fn = tc.get("function", {}) try: args = json.loads(fn.get("arguments", "{}")) except json.JSONDecodeError: args = {} parsed_tool_calls.append(ToolCall(id=tc.get("id", ""), name=fn.get("name", ""), arguments=args)) return LLMResponse( content=message.get("content", "") or "", model=data.get("model", self.config.model), usage=data.get("usage", {}), finish_reason=choices[0].get("finish_reason", "stop"), latency_ms=latency_ms, tool_calls=parsed_tool_calls, ) except httpx.HTTPStatusError as e: logger.error(f"DeepSeek API错误: {e.response.status_code} - {e.response.text}") return LLMResponse( content="", model=self.config.model, error=f"API错误: {e.response.status_code} - {e.response.text[:200]}" ) except Exception as e: logger.error(f"DeepSeek调用失败: {e}") return LLMResponse( content="", model=self.config.model, error=str(e) ) def stream_chat( self, messages: List[Dict[str, str]], max_tokens: Optional[int] = None, temperature: Optional[float] = None, **kwargs ) -> Generator[str, None, Optional[Dict[str, int]]]: """Stream chat for the Deep Seek Client instance. Returns the trailing token-usage dict as the generator's return value (read via StopIteration.value when manually driven with next()) when the gateway sends one via stream_options.include_usage, else None. """ usage: Optional[Dict[str, int]] = None try: payload = { "model": self.config.model, "messages": messages, "max_tokens": max_tokens or self.config.max_tokens, "temperature": temperature or self.config.temperature, "top_p": kwargs.get("top_p", self.config.top_p), "stream": True, "stream_options": {"include_usage": True} } with self._client.stream("POST", "/chat/completions", json=payload) as response: response.raise_for_status() for line in response.iter_lines(): if not line: continue line = line.strip() if line.startswith(":"): continue if not line.startswith("data: "): continue data_str = line[6:] if data_str == "[DONE]": break try: import json data = json.loads(data_str) choices = data.get("choices", []) if choices: delta = choices[0].get("delta", {}) content = delta.get("content", "") if content: yield content elif data.get("usage"): # Trailing usage-only chunk — no content to yield, just capture it. usage = data["usage"] except json.JSONDecodeError: continue except httpx.HTTPStatusError as e: logger.error(f"DeepSeek Stream API错误: {e.response.status_code}") yield "" except Exception as e: logger.error(f"DeepSeek Stream调用失败: {e}") yield "" return usage def get_available_models(self) -> List[str]: """Return available models for the Deep Seek Client instance.""" return self.SUPPORTED_MODELS def close(self): """Release the resources held by this component.""" if self._client: self._client.close() def create_deepseek_client( api_key: str, model: str = "deepseek-v4-flash", base_url: str = "http://6.86.80.4:30080/v1", **kwargs ) -> DeepSeekClient: """Create deepseek client.""" config = LLMConfig( provider=LLMProvider.DEEPSEEK, model=model, api_key=api_key, base_url=base_url, **kwargs ) return DeepSeekClient(config)