lionagi 0.12.8__py3-none-any.whl → 0.13.1__py3-none-any.whl

lionagi/models/model_params.py

@@ -122,13 +122,13 @@ class ModelParams(SchemaModel):
             for k, v in self.parameter_fields.items()
             if k in self._use_keys
         }
-        params.update(
-            {
-                f.name: f.field_info
-                for f in self.field_models
-                if f.name in self._use_keys
-            }
-        )
+        # Add field_models with proper type annotations
+        for f in self.field_models:
+            if f.name in self._use_keys:
+                params[f.name] = f.field_info
+                # Set the annotation from the FieldModel's base_type
+                params[f.name].annotation = f.base_type
+
         return {k: (v.annotation, v) for k, v in params.items()}
 
     @field_validator("parameter_fields", mode="before")
@@ -281,9 +281,18 @@ class ModelParams(SchemaModel):
         self._validators = validators
 
         if self.field_descriptions:
+            # Update field_models with descriptions (create new instances since they're immutable)
+            updated_field_models = []
             for i in self.field_models:
                 if i.name in self.field_descriptions:
-                    i.description = self.field_descriptions[i.name]
+                    # Create new FieldModel with updated description
+                    updated_field_model = i.with_description(
+                        self.field_descriptions[i.name]
+                    )
+                    updated_field_models.append(updated_field_model)
+                else:
+                    updated_field_models.append(i)
+            self.field_models = updated_field_models
 
         if not isinstance(self.name, str):
             if hasattr(self.base_type, "class_name"):

lionagi/models/operable_model.py

@@ -202,9 +202,10 @@ class OperableModel(HashableModel):
 
         if (
             field_name in self.extra_field_models
-            and self.extra_field_models[field_name].validator is not UNDEFINED
+            and self.extra_field_models[field_name].has_validator()
         ):
-            value = self.extra_field_models[field_name].validator(None, value)
+            # Use the validate method to check value - let validation errors propagate
+            self.extra_field_models[field_name].validate(value, field_name)
         if field_name in self.extra_fields:
             object.__setattr__(self, field_name, value)
         else:
