hindsight-client 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

hindsight_client_api/models/reflect_based_on.py

@@ -0,0 +1,115 @@
+# coding: utf-8
+
+"""
+    Hindsight HTTP API
+
+    HTTP API for Hindsight
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from hindsight_client_api.models.reflect_directive import ReflectDirective
+from hindsight_client_api.models.reflect_fact import ReflectFact
+from hindsight_client_api.models.reflect_mental_model import ReflectMentalModel
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ReflectBasedOn(BaseModel):
+    """
+    Evidence the response is based on: memories, mental models, and directives.
+    """ # noqa: E501
+    memories: Optional[List[ReflectFact]] = Field(default=None, description="Memory facts used to generate the response")
+    mental_models: Optional[List[ReflectMentalModel]] = Field(default=None, description="Mental models used during reflection")
+    directives: Optional[List[ReflectDirective]] = Field(default=None, description="Directives applied during reflection")
+    __properties: ClassVar[List[str]] = ["memories", "mental_models", "directives"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ReflectBasedOn from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in memories (list)
+        _items = []
+        if self.memories:
+            for _item_memories in self.memories:
+                if _item_memories:
+                    _items.append(_item_memories.to_dict())
+            _dict['memories'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in mental_models (list)
+        _items = []
+        if self.mental_models:
+            for _item_mental_models in self.mental_models:
+                if _item_mental_models:
+                    _items.append(_item_mental_models.to_dict())
+            _dict['mental_models'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in directives (list)
+        _items = []
+        if self.directives:
+            for _item_directives in self.directives:
+                if _item_directives:
+                    _items.append(_item_directives.to_dict())
+            _dict['directives'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ReflectBasedOn from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "memories": [ReflectFact.from_dict(_item) for _item in obj["memories"]] if obj.get("memories") is not None else None,
+            "mental_models": [ReflectMentalModel.from_dict(_item) for _item in obj["mental_models"]] if obj.get("mental_models") is not None else None,
+            "directives": [ReflectDirective.from_dict(_item) for _item in obj["directives"]] if obj.get("directives") is not None else None
+        })
+        return _obj
+
+

hindsight_client_api/models/reflect_directive.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    Hindsight HTTP API
+
+    HTTP API for Hindsight
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ReflectDirective(BaseModel):
+    """
+    A directive applied during reflect.
+    """ # noqa: E501
+    id: StrictStr = Field(description="Directive ID")
+    name: StrictStr = Field(description="Directive name")
+    content: StrictStr = Field(description="Directive content")
+    __properties: ClassVar[List[str]] = ["id", "name", "content"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ReflectDirective from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ReflectDirective from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "name": obj.get("name"),
+            "content": obj.get("content")
+        })
+        return _obj
+
+

hindsight_client_api/models/reflect_include_options.py

@@ -19,6 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field
 from typing import Any, ClassVar, Dict, List, Optional
+from hindsight_client_api.models.tool_calls_include_options import ToolCallsIncludeOptions
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,7 +28,8 @@ class ReflectIncludeOptions(BaseModel):
     Options for including additional data in reflect results.
     """ # noqa: E501
     facts: Optional[Dict[str, Any]] = Field(default=None, description="Options for including facts (based_on) in reflect results.")
-    __properties: ClassVar[List[str]] = ["facts"]
+    tool_calls: Optional[ToolCallsIncludeOptions] = None
+    __properties: ClassVar[List[str]] = ["facts", "tool_calls"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -68,6 +70,14 @@ class ReflectIncludeOptions(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of tool_calls
+        if self.tool_calls:
+            _dict['tool_calls'] = self.tool_calls.to_dict()
+        # set to None if tool_calls (nullable) is None
+        # and model_fields_set contains the field
+        if self.tool_calls is None and "tool_calls" in self.model_fields_set:
+            _dict['tool_calls'] = None
+
         return _dict
 
     @classmethod
@@ -80,7 +90,8 @@ class ReflectIncludeOptions(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "facts": obj.get("facts")
+            "facts": obj.get("facts"),
+            "tool_calls": ToolCallsIncludeOptions.from_dict(obj["tool_calls"]) if obj.get("tool_calls") is not None else None
         })
         return _obj
 

hindsight_client_api/models/reflect_llm_call.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    Hindsight HTTP API
+
+    HTTP API for Hindsight
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ReflectLLMCall(BaseModel):
+    """
+    An LLM call made during reflect agent execution.
+    """ # noqa: E501
+    scope: StrictStr = Field(description="Call scope: agent_1, agent_2, final, etc.")
+    duration_ms: StrictInt = Field(description="Execution time in milliseconds")
+    __properties: ClassVar[List[str]] = ["scope", "duration_ms"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ReflectLLMCall from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ReflectLLMCall from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "scope": obj.get("scope"),
+            "duration_ms": obj.get("duration_ms")
+        })
+        return _obj
+
+

hindsight_client_api/models/reflect_mental_model.py

