agnt5 0.1.0__cp39-abi3-macosx_11_0_arm64.whl

agnt5/llm/models.json

@@ -0,0 +1,227 @@
+{
+  "_comment": "AGNT5 Model Registry Configuration",
+  "_description": "This configuration file provides model definitions and capabilities without hardcoding model names in source code. Models are organized by provider with capability-based aliases for intelligent selection.",
+  "_version": "1.0",
+  "_last_updated": "2024-12-06",
+  
+  "anthropic": {
+    "claude-3-5-sonnet-20241022": {
+      "tier": "flagship",
+      "capabilities": ["text_generation", "tool_calling", "vision", "reasoning", "analysis", "code_generation", "creative_writing"],
+      "aliases": ["claude-latest", "claude-best", "best-reasoning", "best-analysis"],
+      "context_length": 200000,
+      "max_output_tokens": 8192,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "supports_vision": true,
+      "metadata": {
+        "release_date": "2024-10-22",
+        "description": "Latest Claude 3.5 Sonnet with enhanced reasoning"
+      }
+    },
+    "claude-3-5-haiku-20241022": {
+      "tier": "efficient",
+      "capabilities": ["text_generation", "tool_calling", "fast_inference", "cost_efficient"],
+      "aliases": ["claude-fast", "claude-cheap", "fastest", "most-affordable"],
+      "context_length": 200000,
+      "max_output_tokens": 8192,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "supports_vision": false,
+      "metadata": {
+        "release_date": "2024-10-22",
+        "description": "Fast and efficient Claude 3.5 Haiku"
+      }
+    }
+  },
+  
+  "openai": {
+    "gpt-4o": {
+      "tier": "flagship",
+      "capabilities": ["text_generation", "tool_calling", "vision", "reasoning", "analysis", "code_generation"],
+      "aliases": ["gpt-latest", "gpt-best", "best-multimodal", "best-vision"],
+      "context_length": 128000,
+      "max_output_tokens": 16384,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "supports_vision": true,
+      "metadata": {
+        "description": "GPT-4 Omni with multimodal capabilities"
+      }
+    },
+    "gpt-4o-mini": {
+      "tier": "efficient",
+      "capabilities": ["text_generation", "tool_calling", "fast_inference", "cost_efficient"],
+      "aliases": ["gpt-fast", "gpt-cheap", "gpt-mini"],
+      "context_length": 128000,
+      "max_output_tokens": 16384,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "supports_vision": true,
+      "metadata": {
+        "description": "Efficient GPT-4 Omni mini version"
+      }
+    },
+    "gpt-4-turbo": {
+      "tier": "performance",
+      "capabilities": ["text_generation", "tool_calling", "vision", "reasoning", "analysis"],
+      "aliases": ["gpt-turbo"],
+      "context_length": 128000,
+      "max_output_tokens": 4096,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "supports_vision": true
+    }
+  },
+  
+  "google": {
+    "gemini-1.5-pro": {
+      "tier": "flagship",
+      "capabilities": ["text_generation", "tool_calling", "vision", "long_context", "reasoning", "analysis"],
+      "aliases": ["gemini-latest", "gemini-pro", "best-context"],
+      "context_length": 2000000,
+      "max_output_tokens": 8192,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "supports_vision": true,
+      "metadata": {
+        "description": "Gemini 1.5 Pro with 2M context window"
+      }
+    },
+    "gemini-1.5-flash": {
+      "tier": "efficient",
+      "capabilities": ["text_generation", "tool_calling", "fast_inference", "long_context"],
+      "aliases": ["gemini-fast", "gemini-flash"],
+      "context_length": 1000000,
+      "max_output_tokens": 8192,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "supports_vision": true,
+      "metadata": {
+        "description": "Fast Gemini 1.5 Flash with 1M context"
+      }
+    }
+  },
+  
+  "mistral": {
+    "mistral-large-latest": {
+      "tier": "flagship",
+      "capabilities": ["text_generation", "tool_calling", "reasoning", "multilingual", "analysis"],
+      "aliases": ["mistral-latest", "mistral-large", "mistral-best"],
+      "context_length": 128000,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "metadata": {
+        "description": "Latest Mistral Large model"
+      }
+    },
+    "mistral-small-latest": {
+      "tier": "efficient",
+      "capabilities": ["text_generation", "fast_inference", "cost_efficient", "multilingual"],
+      "aliases": ["mistral-fast", "mistral-small", "mistral-cheap"],
+      "context_length": 128000,
+      "supports_streaming": true,
+      "supports_tools": false,
+      "metadata": {
+        "description": "Efficient Mistral Small model"
+      }
+    },
+    "codestral-latest": {
+      "tier": "performance", 
+      "capabilities": ["text_generation", "code_generation", "tool_calling"],
+      "aliases": ["codestral", "best-coding", "mistral-code"],
+      "context_length": 32000,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "metadata": {
+        "description": "Specialized coding model"
+      }
+    }
+  },
+  
+  "together": {
+    "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo": {
+      "tier": "performance",
+      "capabilities": ["text_generation", "tool_calling", "reasoning", "analysis"],
+      "aliases": ["llama-latest", "llama-70b", "llama-large"],
+      "context_length": 131072,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "metadata": {
+        "description": "Meta's Llama 3.1 70B parameter model",
+        "open_source": true
+      }
+    },
+    "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo": {
+      "tier": "efficient",
+      "capabilities": ["text_generation", "tool_calling", "fast_inference"],
+      "aliases": ["llama-fast", "llama-8b", "llama-small"],
+      "context_length": 131072,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "metadata": {
+        "description": "Meta's Llama 3.1 8B parameter model",
+        "open_source": true
+      }
+    },
+    "meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo": {
+      "tier": "performance",
+      "capabilities": ["text_generation", "tool_calling", "vision", "multimodal"],
+      "aliases": ["llama-vision", "llama-multimodal"],
+      "context_length": 131072,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "supports_vision": true,
+      "metadata": {
+        "description": "Meta's Llama 3.2 with vision capabilities",
+        "open_source": true
+      }
+    },
+    "mistralai/Mixtral-8x7B-Instruct-v0.1": {
+      "tier": "balanced",
+      "capabilities": ["text_generation", "tool_calling", "multilingual", "reasoning"],
+      "aliases": ["mixtral-latest", "mixtral", "mixtral-8x7b"],
+      "context_length": 32768,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "metadata": {
+        "description": "Mistral's Mixtral 8x7B mixture of experts",
+        "open_source": true
+      }
+    },
+    "Qwen/Qwen2.5-72B-Instruct-Turbo": {
+      "tier": "performance",
+      "capabilities": ["text_generation", "tool_calling", "multilingual", "reasoning", "code_generation"],
+      "aliases": ["qwen-latest", "qwen-72b", "qwen"],
+      "context_length": 131072,
+      "supports_streaming": true,
+      "supports_tools": true,
+      "metadata": {
+        "description": "Alibaba's Qwen 2.5 72B parameter model",
+        "open_source": true
+      }
+    }
+  },
+
+  "_capability_descriptions": {
+    "text_generation": "Basic text generation capabilities",
+    "tool_calling": "Ability to call external tools/functions",
+    "vision": "Can process and understand images",
+    "reasoning": "Strong logical reasoning and problem-solving",
+    "analysis": "Data analysis and interpretation",
+    "code_generation": "Programming and code generation",
+    "creative_writing": "Creative content generation",
+    "long_context": "Extended context window support",
+    "multilingual": "Support for multiple languages",
+    "fast_inference": "Optimized for speed",
+    "cost_efficient": "Optimized for cost"
+  },
+
+  "_tier_descriptions": {
+    "flagship": "Highest performance, latest features, premium cost",
+    "performance": "High performance, good feature set, moderate cost", 
+    "balanced": "Good balance of performance and cost",
+    "efficient": "Optimized for speed and cost efficiency",
+    "experimental": "Beta or preview models"
+  }
+}

