lionagi 0.13.0__py3-none-any.whl → 0.13.2__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/providers/claude_code_.py

@@ -10,11 +10,13 @@ from typing import Any, Literal
 
 from claude_code_sdk import ClaudeCodeOptions
 from claude_code_sdk import query as sdk_query
+from claude_code_sdk import types as cc_types
 from pydantic import BaseModel, Field, field_validator, model_validator
 
+from lionagi.libs.schema.as_readable import as_readable
 from lionagi.service.connections.endpoint import Endpoint
 from lionagi.service.connections.endpoint_config import EndpointConfig
-from lionagi.utils import to_dict
+from lionagi.utils import to_dict, to_list
 
 # --------------------------------------------------------------------------- constants
 ClaudePermission = Literal[
@@ -67,6 +69,14 @@ class ClaudeCodeRequest(BaseModel):
     permission_prompt_tool_name: str | None = None
     disallowed_tools: list[str] = Field(default_factory=list)
 
+    # -- internal use --------------------------------------------------------
+    auto_finish: bool = Field(
+        default=True,
+        exclude=True,
+        description="Automatically finish the conversation after the first response",
+    )
+    verbose_output: bool = Field(default=False, exclude=True)
+
     # ------------------------ validators & helpers --------------------------
     @field_validator("permission_mode", mode="before")
     def _norm_perm(cls, v):
@@ -182,27 +192,46 @@ class ClaudeCodeRequest(BaseModel):
         if not messages:
             raise ValueError("messages may not be empty")
 
-        prompt = messages[-1]["content"]
-        if isinstance(prompt, (dict, list)):
-            prompt = json.dumps(prompt)
+        prompt = ""
 
-        if resume and continue_conversation is None:
+        # 1. if resume or continue_conversation, use the last message
+        if resume or continue_conversation:
             continue_conversation = True
-
+            prompt = messages[-1]["content"]
+            if isinstance(prompt, (dict, list)):
+                prompt = json.dumps(prompt)
+
+        # 2. else, use entire messages except system message
+        else:
+            prompts = []
+            continue_conversation = False
+            for message in messages:
+                if message["role"] != "system":
+                    content = message["content"]
+                    prompts.append(
+                        json.dumps(content)
+                        if isinstance(content, (dict, list))
+                        else content
+                    )
+
+            prompt = "\n".join(prompts)
+
+        # 3. assemble the request data
         data: dict[str, Any] = dict(
             prompt=prompt,
             resume=resume,
             continue_conversation=bool(continue_conversation),
         )
 
+        # 4. extract system prompt if available
         if (messages[0]["role"] == "system") and (
             resume or continue_conversation
         ):
             data["system_prompt"] = messages[0]["content"]
-
-        # Merge optional system prompts
-        if kwargs.get("system_prompt"):
-            data["append_system_prompt"] = kwargs.pop("system_prompt")
+        if kwargs.get("append_system_prompt"):
+            data["append_system_prompt"] = str(
+                kwargs.get("append_system_prompt")
+            )
 
         data.update(kwargs)
         return cls.model_validate(data, strict=False)
@@ -238,7 +267,7 @@ class ClaudeCodeEndpoint(Endpoint):
         )
 
     async def stream(self, request: dict | BaseModel, **kwargs):
-        payload = self.create_payload(request, **kwargs)["request"]
+        payload, _ = self.create_payload(request, **kwargs)["request"]
         async for chunk in self._stream_claude_code(payload):
             yield chunk
 
@@ -258,6 +287,7 @@ class ClaudeCodeEndpoint(Endpoint):
             "session_id": None,
             "model": "claude-code",
             "result": "",
+            "tool_uses": [],
             "tool_results": [],
             "is_error": False,
             "num_turns": None,
@@ -269,17 +299,31 @@ class ClaudeCodeEndpoint(Endpoint):
             },
         }
 
-        from claude_code_sdk import types
-
         for response in responses:
-            if isinstance(response, types.SystemMessage):
+            if isinstance(response, cc_types.SystemMessage):
                 results["session_id"] = response.data.get("session_id")
                 results["model"] = response.data.get("model", "claude-code")
-            if isinstance(response, types.AssistantMessage):
-                for block in response.content:
-                    if isinstance(block, types.TextBlock):
+            if isinstance(
+                response, cc_types.AssistantMessage | cc_types.UserMessage
+            ):
+                for block in to_list(
+                    response.content,
+                    flatten=True,
+                    flatten_tuple_set=True,
+                    dropna=True,
+                ):
+                    if isinstance(block, cc_types.TextBlock):
                         results["result"] += block.text.strip() + "\n"
-                    if isinstance(block, types.ToolResultBlock):
+
+                    if isinstance(block, cc_types.ToolUseBlock):
+                        entry = {
+                            "id": block.id,
+                            "name": block.name,
+                            "input": block.input,
+                        }
+                        results["tool_uses"].append(entry)
+
+                    if isinstance(block, cc_types.ToolResultBlock):
                         results["tool_results"].append(
                             {
                                 "tool_use_id": block.tool_use_id,
@@ -287,8 +331,10 @@ class ClaudeCodeEndpoint(Endpoint):
                                 "is_error": block.is_error,
                             }
                         )
-            if isinstance(response, types.ResultMessage):
-                results["result"] += response.result.strip() or ""
+
+            if isinstance(response, cc_types.ResultMessage):
+                if response.result:
+                    results["result"] = str(response.result).strip()
                 results["usage"] = response.usage
                 results["is_error"] = response.is_error
                 results["total_cost_usd"] = response.total_cost_usd
@@ -305,7 +351,135 @@ class ClaudeCodeEndpoint(Endpoint):
         **kwargs,
     ):
         responses = []