@@ -0,0 +1,96 @@
+# coding: utf-8
+
+"""
+    Hindsight HTTP API
+
+    HTTP API for Hindsight
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ReflectMentalModel(BaseModel):
+    """
+    A mental model used during reflect.
+    """ # noqa: E501
+    id: StrictStr = Field(description="Mental model ID")
+    text: StrictStr = Field(description="Mental model content")
+    context: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["id", "text", "context"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ReflectMentalModel from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if context (nullable) is None
+        # and model_fields_set contains the field
+        if self.context is None and "context" in self.model_fields_set:
+            _dict['context'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ReflectMentalModel from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "text": obj.get("text"),
+            "context": obj.get("context")
+        })
+        return _obj
+
+

hindsight_client_api/models/reflect_response.py

@@ -19,7 +19,8 @@ import json
 
 from pydantic import BaseModel, ConfigDict, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
-from hindsight_client_api.models.reflect_fact import ReflectFact
+from hindsight_client_api.models.reflect_based_on import ReflectBasedOn
+from hindsight_client_api.models.reflect_trace import ReflectTrace
 from hindsight_client_api.models.token_usage import TokenUsage
 from typing import Optional, Set
 from typing_extensions import Self
@@ -29,10 +30,11 @@ class ReflectResponse(BaseModel):
     Response model for think endpoint.
     """ # noqa: E501
     text: StrictStr
-    based_on: Optional[List[ReflectFact]] = None
+    based_on: Optional[ReflectBasedOn] = None
     structured_output: Optional[Dict[str, Any]] = None
     usage: Optional[TokenUsage] = None
-    __properties: ClassVar[List[str]] = ["text", "based_on", "structured_output", "usage"]
+    trace: Optional[ReflectTrace] = None
+    __properties: ClassVar[List[str]] = ["text", "based_on", "structured_output", "usage", "trace"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -73,16 +75,20 @@ class ReflectResponse(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in based_on (list)
-        _items = []
+        # override the default output from pydantic by calling `to_dict()` of based_on
         if self.based_on:
-            for _item_based_on in self.based_on:
-                if _item_based_on:
-                    _items.append(_item_based_on.to_dict())
-            _dict['based_on'] = _items
+            _dict['based_on'] = self.based_on.to_dict()
         # override the default output from pydantic by calling `to_dict()` of usage
         if self.usage:
             _dict['usage'] = self.usage.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of trace
+        if self.trace:
+            _dict['trace'] = self.trace.to_dict()
+        # set to None if based_on (nullable) is None
+        # and model_fields_set contains the field
+        if self.based_on is None and "based_on" in self.model_fields_set:
+            _dict['based_on'] = None
+
         # set to None if structured_output (nullable) is None
         # and model_fields_set contains the field
         if self.structured_output is None and "structured_output" in self.model_fields_set:
@@ -93,6 +99,11 @@ class ReflectResponse(BaseModel):
         if self.usage is None and "usage" in self.model_fields_set:
             _dict['usage'] = None
 
+        # set to None if trace (nullable) is None
+        # and model_fields_set contains the field
+        if self.trace is None and "trace" in self.model_fields_set:
+            _dict['trace'] = None
+
         return _dict
 
     @classmethod
@@ -106,9 +117,10 @@ class ReflectResponse(BaseModel):
 
         _obj = cls.model_validate({
             "text": obj.get("text"),
-            "based_on": [ReflectFact.from_dict(_item) for _item in obj["based_on"]] if obj.get("based_on") is not None else None,
+            "based_on": ReflectBasedOn.from_dict(obj["based_on"]) if obj.get("based_on") is not None else None,
             "structured_output": obj.get("structured_output"),
-            "usage": TokenUsage.from_dict(obj["usage"]) if obj.get("usage") is not None else None
+            "usage": TokenUsage.from_dict(obj["usage"]) if obj.get("usage") is not None else None,
+            "trace": ReflectTrace.from_dict(obj["trace"]) if obj.get("trace") is not None else None
         })
         return _obj
 

hindsight_client_api/models/reflect_tool_call.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+
+"""
+    Hindsight HTTP API
+
+    HTTP API for Hindsight
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ReflectToolCall(BaseModel):
+    """
+    A tool call made during reflect agent execution.
+    """ # noqa: E501
+    tool: StrictStr = Field(description="Tool name: lookup, recall, learn, expand")
+    input: Dict[str, Any] = Field(description="Tool input parameters")
+    output: Optional[Dict[str, Any]] = None
+    duration_ms: StrictInt = Field(description="Execution time in milliseconds")
+    iteration: Optional[StrictInt] = Field(default=0, description="Iteration number (1-based) when this tool was called")
+    __properties: ClassVar[List[str]] = ["tool", "input", "output", "duration_ms", "iteration"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ReflectToolCall from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # set to None if output (nullable) is None
+        # and model_fields_set contains the field
+        if self.output is None and "output" in self.model_fields_set:
+            _dict['output'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ReflectToolCall from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "tool": obj.get("tool"),
+            "input": obj.get("input"),
+            "output": obj.get("output"),
+            "duration_ms": obj.get("duration_ms"),
+            "iteration": obj.get("iteration") if obj.get("iteration") is not None else 0
+        })
+        return _obj
+
+