keble-task 2.22.0__py3-none-any.whl

keble_task/agent/tools/mutation.py

@@ -0,0 +1,100 @@
+"""Package-owned pydantic-ai MUTATION tool registrar for generic task actions.
+
+This module is BEHAVIOR ONLY: the tool-registration config
+(``TaskAgentMutationToolsConfig``) lives in ``keble_task.schemas.for_agent``; the
+single-action tool payload (``TaskAction``) and its result
+(``CreateRelatedTaskActionedResult``) live in the external action module
+``keble_task.actions``. One tool call = one action. Nothing here defines a
+``BaseModel``.
+
+Side effect if changes:
+- Tool NAME (``mutate_task_workspace``) is persisted in room diagnostics and
+  mapped to frontend labels — never rename casually.
+- ``register_mutation_tools`` is consumed by keble.backend chat composition.
+"""
+
+from __future__ import annotations
+
+from typing import Any, TypeVar
+
+import keble_exceptions
+from keble_helpers import AgentToolApprovalMode, AgentToolRegistrationConfig
+from pydantic_ai import Agent, ModelRetry, RunContext
+
+from keble_task.actions import CreateRelatedTaskActionedResult, TaskAction
+from keble_task.main import TaskClient
+from keble_task.schemas.for_agent import TaskAgentMutationToolsConfig
+
+from ..deps import TaskAgentDeps
+
+DepsT = TypeVar("DepsT", bound=TaskAgentDeps)
+
+
+def register_mutation_tools(
+    agent: Agent[DepsT, Any],
+    *,
+    task_client: TaskClient,
+    tools_config: TaskAgentMutationToolsConfig | dict[str, Any] | None = None,
+) -> None:
+    """Register task-owned mutation tools on a pydantic-ai agent.
+
+    Step by step this registrar:
+    1. builds tool metadata through schema-owned `build(...)` methods;
+    2. registers one `mutate_task_workspace` tool owned by this package;
+    3. reads Mongo/Redis from `AgentDbDeps`;
+    4. delegates ONE action per call to `TaskClient.aapply_action(...)`.
+    """
+
+    config = TaskAgentMutationToolsConfig.build(tools_config)
+    # Keep the resolved tool config under a distinct name so it does not shadow the
+    # decorated `mutate_task_workspace` tool function below. Sharing one name makes the
+    # type checker unify the symbol and flag the registration config assignment
+    # against the tool-function type; the rename keeps both strongly typed.
+    mutate_task_workspace_config = AgentToolRegistrationConfig.build(
+        config.mutate_task_workspace
+    )
+
+    @agent.tool(
+        name=mutate_task_workspace_config.name,
+        description=mutate_task_workspace_config.description,
+        requires_approval=(
+            mutate_task_workspace_config.approval
+            is AgentToolApprovalMode.REQUIRE_APPROVAL
+        ),
+    )
+    async def mutate_task_workspace(
+        ctx: RunContext[DepsT],
+        *,
+        payload: TaskAction,
+    ) -> CreateRelatedTaskActionedResult:
+        """Apply ONE typed task workspace action through `TaskClient`.
+
+        One tool call = one action = one approval card. To create several
+        related tasks the agent emits several `mutate_task_workspace` calls; the
+        deferred-batch runtime holds them and the frontend resolves one card per
+        click (in order). Do NOT re-introduce a `actions: list[...]` payload.
+        """
+
+        try:
+            return await task_client.aapply_action(
+                amongo=ctx.deps.amongo,
+                current_task=ctx.deps.task.current_task,
+                action=payload,
+                ux_context=ctx.deps.task.ux_context,
+                event_emitter=ctx.deps.task.event_emitter,
+                extended_aredis=ctx.deps.extended_aredis,
+            )
+        except (
+            keble_exceptions.ClientSideInvalidParams,
+            keble_exceptions.ClientSideMissingParams,
+            keble_exceptions.ServerSideInvalidParams,
+        ) as exc:
+            # The model supplied invalid action input (a hallucinated parent_task_id /
+            # from_task_id, a cross-room reference, or a missing required field). Surface it
+            # as a retryable signal so the model corrects its own arguments instead of
+            # aborting the run. Wiring/infra faults (e.g. ServerSideMissingParams) are NOT
+            # caught here and propagate as real failures.
+            raise ModelRetry(str(exc)) from exc
+
+
+__all__ = ["register_mutation_tools"]