@@ -264,6 +265,7 @@ class OperableModel(HashableModel):
         """
         a = {**self.model_fields, **self.extra_fields}
         a.pop("extra_fields", None)
+        a.pop("extra_field_models", None)  # Exclude internal field tracking
         return a
 
     def add_field(

lionagi/protocols/operatives/operative.py

@@ -2,41 +2,139 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from pydantic import BaseModel, Field, PrivateAttr, model_validator
+from typing import Any, Optional
+
+from pydantic import BaseModel
 from pydantic.fields import FieldInfo
-from typing_extensions import Self
 
 from lionagi.libs.validate.fuzzy_match_keys import fuzzy_match_keys
-from lionagi.models import FieldModel, ModelParams, SchemaModel
+from lionagi.models import FieldModel, ModelParams, OperableModel
 from lionagi.utils import UNDEFINED, to_json
 
 
-class Operative(SchemaModel):
-    """Class representing an operative that handles request and response models for operations."""
+class Operative:
+    """Class representing an operative that handles request and response models for operations.
+
+    This implementation uses OperableModel internally for better performance while
+    maintaining backward compatibility with the existing API.
+    """
+
+    def __init__(
+        self,
+        name: str | None = None,
+        request_type: type[BaseModel] | None = None,
+        response_type: type[BaseModel] | None = None,
+        response_model: BaseModel | None = None,
+        response_str_dict: dict | str | None = None,
+        auto_retry_parse: bool = True,
+        max_retries: int = 3,
+        parse_kwargs: dict | None = None,
+        request_params: (
+            ModelParams | None
+        ) = None,  # Deprecated, for backward compatibility
+        **_kwargs,  # Ignored for backward compatibility
+    ):
+        """Initialize the Operative.
+
+        Args:
+            name: Name of the operative
+            request_type: Pydantic model type for requests
+            response_type: Pydantic model type for responses
+            response_model: Current response model instance
+            response_str_dict: Raw response string/dict
+            auto_retry_parse: Whether to auto-retry parsing
+            max_retries: Maximum parse retries
+            parse_kwargs: Additional parse arguments
+            request_params: Deprecated - use direct field addition
+            response_params: Deprecated - use direct field addition
+        """
+        self.name = name
+        self.request_type = request_type
+        self.response_type = response_type
+        self.response_model = response_model
+        self.response_str_dict = response_str_dict
+        self.auto_retry_parse = auto_retry_parse
+        self.max_retries = max_retries
+        self.parse_kwargs = parse_kwargs or {}
+        self._should_retry = None
+
+        # Internal OperableModel instances
+        self._request_operable = OperableModel()
+        self._response_operable = OperableModel()
+
+        # Handle deprecated ModelParams for backward compatibility
+        if request_params:
+            self._init_from_model_params(request_params)
+
+        # Set default name if not provided
+        if not self.name:
+            self.name = (
+                self.request_type.__name__
+                if self.request_type
+                else "Operative"
+            )
+
+    def _init_from_model_params(self, params: ModelParams):
+        """Initialize from ModelParams for backward compatibility."""
+        # Add field models to the request operable
+        if params.field_models:
+            for field_model in params.field_models:
+                self._request_operable.add_field(
+                    field_model.name,
+                    field_model=field_model,
+                    annotation=field_model.base_type,
+                )
+
+        # Add parameter fields (skip if already added from field_models)
+        if params.parameter_fields:
+            for name, field_info in params.parameter_fields.items():
+                if (
+                    name not in (params.exclude_fields or [])
+                    and name not in self._request_operable.all_fields
+                ):
+                    self._request_operable.add_field(
+                        name, field_obj=field_info
+                    )
 
-    name: str | None = None
+        # Generate request_type if not provided
+        if not self.request_type:
+            exclude_fields = params.exclude_fields or []
+            use_fields = set(self._request_operable.all_fields.keys()) - set(
+                exclude_fields
+            )
+            self.request_type = self._request_operable.new_model(
+                name=params.name or "RequestModel",
+                use_fields=use_fields,
+                base_type=params.base_type,
+                frozen=params.frozen,
+                config_dict=params.config_dict,
+                doc=params.doc,
+            )
 
-    request_params: ModelParams | None = Field(default=None)
-    request_type: type[BaseModel] | None = Field(default=None)
+        # Update name if not set
+        if not self.name and params.name:
+            self.name = params.name
 
-    response_params: ModelParams | None = Field(default=None)
-    response_type: type[BaseModel] | None = Field(default=None)
-    response_model: BaseModel | None = Field(default=None)
-    response_str_dict: dict | str | None = Field(default=None)
+    def model_dump(self) -> dict[str, Any]:
+        """Convert to dictionary for backward compatibility.
 
-    auto_retry_parse: bool = True
-    max_retries: int = 3
-    parse_kwargs: dict | None = None
-    _should_retry: bool = PrivateAttr(default=None)
+        Note: This returns a Python dict, not JSON-serializable data.
+        For JSON serialization, convert types appropriately.
+        """
+        return {
+            "name": self.name,
+            "request_type": self.request_type,  # Python class object
+            "response_type": self.response_type,  # Python class object
+            "response_model": self.response_model,
+            "response_str_dict": self.response_str_dict,
+            "auto_retry_parse": self.auto_retry_parse,
+            "max_retries": self.max_retries,
+            "parse_kwargs": self.parse_kwargs,
+        }
 
-    @model_validator(mode="after")
-    def _validate(self) -> Self:
-        """Validates the operative instance after initialization."""
-        if self.request_type is None:
-            self.request_type = self.request_params.create_new_model()
-        if self.name is None:
-            self.name = self.request_params.name or self.request_type.__name__
-        return self
+    def to_dict(self) -> dict[str, Any]:
+        """Alias for model_dump() - more appropriate name for non-Pydantic class."""
+        return self.model_dump()
 
     def raise_validate_pydantic(self, text: str) -> None:
         """Validates and updates the response model using strict matching.
