Exceptions

from tenxgraph.core.exceptions import (
    GraphError,
    GraphRecursionError,
    GraphStopRequested,
    MetricsError,
    NodeError,
    NodeTimeoutError,
    ResourceNotFoundError,
    SchemaVersionError,
    SerializationError,
    StaleStateError,
    StorageError,
    TransientStorageError,
)

# Not re-exported from the package, import it from its module
from tenxgraph.core.exceptions.media_exceptions import UnsupportedMediaInputError

Exception
  GraphError
    NodeError
      NodeTimeoutError
    GraphRecursionError
  GraphStopRequested
  StorageError
    TransientStorageError
    SerializationError
    SchemaVersionError
    StaleStateError
    ResourceNotFoundError
  MetricsError
  UnsupportedMediaInputError

class GraphError(Exception):
    def __init__(
        self,
        message: str,
        error_code: str = "GRAPH_000",
        context: dict[str, Any] | None = None,
    ) -> None: ...

from tenxgraph.core.exceptions import GraphError

try:
    raise GraphError(
        message="Invalid graph structure",
        error_code="GRAPH_001",
        context={"node_count": 5},
    )
except GraphError as e:
    print(e.to_dict())
    # {'error_type': 'GraphError', 'error_code': 'GRAPH_001', ...}

class NodeError(GraphError):
    def __init__(
        self,
        message: str,
        error_code: str = "NODE_000",
        context: dict[str, Any] | None = None,
    ) -> None: ...

from tenxgraph.core.exceptions import NodeError

raise NodeError(
    message="Node failed to execute",
    error_code="NODE_001",
    context={"node_name": "process_data"},
)

class NodeTimeoutError(NodeError):
    def __init__(
        self,
        message: str,
        error_code: str = "NODE_TIMEOUT_000",
        context: dict[str, Any] | None = None,
    ) -> None: ...

from tenxgraph.core.exceptions import NodeTimeoutError

raise NodeTimeoutError(
    message="Node 'fetch' exceeded its 300s timeout",
    error_code="NODE_TIMEOUT_001",
    context={"node_name": "fetch", "timeout": 300.0},
)

class GraphRecursionError(GraphError):
    def __init__(
        self,
        message: str,
        error_code: str = "RECURSION_000",
        context: dict[str, Any] | None = None,
    ) -> None: ...

from tenxgraph.core.exceptions import GraphRecursionError

raise GraphRecursionError(
    message="Recursion limit exceeded",
    error_code="RECURSION_001",
    context={"recursion_depth": 26, "max_depth": 25},
)

class GraphStopRequested(Exception):
    def __init__(self, node_name: str | None = None) -> None: ...

from tenxgraph.core.exceptions import GraphStopRequested

# Typically raised by the execution loop during stop handling
raise GraphStopRequested(node_name="fetch_data")

class StorageError(Exception):
    def __init__(
        self,
        message: str,
        error_code: str = "STORAGE_000",
        context: dict[str, Any] | None = None,
    ) -> None: ...

from tenxgraph.core.exceptions import StorageError

raise StorageError(
    message="Database connection failed",
    error_code="STORAGE_001",
    context={"host": "db.example.com"},
)

class TransientStorageError(StorageError):
    def __init__(
        self,
        message: str,
        error_code: str = "STORAGE_TRANSIENT_000",
        context: dict[str, Any] | None = None,
    ) -> None: ...

from tenxgraph.core.exceptions import TransientStorageError

raise TransientStorageError(
    message="Redis connection timeout",
    error_code="STORAGE_TRANSIENT_001",
    context={"timeout": 5.0},
)

class SerializationError(StorageError):
    def __init__(
        self,
        message: str,
        error_code: str = "STORAGE_SERIALIZATION_000",
        context: dict[str, Any] | None = None,
    ) -> None: ...

from tenxgraph.core.exceptions import SerializationError

raise SerializationError(
    message="Failed to deserialize message content",
    error_code="STORAGE_SERIALIZATION_001",
    context={"message_id": "msg_123"},
)

class SchemaVersionError(StorageError):
    def __init__(
        self,
        message: str,
        error_code: str = "STORAGE_SCHEMA_000",
        context: dict[str, Any] | None = None,
    ) -> None: ...

from tenxgraph.core.exceptions import SchemaVersionError

raise SchemaVersionError(
    message="Database schema version 3 not supported by code version 2.0",
    error_code="STORAGE_SCHEMA_001",
    context={"db_version": 3, "code_version": 2},
)

class StaleStateError(StorageError):
    def __init__(
        self,
        message: str,
        error_code: str = "STORAGE_CONFLICT_000",
        context: dict[str, Any] | None = None,
    ) -> None: ...

from tenxgraph.core.exceptions import StaleStateError

raise StaleStateError(
    message="State was updated by another execution",
    error_code="STORAGE_CONFLICT_001",
    context={"thread_id": "thread_abc", "expected_version": 5, "actual_version": 6},
)

class ResourceNotFoundError(StorageError):
    def __init__(
        self,
        message: str,
        error_code: str = "STORAGE_NOT_FOUND_000",
        context: dict[str, Any] | None = None,
    ) -> None: ...

from tenxgraph.core.exceptions import ResourceNotFoundError

raise ResourceNotFoundError(
    message="Thread not found",
    error_code="STORAGE_NOT_FOUND_001",
    context={"thread_id": "thread_xyz"},
)

class MetricsError(Exception):
    def __init__(
        self,
        message: str,
        error_code: str = "METRICS_000",
        context: dict[str, Any] | None = None,
    ) -> None: ...

from tenxgraph.core.exceptions import MetricsError

try:
    raise MetricsError(
        message="Failed to send metrics to collector",
        error_code="METRICS_001",
        context={"collector": "prometheus"},
    )
except MetricsError:
    # Log and continue; do not fail execution
    pass

class UnsupportedMediaInputError(Exception):
    def __init__(
        self,
        provider: str,
        model: str,
        media_type: str,
        source_kind: str,
        transports_attempted: list[MediaTransportMode] | None = None,
        message: str | None = None,
    ) -> None: ...

from tenxgraph.core.exceptions import UnsupportedMediaInputError
from tenxgraph.storage.media.capabilities import MediaTransportMode

raise UnsupportedMediaInputError(
    provider="openai",
    model="gpt-4o",
    media_type="audio",
    source_kind="url",
    transports_attempted=[MediaTransportMode.remote_url],
)