keble_task/agent/tools/query.py

@@ -0,0 +1,160 @@
+"""Package-owned pydantic-ai READ/QUERY tool registrar for generic task browsing.
+
+These tools let a chat agent discover and inspect tasks without mutating them.
+They are thin, owner-scoped wrappers over `TaskClient` read methods:
+
+1. ``list_tasks`` lists the chat owner's tasks (optionally one task type);
+2. ``get_task`` loads one owner-visible task by id.
+
+All tools are owner-scoped to the chat's ``current_task.owner`` so the agent can
+only ever read its own owner's tasks. They are non-mutating and never require
+approval. Background-session inspection is intentionally NOT duplicated here —
+that is owned by the host-neutral general tools (``check_background_sessions``)
+in ``keble_agentic_chat`` so there is one canonical session-poll path.
+
+This module is BEHAVIOR ONLY: every tool I/O contract lives in
+``keble_task.schemas.for_agent`` (the ``TaskSummaryForAgent`` projection + the
+``TaskAgentQueryToolsConfig``); nothing here defines a ``BaseModel``.
+
+Side effect if changes:
+- Tool NAMES (``list_tasks`` / ``get_task``) are persisted in room diagnostics
+  and mapped to frontend labels — never rename casually.
+- Return projection comes from ``schemas/for_agent.py``; field renames change the
+  agent-visible JSON.
+"""
+
+from __future__ import annotations
+
+from typing import Any, TypeVar
+
+from keble_helpers import (
+    AgentToolRegistrationConfig,
+    parse_object_id_or_model_retry,
+    require_object_or_model_retry,
+)
+from pydantic_ai import Agent, RunContext
+
+from keble_task.main import TaskClient
+from keble_task.schemas.for_agent import (
+    TaskAgentQueryToolsConfig,
+    TaskSummaryForAgent,
+)
+
+from ..deps import TaskAgentDeps
+
+DepsT = TypeVar("DepsT", bound=TaskAgentDeps)
+
+
+def register_query_tools(
+    agent: Agent[DepsT, Any],
+    *,
+    task_client: TaskClient,
+    tools_config: TaskAgentQueryToolsConfig | dict[str, Any] | None = None,
+) -> None:
+    """Register task-owned READ/QUERY tools on a pydantic-ai agent.
+
+    Step by step this registrar:
+    1. resolves per-tool name/description overrides through schema ``build(...)``;
+    2. registers owner-scoped, non-mutating ``list_tasks`` / ``get_task`` tools;
+    3. reads Mongo/Redis and the chat owner from ``TaskAgentDeps``;
+    4. surfaces a bad model-supplied id as ``ModelRetry`` so the model self-corrects.
+    """
+
+    config = TaskAgentQueryToolsConfig.build(tools_config)
+    list_cfg = AgentToolRegistrationConfig.build(config.list_tasks)
+    get_cfg = AgentToolRegistrationConfig.build(config.get_task)
+
+    @agent.tool(
+        name=list_cfg.name or "list_tasks",
+        description=(
+            list_cfg.description
+            or "List your TOP-LEVEL tasks (most recent first). Optional filters: "
+            "task_type (e.g. AMZ_PRODUCT_REPORT or POSITIONING), stage (e.g. "
+            "SUCCESS, FAILURE, PROCESSING), title_contains (case-insensitive "
+            "substring), and parent_task_id (lists that task's DIRECT children "
+            "instead of top-level tasks). Returns "
+            "compact summaries with id, type, title, stage, and failure facts. "
+            "IMPORTANT: background sessions started inside a chat are CHILD tasks "
+            "and will NOT appear here — read them with check_background_sessions, "
+            "or open any session_id directly with get_task (a session_id IS a "
+            "task id)."
+        ),
+        requires_approval=False,
+    )
+    async def list_tasks(
+        ctx: RunContext[DepsT],
+        *,
+        task_type: str | None = None,
+        stage: str | None = None,
+        title_contains: str | None = None,
+        parent_task_id: str | None = None,
+        limit: int = 20,
+    ) -> list[TaskSummaryForAgent]:
+        """List the chat owner's tasks with optional indexed-shape filters.
+
+        Step by step (2.10.0 enrichment):
+        1. `task_type` / `stage` are exact-value filters; `title_contains`
+           is a case-insensitive substring match (owner-bounded);
+        2. `parent_task_id` lists the direct children of one task —
+           malformed ids are ModelRetry so the model self-corrects;
+        3. results stay bounded compact summaries (limit <= 50).
+        """
+
+        owner = ctx.deps.task.current_task.owner
+        bounded_limit = max(1, min(limit, 50))
+        parent_object_id = (
+            parse_object_id_or_model_retry(
+                parent_task_id, field_name="parent_task_id"
+            )
+            if parent_task_id is not None
+            else None
+        )
+        tasks = await task_client.aowner_get_multi(
+            amongo=ctx.deps.amongo,
+            extended_aredis=ctx.deps.extended_aredis,
+            owner=owner,
+            skip=0,
+            limit=bounded_limit,
+            task_types=[task_type] if task_type is not None else None,
+            sharing_scopes=None,
+            stages=[stage] if stage is not None else None,
+            title_contains=title_contains,
+            parent_task=parent_object_id,
+        )
+        return [TaskSummaryForAgent.from_task(task) for task in tasks]
+
+    @agent.tool(
+        name=get_cfg.name or "get_task",
+        description=(
+            get_cfg.description
+            or "Load one of your tasks by its id and return a compact summary "
+            "(type, title, stage, parent/root ids, plus error and exception_type "
+            "when it failed). Works for ANY of your tasks, including chat-started "
+            "background sessions — a session_id from the start/check session "
+            "tools IS a valid task_id here."
+        ),
+        requires_approval=False,
+    )
+    async def get_task(
+        ctx: RunContext[DepsT],
+        *,
+        task_id: str,
+    ) -> TaskSummaryForAgent:
+        """Load one owner-visible task by id; raise ObjectNotFound when missing."""
+
+        object_id = parse_object_id_or_model_retry(task_id, field_name="task_id")
+        task = require_object_or_model_retry(
+            await task_client.aowner_get(
+                amongo=ctx.deps.amongo,
+                owner=ctx.deps.task.current_task.owner,
+                task_id=object_id,
+                task_type=None,
+                sharing_scope=None,
+            ),
+            field_name="task_id",
+            raw=task_id,
+        )
+        return TaskSummaryForAgent.from_task(task)
+
+
+__all__ = ["register_query_tools"]

