euriai 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

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.dist-info → euriai-1.0.3.dist-info}/METADATA

@@ -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.dist-info → euriai-1.0.3.dist-info}/RECORD

@@ -6,13 +6,13 @@ euriai/crewai.py,sha256=eeDfZQC9LtEePSnaj94DA0Kcb8Ayq0Gn_eDSQwbcMBU,7543
 euriai/embedding.py,sha256=uP66Ph1k9Ou6J5RAkztJxlfyj0S0MESOvZ4ulhnVo-o,1270
 euriai/euri_chat.py,sha256=DEAiet1ReRwB4ljkPYaTl1Nb5uc20-JF-3PQjGQZXk4,3567
 euriai/euri_embed.py,sha256=VE-RLUb5bYnEFA_dxFkj2c3Jr_SYyJKPmFOzsDOR0Ys,2137
-euriai/langchain.py,sha256=IByxc9xBd8flDZU0gFrXs6Hs5_N3TaLKFL3rilKDAuc,29285
+euriai/langchain.py,sha256=gVF9eh21RC1WtDn7SQoEREUDqOObm5IRx6BFZtB5xcc,34968
 euriai/langgraph.py,sha256=sw9e-PnfwAwmp_tUCnAGIUB78GyJsMkAzxOGvFUafiM,34128
 euriai/llamaindex.py,sha256=c-ujod2bjL6QIvfAyuIxm1SvSCS00URFElYybKQ5Ew0,26551
 euriai/n8n.py,sha256=hjkckqyW_hZNL78UkBCof1WvKCKCIjwdvZdAgx6NrB8,3764
 euriai/smolagents.py,sha256=xlixGx2IWzAPTpSJGsYIK2L-SHGY9Mw1-8GbwVsEYtU,28507
-euriai-1.0.1.dist-info/METADATA,sha256=BdezMUKkYwKb7S4zZUY14E2v8lUtH3u1dTB01M_3cNI,6881
-euriai-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-euriai-1.0.1.dist-info/entry_points.txt,sha256=9OkET8KIGcsjQn8UlnpPKRT75s2KW34jq1__1SXtpMA,43
-euriai-1.0.1.dist-info/top_level.txt,sha256=TG1htJ8cuD62MXn-NJ7DVF21QHY16w6M_QgfF_Er_EQ,7
-euriai-1.0.1.dist-info/RECORD,,
+euriai-1.0.3.dist-info/METADATA,sha256=VL-iLUQt3qiPi5EMJg2_-19Z7m4zO74RvDtJ3CgwVu0,6881
+euriai-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+euriai-1.0.3.dist-info/entry_points.txt,sha256=9OkET8KIGcsjQn8UlnpPKRT75s2KW34jq1__1SXtpMA,43
+euriai-1.0.3.dist-info/top_level.txt,sha256=TG1htJ8cuD62MXn-NJ7DVF21QHY16w6M_QgfF_Er_EQ,7
+euriai-1.0.3.dist-info/RECORD,,