euriai 1.0.1__tar.gz → 1.0.3__tar.gz

{euriai-1.0.1 → euriai-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euriai
-Version: 1.0.1
+Version: 1.0.3
 Summary: Python client for Euri API (euron.one) with CLI, LangChain, and LlamaIndex integration
 Author: Euri
 Author-email: tech@euron.one

{euriai-1.0.1 → euriai-1.0.3}/euriai/langchain.py

@@ -221,6 +221,24 @@ class EuriaiChatModel(BaseChatModel):
         
         return formatted_messages
     
+    def _messages_to_prompt(self, messages: List[BaseMessage]) -> str:
+        """Convert LangChain messages to a single prompt string."""
+        prompt_parts = []
+        
+        for message in messages:
+            if isinstance(message, SystemMessage):
+                prompt_parts.append(f"System: {message.content}")
+            elif isinstance(message, HumanMessage):
+                prompt_parts.append(f"Human: {message.content}")
+            elif isinstance(message, AIMessage):
+                prompt_parts.append(f"Assistant: {message.content}")
+            elif isinstance(message, (FunctionMessage, ToolMessage)):
+                prompt_parts.append(f"Function: {message.content}")
+            else:
+                prompt_parts.append(f"User: {message.content}")
+        
+        return "\n\n".join(prompt_parts)
+    
     def _create_chat_result(self, response: Dict[str, Any]) -> ChatResult:
         """Create ChatResult from API response."""
         if "choices" not in response or not response["choices"]:
@@ -273,12 +291,12 @@ class EuriaiChatModel(BaseChatModel):
         **kwargs: Any,
     ) -> ChatResult:
         """Generate chat response."""
-        # Format messages
-        formatted_messages = self._format_messages(messages)
+        # Convert messages to prompt format
+        prompt = self._messages_to_prompt(messages)
         
         # Prepare request
         request_params = {
-            "messages": formatted_messages,
+            "prompt": prompt,
             "temperature": self.temperature,
             "max_tokens": self.max_tokens,
         }
@@ -313,12 +331,12 @@ class EuriaiChatModel(BaseChatModel):
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
         """Stream chat response."""
-        # Format messages
-        formatted_messages = self._format_messages(messages)
+        # Convert messages to prompt format
+        prompt = self._messages_to_prompt(messages)
         
         # Prepare request
         request_params = {
-            "messages": formatted_messages,
+            "prompt": prompt,
             "temperature": self.temperature,
             "max_tokens": self.max_tokens,
         }
@@ -464,11 +482,9 @@ class EuriaiChatModel(BaseChatModel):
         self, 
         schema: Union[Dict, Type[BaseModel]], 
         **kwargs: Any
-    ) -> "EuriaiChatModel":
+    ) -> "EuriaiStructuredChatModel":
         """Create a version that returns structured output."""
