entari-plugin-hyw 4.0.0rc17__py3-none-any.whl → 4.0.0rc19__py3-none-any.whl

hyw_core/stages/__init__.py

@@ -1,21 +0,0 @@
-"""
-hyw_core.stages - Pipeline Stages
-
-This subpackage provides the pipeline stage implementations:
-- BaseStage: Abstract base class for all stages
-- StageContext: Shared context between stages
-- StageResult: Stage execution result
-- InstructStage: Initial task planning and search execution
-- SummaryStage: Final response generation
-"""
-
-from .base import BaseStage, StageContext, StageResult
-
-from .summary import SummaryStage
-
-__all__ = [
-    "BaseStage",
-    "StageContext", 
-    "StageResult",
-    "SummaryStage",
-]

hyw_core/stages/base.py

@@ -1,95 +0,0 @@
-"""
-Stage Base Classes
-
-Abstract base classes for pipeline stages.
-Each stage is a self-contained unit of work.
-"""
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
-
-from openai import AsyncOpenAI
-
-
-@dataclass
-class StageContext:
-    """Shared context passed between stages."""
-    user_input: str
-    images: List[str] = field(default_factory=list)
-    conversation_history: List[Dict] = field(default_factory=list)
-    instruct_history: List[Dict] = field(default_factory=list)  # History for Instruct stage rounds
-    
-    # Accumulated data
-    web_results: List[Dict] = field(default_factory=list)
-    agent_context: str = ""
-    review_context: str = "" # Context passed from Instruct to Review stage
-    
-    # Mode info (set by Instruct stage)
-    task_list: List[str] = field(default_factory=list)
-    
-    # Control flags
-    should_refuse: bool = False
-    refuse_reason: str = ""
-    selected_mode: str = "fast"  # "fast" or "deepsearch"
-    
-    # ID counter for unified referencing
-    global_id_counter: int = 0
-    
-    # Model capabilities
-    image_input_supported: bool = True
-    
-    # Search timing
-    search_time: float = 0.0
-    
-    def next_id(self) -> int:
-        """Get next global ID."""
-        self.global_id_counter += 1
-        return self.global_id_counter
-
-
-@dataclass
-class StageResult:
-    """Result from a stage execution."""
-    success: bool
-    data: Dict[str, Any] = field(default_factory=dict)
-    usage: Dict[str, int] = field(default_factory=lambda: {"input_tokens": 0, "output_tokens": 0})
-    trace: Dict[str, Any] = field(default_factory=dict)
-    error: Optional[str] = None
-
-
-class BaseStage(ABC):
-    """Abstract base class for pipeline stages."""
-    
-    def __init__(self, config: Any, search_service: Any, client: AsyncOpenAI):
-        self.config = config
-        self.search_service = search_service
-        self.client = client
-    
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """Stage name for logging and tracing."""
-        pass
-    
-    @abstractmethod
-    async def execute(self, context: StageContext) -> StageResult:
-        """
-        Execute the stage.
-        
-        Args:
-            context: Shared context with accumulated data
-            
-        Returns:
-            StageResult with success status, data, usage, and trace info
-        """
-        pass
-    
-    def _client_for(self, api_key: Optional[str], base_url: Optional[str]) -> AsyncOpenAI:
-        """Get or create client with custom credentials."""
-        if api_key or base_url:
-            return AsyncOpenAI(
-                base_url=base_url or self.config.base_url,
-                api_key=api_key or self.config.api_key
-            )
-        return self.client

hyw_core/stages/summary.py