keble_task/crud.py

@@ -0,0 +1,347 @@
+import keble_exceptions
+from keble_db import MongoCRUDBase, QueryBase
+from keble_helpers import ObjectId
+from motor.motor_asyncio import AsyncIOMotorClient
+from pymongo import ASCENDING, DESCENDING, IndexModel
+from pymongo import MongoClient
+from pymongo.results import InsertOneResult
+
+from . import schemas
+
+
+class CRUDTask(MongoCRUDBase[schemas.TaskMongoObject]):
+    async def aensure_public_id_index(self, amongo: AsyncIOMotorClient) -> None:
+        await amongo[self.database][self.collection].create_index(
+            [("public_id", 1)],
+            unique=True,
+            name="public_id_unique",
+            partialFilterExpression={"public_id": {"$type": "string"}},
+        )
+
+    async def aensure_task_indexes(self, amongo: AsyncIOMotorClient) -> None:
+        """Create indexes for root-tree, root-list, and stage-scan task reads.
+
+        Step by step:
+        1. `root_task + created` backs the `$or` root-tree branch (`aget_tasks_in_root_tree`)
+           and descendant/lineage scans that filter by root and sort newest-first;
+        2. `parent_task + created` backs root-task listing (`parent_task=None`) and
+           immediate-child lookups sorted by creation time;
+        3. `stage + created` backs the retry/timeout sweeps (`aretry_all_undone`,
+           `aget_tasks_by_stage_since`) that match `stage $in [...]` over a `created` window;
+        4. `owner + parent_task + created` backs owner-scoped root lists
+           (`aowner_get_multi` -> `_aget_root_tasks`, which fix `parent_task=None`), so `owner`
+           is an indexed equality instead of a residual post-filter;
+        5. `sharing_scope + parent_task + created` backs public root lists
+           (`apublic_get_multi`, fixed `sharing_scope=PUBLIC`, `parent_task=None`).
+        6. `sharing_scope + task_type + stage + updated` backs the dynamic-page
+           sitemap read (`apublic_list_indexable`, fixed `sharing_scope=PUBLIC`,
+           `task_type $in`, `stage $in`, sorted `updated` DESC).
+
+        Field order is scope/equality first then the `created`/`updated` sort/range
+        field so each index serves its query shape (`task_type`/`root_task` remain
+        residual filters where not led). Creation is idempotent via `create_indexes`.
+        """
+
+        collection = amongo[self.database][self.collection]
+        await collection.create_indexes(
+            [
+                IndexModel(
+                    [("root_task", ASCENDING), ("created", DESCENDING)],
+                    name="root_task_created_desc_idx",
+                ),
+                IndexModel(
+                    [("parent_task", ASCENDING), ("created", DESCENDING)],
+                    name="parent_task_created_desc_idx",
+                ),
+                IndexModel(
+                    [("stage", ASCENDING), ("created", DESCENDING)],
+                    name="stage_created_desc_idx",
+                ),
+                IndexModel(
+                    [
+                        ("owner", ASCENDING),
+                        ("parent_task", ASCENDING),
+                        ("created", DESCENDING),
+                    ],
+                    name="owner_parent_task_created_desc_idx",
+                ),
+                IndexModel(
+                    [
+                        ("sharing_scope", ASCENDING),
+                        ("parent_task", ASCENDING),
+                        ("created", DESCENDING),
+                    ],
+                    name="sharing_scope_parent_task_created_desc_idx",
+                ),
+                IndexModel(
+                    [
+                        ("sharing_scope", ASCENDING),
+                        ("task_type", ASCENDING),
+                        ("stage", ASCENDING),
+                        ("updated", DESCENDING),
+                    ],
+                    name="sharing_scope_task_type_stage_updated_desc_idx",
+                ),
+            ]
+        )
+
+    async def aget_tasks_in_root_tree(
+        self,
+        amongo: AsyncIOMotorClient,
+        *,
+        root_id: ObjectId,
+        base_filter: dict,
+    ) -> list[schemas.TaskMongoObject]:
+        filter_ = dict(base_filter)
+        filter_["$or"] = [{"_id": root_id}, {"root_task": root_id}]
+        return await self.aget_multi(
+            amongo,
+            query=QueryBase(
+                filters=filter_,
+                order_by=[("created", DESCENDING)],
+            ),
+        )
+
+    def increment_attempts(
+        self, mongo: MongoClient, *, _id: ObjectId, increment: int = 1
+    ) -> schemas.TaskMongoObject:
+        existed_obj = self.first_by_id(mongo, _id=_id)
+        if existed_obj is None:
+            raise keble_exceptions.ServerSideInvalidParams(
+                admin_note={"task_id": _id},
+                alert_admin=True,
+                but_got="db_obj is None",
+                expected="db_obj is not None",
+                invalid_params="task_id",
+            )
+        self.update(
+            mongo, _id=_id, obj_in={"attempts": existed_obj.attempts + increment}
+        )
+        db_obj = self.first_by_id(mongo, _id=_id)
+        assert db_obj is not None
+        return db_obj
+
+    async def aincrement_attempts(
+        self, amongo: AsyncIOMotorClient, *, _id: ObjectId, increment: int = 1
+    ) -> schemas.TaskMongoObject:
+        """Async increment attempts for a task"""
+        existed_obj = await self.afirst_by_id(amongo, _id=_id)
+        if existed_obj is None:
+            raise keble_exceptions.ServerSideInvalidParams(
+                admin_note={"task_id": _id},
+                alert_admin=True,
+                but_got="db_obj is None",
+                expected="db_obj is not None",
+                invalid_params="task_id",
+            )
+        await self.aupdate(
+            amongo, _id=_id, obj_in={"attempts": existed_obj.attempts + increment}
+        )
+        db_obj = await self.afirst_by_id(amongo, _id=_id)
+        assert db_obj is not None
+        return db_obj
+
+
+class CRUDTaskRelation(MongoCRUDBase[schemas.TaskRelationMongoObject]):
+    """Mongo CRUD helper for task-relation rows.
+
+    Step by step:
+    1. keep relation storage separate from the task tree collection;
+    2. expose index creation for workspace and edge lookup patterns;
+    3. let `TaskClient` own relation validation before insertion.
+    """
+
+    async def aensure_relation_indexes(self, amongo: AsyncIOMotorClient) -> None:
+        """Create indexes required by root-scoped task-relation queries.
+
+        Step by step:
+        1. index each endpoint for diagnostics and filtered lookups;
+        2. index root/to/type for child-derived lineage queries;
+        3. make the full edge unique so exact duplicate relation rows cannot drift.
+        """
+
+        collection = amongo[self.database][self.collection]
+        await collection.create_index([("root_task", 1)], name="root_task_1")
+        await collection.create_index([("from_task_id", 1)], name="from_task_id_1")
+        await collection.create_index([("to_task_id", 1)], name="to_task_id_1")
+        await collection.create_index(
+            [("root_task", 1), ("to_task_id", 1), ("relation_type", 1)],
+            name="root_task_1_to_task_id_1_relation_type_1",
+        )
+        await collection.create_index(
+            [
+                ("root_task", 1),
+                ("from_task_id", 1),
+                ("to_task_id", 1),
+                ("relation_type", 1),
+            ],
+            name="root_from_to_relation_type_unique",
+            unique=True,
+        )
+
+    async def acreate_relation(
+        self,
+        amongo: AsyncIOMotorClient,
+        *,
+        obj_in: schemas.TaskRelationCreate,
+    ) -> InsertOneResult:
+        """Insert one validated relation create payload into relation storage.
+
+        Step by step:
+        1. accept the create schema before Mongo has assigned a durable `_id`;
+        2. serialize the payload exactly like the generic CRUD insert path;
+        3. return Mongo's insert result so callers can reload the persisted object.
+        """
+
+        return await amongo[self.database][self.collection].insert_one(
+            obj_in.model_dump()
+        )
+
+
+class CRUDTaskCost(MongoCRUDBase[schemas.TaskCostMongoObject]):
+    """Mongo CRUD helper for task-cost rows.
+
+    Step by step:
+    1. keep cost storage separate from task state and relation edges;
+    2. expose indexed list/count query shapes for admin reports;
+    3. centralize index creation so APIs and workers do not create indexes inline.
+    """
+
+    async def aensure_cost_indexes(self, amongo: AsyncIOMotorClient) -> None:
+        """Create indexes required by task-cost list and aggregate reads.
+
+        Step by step:
+        1. index direct task and root-task time windows;
+        2. index owner and owner/task-type reporting windows;
+        3. index tags and occurrence-time scans used by admin aggregation.
+        """
+
+        collection = amongo[self.database][self.collection]
+        await collection.create_indexes(
+            [
+                IndexModel(
+                    [("task_id", ASCENDING), ("occurred_at", DESCENDING)],
+                    name="task_id_occurred_at_desc_idx",
+                ),
+                IndexModel(
+                    [("root_task", ASCENDING), ("occurred_at", DESCENDING)],
+                    name="root_task_occurred_at_desc_idx",
+                ),
+                IndexModel(
+                    [("owner", ASCENDING), ("occurred_at", DESCENDING)],
+                    name="owner_occurred_at_desc_idx",
+                ),
+                IndexModel(
+                    [
+                        ("owner", ASCENDING),
+                        ("task_type", ASCENDING),
+                        ("occurred_at", DESCENDING),
+                    ],
+                    name="owner_task_type_occurred_at_desc_idx",
+                ),
+                IndexModel(
+                    [("tags", ASCENDING), ("occurred_at", DESCENDING)],
+                    name="tags_occurred_at_desc_idx",
+                ),
+                IndexModel(
+                    [("source", ASCENDING), ("occurred_at", DESCENDING)],
+                    name="source_occurred_at_desc_idx",
+                ),
+                IndexModel(
+                    [("occurred_at", DESCENDING)],
+                    name="occurred_at_desc_idx",
+                ),
+            ]
+        )
+
+    def build_cost_filters(
+        self,
+        *,
+        query: schemas.TaskCostFilterBase,
+    ) -> dict[str, object]:
+        """Build the indexed Mongo filter from the canonical cost filter.
+
+        Step by step:
+        1. accept the shared filter base used by list and aggregate reads;
+        2. delegate field mapping to the schema that owns the filter contract;
+        3. keep CRUD methods focused on storage access and stable sorting.
+        """
+
+        return query.to_mongo_filters()
+
+    async def acreate_cost(
+        self,
+        amongo: AsyncIOMotorClient,
+        *,
+        obj_in: schemas.TaskCostCreate,
+    ) -> InsertOneResult:
+        """Insert one validated task-cost row.
+
+        Step by step:
+        1. accept the denormalized create schema produced by `TaskClient`;
+        2. serialize Pydantic dataclasses and nested money values to Mongo-safe dicts;
+        3. return Mongo's insert result so callers can reload the typed row.
+        """
+
+        return await amongo[self.database][self.collection].insert_one(
+            obj_in.model_dump()
+        )
+
+    async def alist_costs(
+        self,
+        amongo: AsyncIOMotorClient,
+        *,
+        query: schemas.TaskCostListRequest,
+    ) -> list[schemas.TaskCostMongoObject]:
+        """List task-cost rows with indexed filters and stable newest-first order.
+
+        Step by step:
+        1. build the shared indexed filter from the request schema;
+        2. sort by `occurred_at` descending and `_id` descending for stable pages;
+        3. parse Mongo documents into `TaskCostMongoObject`.
+        """
+
+        return await self.aget_multi(
+            amongo,
+            query=QueryBase(
+                filters=self.build_cost_filters(query=query),
+                order_by=[("occurred_at", DESCENDING), ("_id", DESCENDING)],
+                offset=query.skip,
+                limit=query.limit,
+            ),
+        )
+
+    async def acount_costs(
+        self,
+        amongo: AsyncIOMotorClient,
+        *,
+        query: schemas.TaskCostFilterBase,
+    ) -> int:
+        """Count task-cost rows for a shared indexed filter."""
+
+        return await self.acount(
+            amongo,
+            query=QueryBase(filters=self.build_cost_filters(query=query)),
+        )
+
+    async def alist_costs_for_aggregate(
+        self,
+        amongo: AsyncIOMotorClient,
+        *,
+        query: schemas.TaskCostAggregateRequest,
+    ) -> list[schemas.TaskCostMongoObject]:
+        """Load filtered task-cost rows for package-owned aggregation.
+
+        Step by step:
+        1. use the same indexed filter as list/count reads;
+        2. sort ascending by occurrence so response buckets are deterministic;
+        3. leave currency conversion and sub-cent math to schema methods.
+        """
+
+        return await self.aget_multi(
+            amongo,
+            query=QueryBase(
+                filters=self.build_cost_filters(query=query),
+                order_by=[("occurred_at", ASCENDING), ("_id", ASCENDING)],
+            ),
+        )