+        request: ClaudeCodeRequest = payload["request"]
+        system: cc_types.SystemMessage = None
+
+        # 1. stream the Claude Code response
         async for chunk in self._stream_claude_code(**payload):
+
+            if request.verbose_output:
+                _display_message(chunk)
+
+            if isinstance(chunk, cc_types.SystemMessage):
+                system = chunk
             responses.append(chunk)
 
+        # 2. If the last response is not a ResultMessage and auto_finish is True,
+        #   we need to query Claude Code again to get the final result message.
+        if request.auto_finish and not isinstance(
+            responses[-1], cc_types.ResultMessage
+        ):
+            options = request.as_claude_options()
+            options.continue_conversation = True
+            options.max_turns = 1
+            if system:
+                options.resume = (
+                    system.data.get("session_id", None) if system else None
+                )
+
+            async for chunk in sdk_query(
+                prompt="Please provide a the final result message only",
+                options=options,
+            ):
+                if isinstance(chunk, cc_types.ResultMessage):
+                    if request.verbose_output:
+                        str_ = _verbose_output(chunk)
+                        if str_:
+                            as_readable(
+                                str_,
+                                md=True,
+                                display_str=True,
+                                format_curly=True,
+                                max_panel_width=100,
+                                theme="light",
+                            )
+
+                    responses.append(chunk)
+
+        # 3. Parse the responses into a clean format
         return self._parse_claude_code_response(responses)
+
+
+def _display_message(chunk):
+    if isinstance(
+        chunk,
+        cc_types.SystemMessage
+        | cc_types.AssistantMessage
+        | cc_types.UserMessage,
+    ):
+        str_ = _verbose_output(chunk)
+        if str_:
+            if str_.startswith("Claude:"):
+                as_readable(
+                    str_,
+                    md=True,
+                    display_str=True,
+                    max_panel_width=100,
+                    theme="light",
+                )
+            else:
+                as_readable(
+                    str_,
+                    format_curly=True,
+                    display_str=True,
+                    max_panel_width=100,
+                    theme="light",
+                )
+
+    if isinstance(chunk, cc_types.ResultMessage):
+        str_ = _verbose_output(chunk)
+        as_readable(
+            str_,
+            md=True,
+            display_str=True,
+            format_curly=True,
+            max_panel_width=100,
+            theme="light",
+        )
+
+
+def _verbose_output(res: cc_types.Message) -> str:
+    str_ = ""
+    if isinstance(res, cc_types.SystemMessage):
+        str_ = f"Claude Code Session Started: {res.data.get('session_id', 'unknown')}"
+        str_ += f"\nModel: {res.data.get('model', 'claude-code')}\n---"
+        return str_
+
+    if isinstance(res, cc_types.AssistantMessage | cc_types.UserMessage):
+        for block in to_list(
+            res.content, flatten=True, flatten_tuple_set=True, dropna=True
+        ):
+            if isinstance(block, cc_types.TextBlock):
+                text = (
+                    block.text.strip() if isinstance(block.text, str) else ""
+                )
+                str_ += f"Claude:\n{text}"
+
+            if isinstance(block, cc_types.ToolUseBlock):
+                input = (
+                    json.dumps(block.input, indent=2)
+                    if isinstance(block.input, dict)
+                    else str(block.input)
+                )
+                input = input[:200] + "..." if len(input) > 200 else input
+                str_ += (
+                    f"Tool Use: {block.name} - {block.id}\n  - Input: {input}"
+                )
+
+            if isinstance(block, cc_types.ToolResultBlock):
+                content = str(block.content)
+                content = (
+                    content[:200] + "..." if len(content) > 200 else content
+                )
+                str_ += (
+                    f"Tool Result: {block.tool_use_id}\n  - Content: {content}"
+                )
+        return str_
+
+    if isinstance(res, cc_types.ResultMessage):
+        str_ += f"Session Completion - {res.session_id}"
+        str_ += f"\nResult: {res.result or 'No result'}"
+        str_ += f"\n- Cost: ${res.total_cost_usd:.4f} USD"
+        str_ += f"\n- Duration: {res.duration_ms} ms (API: {res.duration_api_ms} ms)"
+        str_ += f"\n- Turns: {res.num_turns}"
+        return str_

lionagi/service/connections/providers/oai_.py

@@ -53,7 +53,7 @@ OPENROUTER_CHAT_ENDPOINT_CONFIG = EndpointConfig(
     provider="openrouter",
     base_url="https://openrouter.ai/api/v1",
     endpoint="chat/completions",
-    kwargs={"model": "google/gemini-2.5-flash-preview-05-20"},
+    kwargs={"model": "google/gemini-2.5-flash"},
     api_key=settings.OPENROUTER_API_KEY or "dummy-key-for-testing",
     auth_type="bearer",
     content_type="application/json",
@@ -61,18 +61,6 @@ OPENROUTER_CHAT_ENDPOINT_CONFIG = EndpointConfig(
     request_options=CreateChatCompletionRequest,
 )
 
-OPENROUTER_GEMINI_ENDPOINT_CONFIG = EndpointConfig(
-    name="openrouter_gemini",
-    provider="openrouter",
-    base_url="https://openrouter.ai/api/v1",
-    endpoint="chat/completions",
-    kwargs={"model": "google/gemini-2.5-flash-preview-05-20"},
-    api_key=settings.OPENROUTER_API_KEY or "dummy-key-for-testing",
-    auth_type="bearer",
-    content_type="application/json",
-    method="POST",
-)
-
 OPENAI_EMBEDDING_ENDPOINT_CONFIG = EndpointConfig(
     name="openai_embed",
     provider="openai",