add Deepseek v3 api

[khanfar]

hi , we need add deepseek v3 api

[khanfar]

import aiohttp
import json
import logging
from typing import Dict, List, Optional, Tuple
from plugin_manager import PluginManager

class DeepSeekHelper:
def init(self, config: dict, plugin_manager: PluginManager):
self.api_key = config.get('api_key')
if not self.api_key:
raise ValueError("DeepSeek API key is required")

    print(f"Initializing DeepSeek helper with API key: {self.api_key[:4]}...{self.api_key[-4:]}")
    self.api_url = 'https://api.deepseek.com/v1/chat/completions'
    self.plugin_manager = plugin_manager
    self.dialog_context = {}
    self.system_prompt = """You are a helpful AI assistant. Follow these guidelines:

1. Always respond with complete sentences

2. Avoid using emojis or symbols as responses

3. Provide clear and informative answers

4. Maintain a professional yet friendly tone

5. If unsure about an answer, say "I'm not sure about that" instead of using symbols"""

   async def get_chat_response(self, chat_id: int, query: str) -> Tuple[str, int]:
   """Get chat response from DeepSeek API"""
   if chat_id not in self.dialog_context:
   self.dialog_context[chat_id] = []

    self.dialog_context[chat_id].append({'role': 'user', 'content': query})
    
    headers = {
        'Authorization': f'Bearer {self.api_key}',
        'Content-Type': 'application/json'
    }
    
    data = {
        'model': 'deepseek-chat',
        'messages': self.dialog_context[chat_id],
        'temperature': 0.7,
        'max_tokens': 1000,
        'top_p': 1.0,
        'frequency_penalty': 0.0,
        'presence_penalty': 0.0,
        'stream': False
    }
    
    try:
        async with aiohttp.ClientSession() as session:
            async with session.post(self.api_url, headers=headers, json=data) as response:
                # Log the request details for debugging
                print(f"Request URL: {self.api_url}")
                print(f"Request Headers: {headers}")
                print(f"Request Payload: {json.dumps(data, indent=2)}")
                
                try:
                    response.raise_for_status()
                    response_data = await response.json()
                    
                    # Log successful response
                    print(f"Response Status: {response.status}")
                    print(f"Response Data: {json.dumps(response_data, indent=2)}")
                except Exception as e:
                    print(f"API Request Failed: {str(e)}")
                    print(f"Response Status: {response.status}")
                    try:
                        error_details = await response.json()
                        print(f"Error Details: {json.dumps(error_details, indent=2)}")
                    except Exception as json_error:
                        print(f"Failed to parse error response: {str(json_error)}")
                    raise
                
                if 'choices' not in response_data or len(response_data['choices']) == 0:
                    raise ValueError("Invalid response format from DeepSeek API")
                    
                bot_response = response_data['choices'][0]['message']['content']
                total_tokens = response_data.get('usage', {}).get('total_tokens', 0)
                
                self.dialog_context[chat_id].append({'role': 'assistant', 'content': bot_response})
                return bot_response, total_tokens
                
    except Exception as e:
        error_msg = f"DeepSeek API Error: {str(e)}"
        if hasattr(e, 'response') and e.response:
            try:
                error_details = await e.response.json()
                error_msg += f"\nStatus: {e.response.status}\nDetails: {json.dumps(error_details, indent=2)}"
                if e.response.status == 401:
                    error_msg += "\nPossible causes:\n"
                    error_msg += "- Invalid or expired API key\n"
                    error_msg += "- API key not activated\n"
                    error_msg += "- Regional restrictions on API access\n"
            except Exception as json_error:
                error_msg += f"\nFailed to parse error response: {str(json_error)}"
        return error_msg, 0
   

   def reset_chat_history(self, chat_id: int, content: str = ''):
   """Reset chat history for a specific chat"""
   self.dialog_context[chat_id] = []
   if content:
   self.dialog_context[chat_id].append({'role': 'system', 'content': content})

   def get_conversation_stats(self, chat_id: int) -> Tuple[int, int]:
   """Get conversation statistics"""
   if chat_id not in self.dialog_context:
   return 0, 0

    total_messages = len(self.dialog_context[chat_id])
    total_tokens = sum(len(msg['content']) for msg in self.dialog_context[chat_id]) // 4  # Approximate token count
    
    return total_messages, total_tokens
   

   async def get_chat_response_stream(self, chat_id: int, query: str):
   """Get streaming chat response from DeepSeek API"""
   if chat_id not in self.dialog_context:
   # Initialize with system prompt if new chat
   logging.info(f"Initializing new chat context with system prompt for chat {chat_id}")
   self.dialog_context[chat_id] = [{'role': 'system', 'content': self.system_prompt}]
   logging.debug(f"System prompt: {self.system_prompt}")

    # Add user message to context
    self.dialog_context[chat_id].append({'role': 'user', 'content': query})
    
    # Keep only last 10 messages to maintain context
    if len(self.dialog_context[chat_id]) > 10:
        self.dialog_context[chat_id] = self.dialog_context[chat_id][-10:]
    
    headers = {
        'Authorization': f'Bearer {self.api_key}',
        'Content-Type': 'application/json'
    }
    
    data = {
        'model': 'deepseek-chat',
        'messages': self.dialog_context[chat_id],
        'temperature': 0.7,
        'max_tokens': 1000,
        'top_p': 1.0,
        'frequency_penalty': 0.0,
        'presence_penalty': 0.0,
        'stream': True
    }
    
    try:
        async with aiohttp.ClientSession() as session:
            async with session.post(self.api_url, headers=headers, json=data) as response:
                response.raise_for_status()
                
                buffer = ""
                buffer = ""
                async for chunk in response.content:
                    if chunk:
                        chunk_str = chunk.decode('utf-8')
                        if chunk_str.startswith('data: '):
                            json_str = chunk_str[6:].strip()
                            if json_str == '[DONE]':
                                break
                                
                            try:
                                chunk_data = json.loads(json_str)
                                if 'choices' in chunk_data and len(chunk_data['choices']) > 0:
                                    delta = chunk_data['choices'][0].get('delta', {})
                                    if 'content' in delta:
                                        buffer += delta['content']
                                        # Only yield when we have a complete sentence
                                        if delta['content'].endswith(('.', '!', '?')):
                                            yield buffer, 'not_finished'
                                            buffer = ""
                                        # Also yield if buffer exceeds 100 characters
                                        elif len(buffer) > 100:
                                            yield buffer, 'not_finished'
                                            buffer = ""
                            except json.JSONDecodeError:
                                continue
                                
                # Yield any remaining content in the buffer
                if buffer:
                    yield buffer, 'not_finished'
                                
                # Store the complete response in dialog context
                if buffer:
                    self.dialog_context[chat_id].append({'role': 'assistant', 'content': buffer})
                    
                # Yield final token count (approximate based on buffer length)
                yield "", len(buffer) // 4  # Approximate token count
                    
    except Exception as e:
        error_msg = f"DeepSeek API Error: {str(e)}"
        if hasattr(e, 'response') and e.response:
            error_details = await e.response.json()
            error_msg += f"\nDetails: {json.dumps(error_details, indent=2)}"
        yield error_msg, 0
   

[khanfar]

here helper for deepseek i make

[khanfar]

deepseek_helper.py

[khanfar]

New Text Document.txt

[khanfar]

??