agnt5/llm/openai.py

@@ -0,0 +1,334 @@
+"""
+OpenAI integration for AGNT5 SDK.
+
+Provides integration with OpenAI's GPT models including proper message conversion,
+tool calling, and streaming support.
+"""
+
+import json
+import os
+from typing import Any, AsyncIterator, Dict, List, Optional, Union
+
+from .base import (
+    LanguageModel,
+    LanguageModelResponse,
+    LanguageModelType,
+    LLMError,
+    Message,
+    Role,
+    TokenUsage,
+    ToolCall,
+)
+
+try:
+    import openai
+    from openai.types.chat import (
+        ChatCompletion,
+        ChatCompletionChunk,
+        ChatCompletionMessage,
+        ChatCompletionMessageToolCall,
+    )
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+
+
+class OpenAIError(LLMError):
+    """OpenAI-specific errors."""
+    pass
+
+
+class OpenAILanguageModel(LanguageModel):
+    """
+    OpenAI GPT language model implementation.
+    
+    Supports all GPT models with proper message conversion, tool calling,
+    and streaming capabilities.
+    """
+    
+    def __init__(
+        self,
+        llm_model: LanguageModelType,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        organization: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        **kwargs
+    ):
+        if not OPENAI_AVAILABLE:
+            raise OpenAIError("OpenAI library not installed. Install with: pip install openai")
+        
+        super().__init__(llm_model, system_prompt, **kwargs)
+        
+        # Get API key
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        if not self.api_key:
+            raise OpenAIError("OpenAI API key required. Set OPENAI_API_KEY or pass api_key parameter")
+        
+        # Initialize client
+        client_kwargs = {"api_key": self.api_key}
+        if base_url:
+            client_kwargs["base_url"] = base_url
+        if organization:
+            client_kwargs["organization"] = organization
+            
+        self.client = openai.AsyncOpenAI(**client_kwargs)
+        
+        # Validate model is supported by OpenAI
+        if not self.model_name.startswith("gpt"):
+            raise OpenAIError(f"Model {self.model_name} is not an OpenAI model")
+    
+    async def generate(
+        self,
+        messages: List[Message],
+        tools: Optional[List[Dict[str, Any]]] = None,
+        max_tokens: int = 1024,
+        temperature: float = 0.7,
+        top_p: float = 1.0,
+        stream: bool = False,
+        **kwargs
+    ) -> Union[LanguageModelResponse, AsyncIterator[LanguageModelResponse]]:
+        """Generate response using OpenAI GPT."""
+        try:
+            # Validate and prepare messages
+            self.validate_messages(messages)
+            prepared_messages = self.prepare_system_message(messages)
+            
+            # Convert to OpenAI format
+            openai_messages = self.convert_messages_to_provider_format(prepared_messages)
+            
+            # Prepare request parameters
+            request_params = {
+                "model": self.model_name,
+                "messages": openai_messages,
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "top_p": top_p,
+                "stream": stream,
+            }
+            
+            if tools:
+                request_params["tools"] = self.convert_tools_to_provider_format(tools)
+                request_params["tool_choice"] = "auto"
+            
+            # Add any additional parameters
+            request_params.update(kwargs)
+            
+            if stream:
+                return self._generate_stream(**request_params)
+            else:
+                return await self._generate_single(**request_params)
+                
+        except openai.APIError as e:
+            raise OpenAIError(f"OpenAI API error: {e}", provider="openai", model=self.model_name) from e
+        except Exception as e:
+            raise OpenAIError(f"Unexpected error: {e}", provider="openai", model=self.model_name) from e
+    
+    async def _generate_single(self, **request_params) -> LanguageModelResponse:
+        """Generate a single response."""
+        response = await self.client.chat.completions.create(**request_params)
+        
+        message = response.choices[0].message
+        
+        # Extract text content
+        response_text = message.content or ""
+        
+        # Extract tool calls
+        tool_calls = []
+        if message.tool_calls:
+            for tool_call in message.tool_calls:
+                if tool_call.type == "function":
+                    try:
+                        arguments = json.loads(tool_call.function.arguments)
+                    except json.JSONDecodeError:
+                        arguments = {"raw_arguments": tool_call.function.arguments}
+                    
+                    tool_calls.append(ToolCall(
+                        id=tool_call.id,
+                        name=tool_call.function.name,
+                        arguments=arguments
+                    ))
+        
+        # Calculate token usage
+        usage = TokenUsage()
+        if response.usage:
+            usage = TokenUsage(
+                prompt_tokens=response.usage.prompt_tokens,
+                completion_tokens=response.usage.completion_tokens,
+                total_tokens=response.usage.total_tokens
+            )
+        
+        return LanguageModelResponse(
+            message=response_text,
+            usage=usage,
+            tool_calls=tool_calls if tool_calls else None,
+            model=response.model,
+            finish_reason=response.choices[0].finish_reason,
+            metadata={"response_id": response.id}
+        )
+    
+    async def _generate_stream(self, **request_params) -> AsyncIterator[LanguageModelResponse]:
+        """Generate streaming response."""
+        stream = await self.client.chat.completions.create(**request_params)
+        
+        async for chunk in stream:
+            if chunk.choices:
+                choice = chunk.choices[0]
+                
+                # Handle content delta
+                if choice.delta.content:
+                    yield LanguageModelResponse(
+                        message=choice.delta.content,
+                        usage=TokenUsage(),
+                        model=chunk.model
+                    )
+                
+                # Handle tool calls
+                if choice.delta.tool_calls:
+                    for tool_call_delta in choice.delta.tool_calls:
+                        if tool_call_delta.function:
+                            # Note: In streaming, tool calls come in pieces
+                            # This is a simplified version - full implementation would
+                            # need to accumulate the complete tool call
+                            yield LanguageModelResponse(
+                                message="",
+                                usage=TokenUsage(),
+                                model=chunk.model,
+                                metadata={"tool_call_delta": tool_call_delta}
+                            )
+    
+    def convert_messages_to_provider_format(self, messages: List[Message]) -> List[Dict[str, Any]]:
+        """Convert internal messages to OpenAI format."""
+        openai_messages = []
+        
+        for message in messages:
+            # Convert role
+            if message.role == Role.SYSTEM:
+                role = "system"
+            elif message.role == Role.USER:
+                role = "user"
+            elif message.role == Role.ASSISTANT:
+                role = "assistant"
+            elif message.role == Role.TOOL:
+                role = "tool"
+            else:
+                continue  # Skip unsupported roles
+            
+            # Prepare content
+            if isinstance(message.content, str):
+                content = message.content
+            elif isinstance(message.content, list):
+                content = self._convert_content_blocks(message.content)
+            else:
+                content = str(message.content)
+            
+            openai_message = {
+                "role": role,
+                "content": content
+            }
+            
+            # Add name if present
+            if message.name:
+                openai_message["name"] = message.name
+            
+            # Handle tool calls for assistant messages
+            if message.tool_calls and message.role == Role.ASSISTANT:
+                openai_message["tool_calls"] = [
+                    {
+                        "id": tool_call.id,
+                        "type": "function",
+                        "function": {
+                            "name": tool_call.name,
+                            "arguments": json.dumps(tool_call.arguments)
+                        }
+                    }
+                    for tool_call in message.tool_calls
+                ]
+            
+            # Handle tool call ID for tool messages
+            if message.tool_call_id:
+                openai_message["tool_call_id"] = message.tool_call_id
+            
+            openai_messages.append(openai_message)
+        
+        return openai_messages
+    
+    def _convert_content_blocks(self, content_blocks: List[Dict[str, Any]]) -> Union[str, List[Dict[str, Any]]]:
+        """Convert content blocks to OpenAI format."""
+        # For simple text-only blocks, return as string
+        if len(content_blocks) == 1 and content_blocks[0].get("type") == "text":
+            return content_blocks[0].get("text", str(content_blocks[0]))
+        
+        # For complex content, return as structured blocks
+        converted_blocks = []
+        
+        for block in content_blocks:
+            if isinstance(block, str):
+                converted_blocks.append({"type": "text", "text": block})
+            elif isinstance(block, dict):
+                block_type = block.get("type", "text")
+                
+                if block_type == "text":
+                    converted_blocks.append({
+                        "type": "text",
+                        "text": block.get("text", str(block))
+                    })
+                elif block_type == "image_url":
+                    converted_blocks.append({
+                        "type": "image_url",
+                        "image_url": block.get("image_url", {})
+                    })
+                else:
+                    # Convert unknown blocks to text
+                    converted_blocks.append({
+                        "type": "text", 
+                        "text": str(block)
+                    })
+            else:
+                converted_blocks.append({"type": "text", "text": str(block)})
+        
+        return converted_blocks
+    
+    def convert_tools_to_provider_format(self, tools: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Convert tools to OpenAI format."""
+        openai_tools = []
+        
+        for tool in tools:
+            if "function" in tool:
+                # Already in OpenAI format
+                openai_tools.append(tool)
+            else:
+                # Convert from simple format
+                openai_tool = {
+                    "type": "function",
+                    "function": {
+                        "name": tool.get("name", "unknown"),
+                        "description": tool.get("description", ""),
+                        "parameters": tool.get("parameters", tool.get("input_schema", {}))
+                    }
+                }
+                openai_tools.append(openai_tool)
+        
+        return openai_tools
+    
+    def extract_tool_calls_from_response(self, response: Any) -> List[ToolCall]:
+        """Extract tool calls from OpenAI response."""
+        tool_calls = []
+        
+        if hasattr(response, "choices") and response.choices:
+            message = response.choices[0].message
+            if hasattr(message, "tool_calls") and message.tool_calls:
+                for tool_call in message.tool_calls:
+                    if tool_call.type == "function":
+                        try:
+                            arguments = json.loads(tool_call.function.arguments)
+                        except json.JSONDecodeError:
+                            arguments = {"raw_arguments": tool_call.function.arguments}
+                        
+                        tool_calls.append(ToolCall(
+                            id=tool_call.id,
+                            name=tool_call.function.name,
+                            arguments=arguments
+                        ))
+        
+        return tool_calls