antfly-sdk 0.0.2.dev2__py3-none-any.whl

antfly/client_generated/models/agent_decision.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="AgentDecision")
+
+
+@_attrs_define
+class AgentDecision:
+    """
+    Attributes:
+        question_id (str): The question being answered
+        answer (Any | Unset): User answer, scalar or structured depending on the question kind
+        approved (bool | Unset): Used for confirm/review steps where the draft may be accepted as-is
+    """
+
+    question_id: str
+    answer: Any | Unset = UNSET
+    approved: bool | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        question_id = self.question_id
+
+        answer = self.answer
+
+        approved = self.approved
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "question_id": question_id,
+            }
+        )
+        if answer is not UNSET:
+            field_dict["answer"] = answer
+        if approved is not UNSET:
+            field_dict["approved"] = approved
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        question_id = d.pop("question_id")
+
+        answer = d.pop("answer", UNSET)
+
+        approved = d.pop("approved", UNSET)
+
+        agent_decision = cls(
+            question_id=question_id,
+            answer=answer,
+            approved=approved,
+        )
+
+        agent_decision.additional_properties = d
+        return agent_decision
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/agent_question.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.agent_question_kind import AgentQuestionKind
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="AgentQuestion")
+
+
+@_attrs_define
+class AgentQuestion:
+    """
+    Attributes:
+        id (str): Stable question identifier for client-carried continuation Example: clarify_oauth_version.
+        kind (AgentQuestionKind): UI rendering/answer handling hint for a bounded agent question
+        question (str): The clarifying question to ask the user
+        reason (str | Unset): Why clarification is needed
+        options (list[str] | Unset): Optional list of choices for the user
+        default_answer (str | Unset): Suggested default answer when the server has a preferred choice
+        affects (list[str] | Unset): High-level result areas affected by this decision
+    """
+
+    id: str
+    kind: AgentQuestionKind
+    question: str
+    reason: str | Unset = UNSET
+    options: list[str] | Unset = UNSET
+    default_answer: str | Unset = UNSET
+    affects: list[str] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        kind = self.kind.value
+
+        question = self.question
+
+        reason = self.reason
+
+        options: list[str] | Unset = UNSET
+        if not isinstance(self.options, Unset):
+            options = self.options
+
+        default_answer = self.default_answer
+
+        affects: list[str] | Unset = UNSET
+        if not isinstance(self.affects, Unset):
+            affects = self.affects
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "kind": kind,
+                "question": question,
+            }
+        )
+        if reason is not UNSET:
+            field_dict["reason"] = reason
+        if options is not UNSET:
+            field_dict["options"] = options
+        if default_answer is not UNSET:
+            field_dict["default_answer"] = default_answer
+        if affects is not UNSET:
+            field_dict["affects"] = affects
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        kind = AgentQuestionKind(d.pop("kind"))
+
+        question = d.pop("question")
+
+        reason = d.pop("reason", UNSET)
+
+        options = cast(list[str], d.pop("options", UNSET))
+
+        default_answer = d.pop("default_answer", UNSET)
+
+        affects = cast(list[str], d.pop("affects", UNSET))
+
+        agent_question = cls(
+            id=id,
+            kind=kind,
+            question=question,
+            reason=reason,
+            options=options,
+            default_answer=default_answer,
+            affects=affects,
+        )
+
+        agent_question.additional_properties = d
+        return agent_question
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/agent_question_kind.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class AgentQuestionKind(str, Enum):
+    CONFIRM = "confirm"
+    FIELD_POLICY = "field_policy"
+    FREE_TEXT = "free_text"
+    MULTI_CHOICE = "multi_choice"
+    SINGLE_CHOICE = "single_choice"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/agent_status.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class AgentStatus(str, Enum):
+    CLARIFICATION_REQUIRED = "clarification_required"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    INCOMPLETE = "incomplete"
+    IN_PROGRESS = "in_progress"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/agent_step.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.agent_step_kind import AgentStepKind
+from ..models.agent_step_status import AgentStepStatus
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.agent_step_details import AgentStepDetails
+
+
+T = TypeVar("T", bound="AgentStep")
+
+
+@_attrs_define
+class AgentStep:
+    """A step in the shared bounded-agent execution trace
+
+    Attributes:
+        name (str): Stable step name used for correlation across JSON and SSE surfaces
+        action (str): What action was taken
+        id (str | Unset): Unique step ID for correlation and tracing
+        kind (AgentStepKind | Unset): Shared bounded-agent step category
+        status (AgentStepStatus | Unset): Outcome of a shared agent step
+        error_message (str | Unset): Error details when status is "error"
+        duration_ms (int | Unset): Server-side execution time in milliseconds
+        details (AgentStepDetails | Unset): Additional details about the step
+    """
+
+    name: str
+    action: str
+    id: str | Unset = UNSET
+    kind: AgentStepKind | Unset = UNSET
+    status: AgentStepStatus | Unset = UNSET
+    error_message: str | Unset = UNSET
+    duration_ms: int | Unset = UNSET
+    details: AgentStepDetails | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        action = self.action
+
+        id = self.id
+
+        kind: str | Unset = UNSET
+        if not isinstance(self.kind, Unset):
+            kind = self.kind.value
+
+        status: str | Unset = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status.value
+
+        error_message = self.error_message
+
+        duration_ms = self.duration_ms
+
+        details: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.details, Unset):
+            details = self.details.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "action": action,
+            }
+        )
+        if id is not UNSET:
+            field_dict["id"] = id
+        if kind is not UNSET:
+            field_dict["kind"] = kind
+        if status is not UNSET:
+            field_dict["status"] = status
+        if error_message is not UNSET:
+            field_dict["error_message"] = error_message
+        if duration_ms is not UNSET:
+            field_dict["duration_ms"] = duration_ms
+        if details is not UNSET:
+            field_dict["details"] = details
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.agent_step_details import AgentStepDetails
+
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        action = d.pop("action")
+
+        id = d.pop("id", UNSET)
+
+        _kind = d.pop("kind", UNSET)
+        kind: AgentStepKind | Unset
+        if isinstance(_kind, Unset):
+            kind = UNSET
+        else:
+            kind = AgentStepKind(_kind)
+
+        _status = d.pop("status", UNSET)
+        status: AgentStepStatus | Unset
+        if isinstance(_status, Unset):
+            status = UNSET
+        else:
+            status = AgentStepStatus(_status)
+
+        error_message = d.pop("error_message", UNSET)
+
+        duration_ms = d.pop("duration_ms", UNSET)
+
+        _details = d.pop("details", UNSET)
+        details: AgentStepDetails | Unset
+        if isinstance(_details, Unset):
+            details = UNSET
+        else:
+            details = AgentStepDetails.from_dict(_details)
+
+        agent_step = cls(
+            name=name,
+            action=action,
+            id=id,
+            kind=kind,
+            status=status,
+            error_message=error_message,
+            duration_ms=duration_ms,
+            details=details,
+        )
+
+        agent_step.additional_properties = d
+        return agent_step
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/agent_step_details.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="AgentStepDetails")
+
+
+@_attrs_define
+class AgentStepDetails:
+    """Additional details about the step"""
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        agent_step_details = cls()
+
+        agent_step_details.additional_properties = d
+        return agent_step_details
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/agent_step_kind.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class AgentStepKind(str, Enum):
+    CLARIFICATION = "clarification"
+    CLASSIFICATION = "classification"
+    GENERATION = "generation"
+    PLANNING = "planning"
+    TOOL_CALL = "tool_call"
+    VALIDATION = "validation"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/agent_step_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class AgentStepStatus(str, Enum):
+    ERROR = "error"
+    SKIPPED = "skipped"
+    SUCCESS = "success"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/aggregation_bucket.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.aggregation_bucket_sub_aggregations import AggregationBucketSubAggregations
+
+
+T = TypeVar("T", bound="AggregationBucket")
+
+
+@_attrs_define
+class AggregationBucket:
+    """
+    Attributes:
+        key (str): Bucket key (term, range name, date, etc.)
+        doc_count (int): Number of documents in this bucket
+        key_as_string (str | Unset): Formatted key for display (e.g., formatted dates)
+        from_ (float | Unset): Lower bound for range buckets
+        to (float | Unset): Upper bound for range buckets
+        from_as_string (str | Unset): Formatted lower bound
+        to_as_string (str | Unset): Formatted upper bound
+        score (float | Unset): Significance score (for significant_terms)
+        bg_count (int | Unset): Background count (for significant_terms)
+        sub_aggregations (AggregationBucketSubAggregations | Unset): Results of nested sub-aggregations
+    """
+
+    key: str
+    doc_count: int
+    key_as_string: str | Unset = UNSET
+    from_: float | Unset = UNSET
+    to: float | Unset = UNSET
+    from_as_string: str | Unset = UNSET
+    to_as_string: str | Unset = UNSET
+    score: float | Unset = UNSET
+    bg_count: int | Unset = UNSET
+    sub_aggregations: AggregationBucketSubAggregations | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        key = self.key
+
+        doc_count = self.doc_count
+
+        key_as_string = self.key_as_string
+
+        from_ = self.from_
+
+        to = self.to
+
+        from_as_string = self.from_as_string
+
+        to_as_string = self.to_as_string
+
+        score = self.score
+
+        bg_count = self.bg_count
+
+        sub_aggregations: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.sub_aggregations, Unset):
+            sub_aggregations = self.sub_aggregations.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "key": key,
+                "doc_count": doc_count,
+            }
+        )
+        if key_as_string is not UNSET:
+            field_dict["key_as_string"] = key_as_string
+        if from_ is not UNSET:
+            field_dict["from"] = from_
+        if to is not UNSET:
+            field_dict["to"] = to
+        if from_as_string is not UNSET:
+            field_dict["from_as_string"] = from_as_string
+        if to_as_string is not UNSET:
+            field_dict["to_as_string"] = to_as_string
+        if score is not UNSET:
+            field_dict["score"] = score
+        if bg_count is not UNSET:
+            field_dict["bg_count"] = bg_count
+        if sub_aggregations is not UNSET:
+            field_dict["sub_aggregations"] = sub_aggregations
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.aggregation_bucket_sub_aggregations import AggregationBucketSubAggregations
+
+        d = dict(src_dict)
+        key = d.pop("key")
+
+        doc_count = d.pop("doc_count")
+
+        key_as_string = d.pop("key_as_string", UNSET)
+
+        from_ = d.pop("from", UNSET)
+
+        to = d.pop("to", UNSET)
+
+        from_as_string = d.pop("from_as_string", UNSET)
+
+        to_as_string = d.pop("to_as_string", UNSET)
+
+        score = d.pop("score", UNSET)
+
+        bg_count = d.pop("bg_count", UNSET)
+
+        _sub_aggregations = d.pop("sub_aggregations", UNSET)
+        sub_aggregations: AggregationBucketSubAggregations | Unset
+        if isinstance(_sub_aggregations, Unset):
+            sub_aggregations = UNSET
+        else:
+            sub_aggregations = AggregationBucketSubAggregations.from_dict(_sub_aggregations)
+
+        aggregation_bucket = cls(
+            key=key,
+            doc_count=doc_count,
+            key_as_string=key_as_string,
+            from_=from_,
+            to=to,
+            from_as_string=from_as_string,
+            to_as_string=to_as_string,
+            score=score,
+            bg_count=bg_count,
+            sub_aggregations=sub_aggregations,
+        )
+
+        aggregation_bucket.additional_properties = d
+        return aggregation_bucket
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/aggregation_bucket_sub_aggregations.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.aggregation_result import AggregationResult
+
+
+T = TypeVar("T", bound="AggregationBucketSubAggregations")
+
+
+@_attrs_define
+class AggregationBucketSubAggregations:
+    """Results of nested sub-aggregations"""
+
+    additional_properties: dict[str, AggregationResult] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.aggregation_result import AggregationResult
+
+        d = dict(src_dict)
+        aggregation_bucket_sub_aggregations = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = AggregationResult.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        aggregation_bucket_sub_aggregations.additional_properties = additional_properties
+        return aggregation_bucket_sub_aggregations
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> AggregationResult:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: AggregationResult) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties