stackgen-sdk 0.1.1__py3-none-any.whl

stackgen/generated/models/investigation.py

@@ -0,0 +1,167 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from stackgen.generated.models.investigation_evidence import InvestigationEvidence
+from stackgen.generated.models.investigation_hypothesis import InvestigationHypothesis
+from stackgen.generated.models.investigation_prior_incident import InvestigationPriorIncident
+from stackgen.generated.models.investigation_status import InvestigationStatus
+from stackgen.generated.models.investigation_structured_rca import InvestigationStructuredRCA
+from stackgen.generated.models.investigation_triage_metadata import InvestigationTriageMetadata
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Investigation(BaseModel):
+    """
+    Full investigation record returned by /api/v1/investigations.
+    """ # noqa: E501
+    id: StrictStr
+    alert_id: StrictStr
+    guild_trace_id: StrictStr
+    guild_session_id: Optional[StrictStr] = None
+    status: InvestigationStatus
+    result_summary: Optional[StrictStr] = None
+    parent_investigation_id: Optional[StrictStr] = Field(default=None, description="When this investigation was created by forking another, the parent investigation it was forked from. Null for normal investigations.")
+    started_at: datetime
+    finished_at: Optional[datetime] = None
+    evidence: Optional[List[InvestigationEvidence]] = Field(default=None, description="Clickable evidence URLs attached to this investigation, in capture order. Empty when the agent has not submitted any citations.")
+    structured_rca: Optional[InvestigationStructuredRCA] = None
+    hypotheses: Optional[List[InvestigationHypothesis]] = Field(default=None, description="Ranked investigation hypotheses produced during structured triage. Empty when the agent has not submitted hypothesis rows.")
+    prior_incidents: Optional[List[InvestigationPriorIncident]] = Field(default=None, description="Similar prior incidents matched from memory or history. Empty when none were found or submitted.")
+    triage_metadata: Optional[InvestigationTriageMetadata] = None
+    __properties: ClassVar[List[str]] = ["id", "alert_id", "guild_trace_id", "guild_session_id", "status", "result_summary", "parent_investigation_id", "started_at", "finished_at", "evidence", "structured_rca", "hypotheses", "prior_incidents", "triage_metadata"]
+
+    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 Investigation 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 evidence (list)
+        _items = []
+        if self.evidence:
+            for _item_evidence in self.evidence:
+                if _item_evidence:
+                    _items.append(_item_evidence.to_dict())
+            _dict['evidence'] = _items
+        # override the default output from pydantic by calling `to_dict()` of structured_rca
+        if self.structured_rca:
+            _dict['structured_rca'] = self.structured_rca.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in hypotheses (list)
+        _items = []
+        if self.hypotheses:
+            for _item_hypotheses in self.hypotheses:
+                if _item_hypotheses:
+                    _items.append(_item_hypotheses.to_dict())
+            _dict['hypotheses'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in prior_incidents (list)
+        _items = []
+        if self.prior_incidents:
+            for _item_prior_incidents in self.prior_incidents:
+                if _item_prior_incidents:
+                    _items.append(_item_prior_incidents.to_dict())
+            _dict['prior_incidents'] = _items
+        # override the default output from pydantic by calling `to_dict()` of triage_metadata
+        if self.triage_metadata:
+            _dict['triage_metadata'] = self.triage_metadata.to_dict()
+        # set to None if guild_session_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.guild_session_id is None and "guild_session_id" in self.model_fields_set:
+            _dict['guild_session_id'] = None
+
+        # set to None if result_summary (nullable) is None
+        # and model_fields_set contains the field
+        if self.result_summary is None and "result_summary" in self.model_fields_set:
+            _dict['result_summary'] = None
+
+        # set to None if parent_investigation_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.parent_investigation_id is None and "parent_investigation_id" in self.model_fields_set:
+            _dict['parent_investigation_id'] = None
+
+        # set to None if finished_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.finished_at is None and "finished_at" in self.model_fields_set:
+            _dict['finished_at'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Investigation 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"),
+            "alert_id": obj.get("alert_id"),
+            "guild_trace_id": obj.get("guild_trace_id"),
+            "guild_session_id": obj.get("guild_session_id"),
+            "status": obj.get("status"),
+            "result_summary": obj.get("result_summary"),
+            "parent_investigation_id": obj.get("parent_investigation_id"),
+            "started_at": obj.get("started_at"),
+            "finished_at": obj.get("finished_at"),
+            "evidence": [InvestigationEvidence.from_dict(_item) for _item in obj["evidence"]] if obj.get("evidence") is not None else None,
+            "structured_rca": InvestigationStructuredRCA.from_dict(obj["structured_rca"]) if obj.get("structured_rca") is not None else None,
+            "hypotheses": [InvestigationHypothesis.from_dict(_item) for _item in obj["hypotheses"]] if obj.get("hypotheses") is not None else None,
+            "prior_incidents": [InvestigationPriorIncident.from_dict(_item) for _item in obj["prior_incidents"]] if obj.get("prior_incidents") is not None else None,
+            "triage_metadata": InvestigationTriageMetadata.from_dict(obj["triage_metadata"]) if obj.get("triage_metadata") is not None else None
+        })
+        return _obj
+
+

stackgen/generated/models/investigation_evidence.py

@@ -0,0 +1,114 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    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 datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from stackgen.generated.models.investigation_evidence_kind import InvestigationEvidenceKind
+from stackgen.generated.models.investigation_evidence_source import InvestigationEvidenceSource
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvestigationEvidence(BaseModel):
+    """
+    A single clickable citation attached to an investigation. Submitted by the Aiden agent via the `sre_update_investigation_status` or `sre_submit_investigation_evidence` MCP callbacks. `verified` and `captured_at` are always set server-side regardless of what the caller passes.
+    """ # noqa: E501
+    kind: InvestigationEvidenceKind
+    title: StrictStr = Field(description="Short, human-readable label for the evidence row.")
+    url: StrictStr = Field(description="Absolute http(s) URL the user can open.")
+    description: Optional[StrictStr] = Field(default=None, description="Plain DevOps context shown below the title: what this link shows and why it matters for triage (breach timing, firing condition, upstream dependency, prior incident match, etc.). Set by the agent when submitting evidence; the server may infer a default from kind or tool when omitted.")
+    source: InvestigationEvidenceSource
+    tool_name: Optional[StrictStr] = Field(default=None, description="Name of the tool invocation that produced this URL (only set when source=tool_trace).")
+    verified: StrictBool = Field(description="True when the URL host matches the per-tenant active-integration allowlist. Always set server-side; clients cannot mark a URL verified.")
+    captured_at: datetime = Field(description="Server timestamp when the URL was persisted.")
+    __properties: ClassVar[List[str]] = ["kind", "title", "url", "description", "source", "tool_name", "verified", "captured_at"]
+
+    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 InvestigationEvidence 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 description (nullable) is None
+        # and model_fields_set contains the field
+        if self.description is None and "description" in self.model_fields_set:
+            _dict['description'] = None
+
+        # set to None if tool_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.tool_name is None and "tool_name" in self.model_fields_set:
+            _dict['tool_name'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvestigationEvidence from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "kind": obj.get("kind"),
+            "title": obj.get("title"),
+            "url": obj.get("url"),
+            "description": obj.get("description"),
+            "source": obj.get("source"),
+            "tool_name": obj.get("tool_name"),
+            "verified": obj.get("verified"),
+            "captured_at": obj.get("captured_at")
+        })
+        return _obj
+
+

stackgen/generated/models/investigation_evidence_kind.py

@@ -0,0 +1,44 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    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 json
+from enum import Enum
+from typing_extensions import Self
+
+
+class InvestigationEvidenceKind(str, Enum):
+    """
+    Categorises an evidence URL so the UI can pick the right icon and group items by signal type.
+    """
+
+    """
+    allowed enum values
+    """
+    DASHBOARD = 'dashboard'
+    METRIC = 'metric'
+    LOG = 'log'
+    TRACE = 'trace'
+    RUNBOOK = 'runbook'
+    ALERT_RULE = 'alert_rule'
+    CONSOLE = 'console'
+    CODE = 'code'
+    OTHER = 'other'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of InvestigationEvidenceKind from a JSON string"""
+        return cls(json.loads(json_str))
+
+

stackgen/generated/models/investigation_evidence_source.py

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    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 json
+from enum import Enum
+from typing_extensions import Self
+
+
+class InvestigationEvidenceSource(str, Enum):
+    """
+    Provenance of an evidence URL. Drives UI trust labelling: `runbook` and `tool_trace` are treated as grounded citations, `llm` items are accepted but optionally labelled if outside the active-integration host allowlist, and `prior_knowledge` items render as non-clickable suggestions unless the host is verified.
+    """
+
+    """
+    allowed enum values
+    """
+    LLM = 'llm'
+    TOOL_TRACE = 'tool_trace'
+    RUNBOOK = 'runbook'
+    PRIOR_KNOWLEDGE = 'prior_knowledge'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of InvestigationEvidenceSource from a JSON string"""
+        return cls(json.loads(json_str))
+
+

stackgen/generated/models/investigation_hypothesis.py

@@ -0,0 +1,112 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvestigationHypothesis(BaseModel):
+    """
+    A single ranked hypothesis explored during triage.
+    """ # noqa: E501
+    statement: StrictStr = Field(description="Plain-language hypothesis statement.")
+    confidence: Optional[Union[Annotated[float, Field(le=1, strict=True, ge=0)], Annotated[int, Field(le=1, strict=True, ge=0)]]] = Field(default=None, description="Confidence in this hypothesis (0–1).")
+    status: Optional[StrictStr] = Field(default=None, description="Lifecycle status of the hypothesis after evidence review.")
+    __properties: ClassVar[List[str]] = ["statement", "confidence", "status"]
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['open', 'confirmed', 'rejected']):
+            raise ValueError("must be one of enum values ('open', 'confirmed', 'rejected')")
+        return value
+
+    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 InvestigationHypothesis 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 confidence (nullable) is None
+        # and model_fields_set contains the field
+        if self.confidence is None and "confidence" in self.model_fields_set:
+            _dict['confidence'] = None
+
+        # set to None if status (nullable) is None
+        # and model_fields_set contains the field
+        if self.status is None and "status" in self.model_fields_set:
+            _dict['status'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InvestigationHypothesis from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "statement": obj.get("statement"),
+            "confidence": obj.get("confidence"),
+            "status": obj.get("status")
+        })
+        return _obj
+
+

stackgen/generated/models/investigation_plain_summary.py

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+"""
+    StackGen External API
+
+    Allowlisted StackGen API surface for the public SDK. Managed via api-docs/product/allowlists/external.yaml.
+
+    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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class InvestigationPlainSummary(BaseModel):
+    """
+    Plain-language investigation answer and reasoning path for developers. Answer fields summarize the conclusion; how_we_got_here lists the short ordered steps that led there. No agent-internal vocabulary. When present, callers should populate verdict, what_broke, what_to_do, and how_we_got_here; fields are not OpenAPI-required so omitted plain_summary does not fail nested Assert on zero-value StructuredRCA.
+    """ # noqa: E501
+    verdict: Optional[StrictStr] = Field(default=None, description="High-level answer class for the investigation.")
+    what_broke: Optional[StrictStr] = Field(default=None, description="One sentence a developer who has never seen this service can understand. Name the service and what users saw or what the alert claimed. No internal agent vocabulary.")
+    what_to_do: Optional[StrictStr] = Field(default=None, description="One concrete next action on the customer system (fix the alert, check a dependency, roll back a deploy). Never an action on the investigation agent itself such as rehydrating a signal cache.")
+    how_we_got_here: Optional[Annotated[List[StrictStr], Field(min_length=2, max_length=5)]] = Field(default=None, description="Ordered path of 2–5 short plain-language steps. Each step is one sentence: what we checked and what it showed. Developer vocabulary only — no snapshot SHAs, plane names, or ledger jargon.")
+    __properties: ClassVar[List[str]] = ["verdict", "what_broke", "what_to_do", "how_we_got_here"]
+
+    @field_validator('verdict')
+    def verdict_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['real_problem', 'alert_is_misconfigured', 'not_enough_information']):
+            raise ValueError("must be one of enum values ('real_problem', 'alert_is_misconfigured', 'not_enough_information')")
+        return value
+
+    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 InvestigationPlainSummary 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 InvestigationPlainSummary from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "verdict": obj.get("verdict"),
+            "what_broke": obj.get("what_broke"),
+            "what_to_do": obj.get("what_to_do"),
+            "how_we_got_here": obj.get("how_we_got_here")
+        })
+        return _obj
+
+