-        # This would need to be implemented with proper schema validation
-        # For now, return self with structured output enabled
-        return self.__class__(
+        return EuriaiStructuredChatModel(
             api_key=self.api_key,
             model=self.model,
             temperature=self.temperature,
@@ -479,11 +495,136 @@ class EuriaiChatModel(BaseChatModel):
             streaming=self.streaming,
             supports_function_calling=self.supports_function_calling,
             supports_structured_output=True,
-            _structured_output_schema=schema,
+            schema=schema,
             **kwargs
         )
 
 
+class EuriaiStructuredChatModel(EuriaiChatModel):
+    """
+    EuriaiChatModel with structured output support.
+    
+    This class extends EuriaiChatModel to parse responses into structured Pydantic models.
+    """
+    
+    def __init__(self, schema: Union[Dict, Type[BaseModel]], **kwargs):
+        # Initialize the parent class first
+        super().__init__(**kwargs)
+        
+        # Store schema in private attributes to avoid Pydantic conflicts
+        self._output_schema = schema
+        self._schema_name = getattr(schema, '__name__', 'OutputSchema')
+        
+    @property
+    def schema(self):
+        """Get the output schema."""
+        return self._output_schema
+    
+    @property
+    def schema_name(self):
+        """Get the schema name."""
+        return self._schema_name
+        
+    def _get_json_schema(self) -> Dict[str, Any]:
+        """Generate JSON schema from the Pydantic model."""
+        if hasattr(self.schema, 'model_json_schema'):
+            # Pydantic v2
+            return self.schema.model_json_schema()
+        elif hasattr(self.schema, 'schema'):
+            # Pydantic v1
+            return self.schema.schema()
+        else:
+            # Dictionary schema
+            return self.schema
+    
+    def _create_structured_prompt(self, original_prompt: str) -> str:
+        """Create a prompt that requests structured JSON output."""
+        json_schema = self._get_json_schema()
+        
+        structured_prompt = f"""{original_prompt}
+
+Please respond with a valid JSON object that matches this exact schema:
+```json
+{json.dumps(json_schema, indent=2)}
+```
+
+Your response must be valid JSON that can be parsed. Do not include any other text outside the JSON object."""
+        
+        return structured_prompt
+    
+    def _parse_structured_response(self, response_content: str) -> Any:
+        """Parse the response content into the structured format."""
+        try:
+            # Try to find JSON in the response
+            response_content = response_content.strip()
+            
+            # Handle cases where the response might have extra text
+            if '```json' in response_content:
+                # Extract JSON from code block
+                start = response_content.find('```json') + 7
+                end = response_content.find('```', start)
+                if end == -1:
+                    end = len(response_content)
+                json_str = response_content[start:end].strip()
+            elif response_content.startswith('{') and response_content.endswith('}'):
+                # Response is already JSON
+                json_str = response_content
+            else:
+                # Try to find JSON object in the response
+                import re
+                json_match = re.search(r'\{.*\}', response_content, re.DOTALL)
+                if json_match:
+                    json_str = json_match.group(0)
+                else:
+                    raise ValueError("No JSON object found in response")
+            
+            # Parse JSON
+            parsed_data = json.loads(json_str)
+            
+            # Convert to Pydantic model if schema is a BaseModel
+            if hasattr(self.schema, 'model_validate'):
+                # Pydantic v2
+                return self.schema.model_validate(parsed_data)
+            elif hasattr(self.schema, 'parse_obj'):
+                # Pydantic v1
+                return self.schema.parse_obj(parsed_data)
+            else:
+                # Dictionary schema - return parsed data
+                return parsed_data
+                
+        except Exception as e:
+            # Fallback: return raw response if parsing fails
+            raise ValueError(f"Failed to parse structured output: {e}\nResponse: {response_content}")
+    
+    def _messages_to_prompt(self, messages: List[BaseMessage]) -> str:
+        """Convert LangChain messages to a single prompt string with structured output instructions."""
+        # Get the original prompt
+        original_prompt = super()._messages_to_prompt(messages)
+        
+        # Add structured output instructions
+        return self._create_structured_prompt(original_prompt)
+    
+    def invoke(self, input, config=None, **kwargs):
+        """Invoke the model and return structured output."""
+        # Get the regular AI message response
+        response = super().invoke(input, config, **kwargs)
+        
+        # Parse the response content into structured format
+        structured_result = self._parse_structured_response(response.content)
+        
+        return structured_result
+    
+    async def ainvoke(self, input, config=None, **kwargs):
+        """Async invoke the model and return structured output."""
+        # Get the regular AI message response
+        response = await super().ainvoke(input, config, **kwargs)
+        
+        # Parse the response content into structured format
+        structured_result = self._parse_structured_response(response.content)
+        
+        return structured_result
+
+
 class EuriaiEmbeddings(Embeddings):
     """
     Enhanced LangChain Embeddings implementation using Euri API.

{euriai-1.0.1 → euriai-1.0.3}/euriai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euriai
-Version: 1.0.1
+Version: 1.0.3
 Summary: Python client for Euri API (euron.one) with CLI, LangChain, and LlamaIndex integration
 Author: Euri
 Author-email: tech@euron.one

{euriai-1.0.1 → euriai-1.0.3}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = euriai
-version = 1.0.1
+version = 1.0.3
 license = MIT
 description = Python client for EURI LLM API (euron.one) with CLI, LangChain, LlamaIndex, LangGraph, SmolAgents, and n8n integration
 keywords = euriai, llm, langchain, llamaindex, langgraph, smolagents, n8n, agents, ai, sdk

{euriai-1.0.1 → euriai-1.0.3}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="euriai",
-    version="1.0.1",
+    version="1.0.3",
     description="Python client for Euri API (euron.one) with CLI, LangChain, and LlamaIndex integration",
     long_description=open("README.md", encoding="utf-8").read(),
     long_description_content_type="text/markdown",