@@ -1,218 +0,0 @@
-"""
-Summary Stage
-
-Generates final response based on gathered information.
-Different output formats for different modes.
-"""
-
-import time
-import re
-from typing import Any, Dict, List, Optional
-
-from loguru import logger
-from openai import AsyncOpenAI
-
-from .base import BaseStage, StageContext, StageResult
-from ..definitions import SUMMARY_REPORT_SP, IMAGE_CONTEXT_TEMPLATE, get_refuse_answer_tool
-
-
-class SummaryStage(BaseStage):
-    """
-    Summary Stage: Generate final response.
-    """
-    
-    @property
-    def name(self) -> str:
-        return "Summary"
-    
-    async def execute(
-        self, 
-        context: StageContext, 
-        images: List[str] = None
-    ) -> StageResult:
-        """Generate summary."""
-        start_time = time.time()
-        
-        # Format context from web results
-        web_content = self._format_web_content(context)
-        
-        # Tools
-        refuse_tool = get_refuse_answer_tool()
-        full_context = f"{context.agent_context}\n\n{web_content}"
-        
-        # Select prompt
-        language = getattr(self.config, "language", "Simplified Chinese")
-        
-        system_prompt = SUMMARY_REPORT_SP + f"\n\n用户要求的语言: {language}"
-        
-        # Build Context Message
-        context_message = f"## Web Search & Page Content\n\n```context\n{full_context}\n```"
-        
-        
-        # Build user content
-        user_text = context.user_input or "..."
-        if images:
-            # 构建智能图文融合指导
-            image_context = IMAGE_CONTEXT_TEMPLATE.format(image_count=len(images))
-            user_content: List[Dict[str, Any]] = [{"type": "text", "text": f"{image_context}{user_text}"}]
-            for img_b64 in images:
-                url = f"data:image/jpeg;base64,{img_b64}" if not img_b64.startswith("data:") else img_b64
-                user_content.append({"type": "image_url", "image_url": {"url": url}})
-        else:
-            user_content = user_text
-        
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": context_message},
-            {"role": "user", "content": user_content}
-        ]
-        
-        # Get model config
-        model_cfg = self.config.get_model_config("main")
-        
-        client = self._client_for(
-            api_key=model_cfg.api_key,
-            base_url=model_cfg.base_url
-        )
-        
-        model = model_cfg.model_name or self.config.model_name
-        
-        # Retry logic for API calls
-        max_retries = 2
-        response = None
-        last_error = None
-        
-        for attempt in range(max_retries + 1):
-            try:
-                response = await client.chat.completions.create(
-                    model=model,
-                    messages=messages,
-                    temperature=self.config.temperature,
-                    extra_body=getattr(self.config, "summary_extra_body", None),
-                    tools=[refuse_tool],
-                    tool_choice="auto",
-                )
-                
-                # Check for valid response
-                if response.choices:
-                    break  # Success, exit retry loop
-                
-                # Empty choices - log and retry
-                logger.warning(f"SummaryStage: Empty choices response (attempt {attempt + 1}/{max_retries + 1}). Response: {response}")
-                last_error = "Invalid API response: no choices returned"
-                
-                if attempt < max_retries:
-                    import asyncio
-                    await asyncio.sleep(1)  # Wait 1 second before retry
-                    
-            except Exception as e:
-                logger.error(f"SummaryStage LLM error (attempt {attempt + 1}/{max_retries + 1}): {e}")
-                last_error = str(e)
-                
-                if attempt < max_retries:
-                    import asyncio
-                    await asyncio.sleep(1)  # Wait 1 second before retry
-        
-        # Check if we got a valid response after retries
-        if not response or not response.choices:
-            logger.error(f"SummaryStage: All retries exhausted. Last error: {last_error}")
-            return StageResult(
-                success=False,
-                error=last_error or "Invalid API response after retries",
-                data={"content": f"Error: {last_error or 'API returned invalid response after retries'}"}
-            )
-        
-        usage = {"input_tokens": 0, "output_tokens": 0}
-        if hasattr(response, "usage") and response.usage:
-            usage["input_tokens"] = getattr(response.usage, "prompt_tokens", 0) or 0
-            usage["output_tokens"] = getattr(response.usage, "completion_tokens", 0) or 0
-        
-        # Handle Tool Calls (Refusal)
-        tool_calls = response.choices[0].message.tool_calls
-        if tool_calls:
-            for tc in tool_calls:
-                if tc.function.name == "refuse_answer":
-                    import json
-                    try:
-                        args = json.loads(tc.function.arguments)
-                        reason = args.get("reason", "Refused")
-                        context.should_refuse = True
-                        context.refuse_reason = reason
-                        return StageResult(
-                            success=True,
-                            data={"content": f"Refused: {reason}"},
-                            usage=usage,
-                            trace={"skipped": True, "reason": reason}
-                        )
-                    except: pass
-        
-        content = (response.choices[0].message.content or "").strip()
-        
-        return StageResult(
-            success=True,
-            data={"content": content},
-            usage=usage,
-            trace={
-                "model": model,
-                "provider": model_cfg.model_provider or "Unknown",
-                "usage": usage,
-                "system_prompt": system_prompt,
-                "context_message": context_message,  # Includes vision description + search results
-                "output": content,
-                "time": time.time() - start_time,
-                "images_count": len(images) if images else 0,
-            }
-        )
-    
-    def _strip_links(self, text: str) -> str:
-        """Strip markdown links [text](url) -> text and remove bare URLs."""
-        # Replace [text](url) with text
-        text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text)
-        # Remove bare URLs (http/https) roughly, trying to preserve surrounding text if possible?
-        # A simple pattern for http/s
-        text = re.sub(r'https?://\S+', '', text)
-        return text
-
-    def _format_web_content(self, context: StageContext) -> str:
-        """Format web results for summary prompt."""
-        if not context.web_results:
-            return ""
-        
-        # Sort results: pages first, then raw searches, then snippets
-        def get_priority(item_type):
-            if item_type == "page": return 0
-            if item_type == "search_raw_page": return 1
-            return 2  # search (snippets)
-            
-        sorted_results = sorted(
-            context.web_results, 
-            key=lambda x: get_priority(x.get("_type"))
-        )
-        
-        lines = []
-        seen_urls = set()
-        
-        for res in sorted_results:
-            type_ = res.get("_type")
-            idx = res.get("_id")
-            title = (res.get("title", "") or "").strip()
-            url = res.get("url", "")
-            
-            # Deduplicate items by URL (keep higher priority item only)
-            if url:
-                if url in seen_urls:
-                    continue
-                seen_urls.add(url)
-            
-            # url = res.get("url", "") # Removed as requested
-            
-            if type_ == "page":
-                content = (res.get("content", "") or "").strip()
-                content = self._strip_links(content)
-                lines.append(f"[{idx}] Title: {title}\nContent:\n{content}\n")
-            elif type_ == "search":
-                snippet = (res.get("content", "") or "").strip()
-                snippet = self._strip_links(snippet)
-                lines.append(f"[{idx}] Title: {title}\nSnippet: {snippet}\n")
-        
-        return "\n".join(lines)