keble_task/exceptions.py

@@ -0,0 +1,62 @@
+import json
+import traceback
+from enum import Enum
+from typing import Optional
+
+from keble_exceptions import KebleException
+
+
+class TaskExceptionType(str, Enum):
+    UNKNOWN = "UNKNOWN"
+    FAILED_TO_START = "FAILED_TO_START"
+    NO_SUFFICIENT_DATA = "NO_SUFFICIENT_DATA"
+    TIMEOUT = "TIMEOUT"
+
+
+class TaskException(KebleException):
+    def __init__(
+        self,
+        *,
+        exception_type: TaskExceptionType = TaskExceptionType.UNKNOWN,
+        # More information regarding the exception
+        error: Optional[str] = None,
+    ):
+        self.exception_type = exception_type
+        self.error = error
+        super().__init__(
+            admin_note=json.dumps(
+                {
+                    "exception_type": str(exception_type),
+                    "traceback": str(traceback.format_exc()),
+                    "error": error,
+                }
+            ),
+            alert_admin=True,
+            function_identifier="TaskException.__init__",
+        )
+
+    def __str__(self):
+        return self.exception_type.value
+
+
+class TaskNoSufficientDataException(TaskException):
+    def __init__(self, data_type: str):
+        super().__init__(
+            exception_type=TaskExceptionType.NO_SUFFICIENT_DATA,
+            error=f"No enough: {data_type}",
+        )
+
+
+class TaskFailedToStartException(TaskException):
+    def __init__(self, error: str):
+        super().__init__(exception_type=TaskExceptionType.FAILED_TO_START, error=error)
+
+
+class TaskTimeoutException(TaskException):
+    def __init__(self, error: str):
+        super().__init__(exception_type=TaskExceptionType.TIMEOUT, error=error)
+
+
+class TaskUnknownException(TaskException):
+    def __init__(self, error: str):
+        super().__init__(exception_type=TaskExceptionType.UNKNOWN, error=error)