@@ -153,18 +251,89 @@ class Operative(SchemaModel):
             frozen (bool, optional): Whether the model is frozen.
             validators (dict, optional): Dictionary of validators.
         """
-        self.response_params = response_params or ModelParams(
-            parameter_fields=parameter_fields,
-            field_models=field_models,
-            exclude_fields=exclude_fields,
-            field_descriptions=field_descriptions,
-            inherit_base=inherit_base,
+        # Process response_params if provided (for backward compatibility)
+        if response_params:
+            # Extract values from ModelParams
+            field_models = field_models or response_params.field_models
+            parameter_fields = (
+                parameter_fields or response_params.parameter_fields
+            )
+            exclude_fields = exclude_fields or response_params.exclude_fields
+            field_descriptions = (
+                field_descriptions or response_params.field_descriptions
+            )
+            inherit_base = (
+                response_params.inherit_base if inherit_base else False
+            )
+            config_dict = config_dict or response_params.config_dict
+            doc = doc or response_params.doc
+            frozen = frozen or response_params.frozen
+
+        # Clear response operable and rebuild
+        self._response_operable = OperableModel()
+
+        # Copy fields from request operable if inherit_base
+        if inherit_base and self._request_operable:
+            for (
+                field_name,
+                field_model,
+            ) in self._request_operable.extra_field_models.items():
+                self._response_operable.add_field(
+                    field_name, field_model=field_model
+                )
+
+        # Add field models (skip if already exists from inheritance)
+        if field_models:
+            for field_model in field_models:
+                if field_model.name not in self._response_operable.all_fields:
+                    self._response_operable.add_field(
+                        field_model.name,
+                        field_model=field_model,
+                        annotation=field_model.base_type,
+                    )
+
+        # Add parameter fields (skip if already added)
+        if parameter_fields:
+            for name, field_info in parameter_fields.items():
+                if (
+                    name not in (exclude_fields or [])
+                    and name not in self._response_operable.all_fields
+                ):
+                    self._response_operable.add_field(
+                        name, field_obj=field_info
+                    )
+
+        # Add validators if provided
+        if validators:
+            for field_name, validator in validators.items():
+                if field_name in self._response_operable.all_fields:
+                    field_model = (
+                        self._response_operable.extra_field_models.get(
+                            field_name
+                        )
+                    )
+                    if field_model:
+                        field_model.validator = validator
+
+        # Generate response type
+        exclude_fields = exclude_fields or []
+        use_fields = set(self._response_operable.all_fields.keys()) - set(
+            exclude_fields
+        )
+
+        # Determine base type - use request_type if inheriting and no specific base provided
+        base_type = None
+        if response_params and response_params.base_type:
+            base_type = response_params.base_type
+        elif inherit_base and self.request_type:
+            base_type = self.request_type
+
+        self.response_type = self._response_operable.new_model(
+            name=(response_params.name if response_params else None)
+            or "ResponseModel",
+            use_fields=use_fields,
+            base_type=base_type,
+            frozen=frozen,
             config_dict=config_dict,
             doc=doc,
-            frozen=frozen,
-            base_type=self.request_params.base_type,
         )
-        if validators and isinstance(validators, dict):
-            self.response_params._validators.update(validators)
-
-        self.response_type = self.response_params.create_new_model()

lionagi/protocols/operatives/step.py

@@ -230,7 +230,8 @@ class Step:
             field_models.extend([REASON_FIELD])
 
         exclude_fields = exclude_fields or []
-        exclude_fields.extend(operative.request_params.exclude_fields)
+        # Note: We no longer have access to request_params.exclude_fields
+        # since Operative doesn't store ModelParams anymore
 
         operative.create_response_type(
             response_params=response_params,

lionagi/service/connections/endpoint_config.py

@@ -53,7 +53,6 @@ class EndpointConfig(BaseModel):
 
     @model_validator(mode="after")
     def _validate_api_key(self):
-
         if self.api_key is not None:
             if isinstance(self.api_key, SecretStr):
                 self._api_key = self.api_key.get_secret_value()
@@ -61,6 +60,9 @@ class EndpointConfig(BaseModel):
                 # Skip settings lookup for ollama special case
                 if self.provider == "ollama" and self.api_key == "ollama_key":
                     self._api_key = "ollama_key"
+                if self.provider == "claude_code":
+                    self._api_key = "dummy"
+
                 else:
                     from lionagi.config import settings
 
@@ -89,9 +91,11 @@ class EndpointConfig(BaseModel):
             if isinstance(v, BaseModel):
                 return v.__class__
             if isinstance(v, dict | str):
-                from lionagi.libs.schema import SchemaUtil
+                from lionagi.libs.schema.load_pydantic_model_from_schema import (
+                    load_pydantic_model_from_schema,
+                )
 
-                return SchemaUtil.load_pydantic_model_from_schema(v)
+                return load_pydantic_model_from_schema(v)
         except Exception as e:
             raise ValueError("Invalid request options") from e
         raise ValueError(