gumloop 0.5.2__tar.gz → 0.5.4__tar.gz

{gumloop-0.5.2 → gumloop-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gumloop
-Version: 0.5.2
+Version: 0.5.4
 Summary: Python client for the Gumloop API
 Project-URL: Homepage, https://github.com/gumloop/gumloop-py
 Project-URL: Bug Tracker, https://github.com/gumloop/gumloop-py/issues

{gumloop-0.5.2 → gumloop-0.5.4}/src/gumloop/_client.py

@@ -20,6 +20,7 @@ from gumloop.resources import AsyncArtifacts
 from gumloop.resources import AsyncBrain
 from gumloop.resources import AsyncBrowserProfiles
 from gumloop.resources import AsyncChat
+from gumloop.resources import AsyncDecisions
 from gumloop.resources import AsyncEvaluations
 from gumloop.resources import AsyncMCP
 from gumloop.resources import AsyncModels
@@ -30,6 +31,7 @@ from gumloop.resources import AsyncTeams
 from gumloop.resources import Brain
 from gumloop.resources import BrowserProfiles
 from gumloop.resources import Chat
+from gumloop.resources import Decisions
 from gumloop.resources import Evaluations
 from gumloop.resources import Models
 from gumloop.resources import Organizations
@@ -79,7 +81,9 @@ class Gumloop:
         self.team_id = team_id or os.environ.get("GUMLOOP_TEAM_ID")
         # Defaults to production; GUMLOOP_BASE_URL is an optional override.
         self.base_url = (base_url or os.environ.get("GUMLOOP_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
-        self.stream_base_url = (stream_base_url or _derive_stream_base_url(self.base_url)).rstrip("/")
+        self.stream_base_url = (
+            stream_base_url or os.environ.get("GUMLOOP_STREAM_BASE_URL") or _derive_stream_base_url(self.base_url)
+        ).rstrip("/")
         self.timeout = timeout
         self.stream_timeout = stream_timeout
 
@@ -96,6 +100,7 @@ class Gumloop:
         self.agents = Agents(self._http)
         self.sessions = Sessions(self._http)
         self.chat = Chat(self._http)
+        self.decisions = Decisions(self._http)
         self.models = Models(self._http)
         self.mcp = MCP(self._http)
         self.teams = Teams(self._http)
@@ -141,7 +146,9 @@ class AsyncGumloop:
         self.team_id = team_id or os.environ.get("GUMLOOP_TEAM_ID")
         # Defaults to production; GUMLOOP_BASE_URL is an optional override.
         self.base_url = (base_url or os.environ.get("GUMLOOP_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
-        self.stream_base_url = (stream_base_url or _derive_stream_base_url(self.base_url)).rstrip("/")
+        self.stream_base_url = (
+            stream_base_url or os.environ.get("GUMLOOP_STREAM_BASE_URL") or _derive_stream_base_url(self.base_url)
+        ).rstrip("/")
         self.timeout = timeout
         self.stream_timeout = stream_timeout
 
@@ -158,6 +165,7 @@ class AsyncGumloop:
         self.agents = AsyncAgents(self._http)
         self.sessions = AsyncSessions(self._http)
         self.chat = AsyncChat(self._http)
+        self.decisions = AsyncDecisions(self._http)
         self.models = AsyncModels(self._http)
         self.mcp = AsyncMCP(self._http)
         self.teams = AsyncTeams(self._http)

{gumloop-0.5.2 → gumloop-0.5.4}/src/gumloop/_version.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-__version__ = "0.5.2"
+__version__ = "0.5.4"

{gumloop-0.5.2 → gumloop-0.5.4}/src/gumloop/resources/__init__.py

@@ -12,6 +12,8 @@ from gumloop.resources.browser_profiles import AsyncBrowserProfiles
 from gumloop.resources.browser_profiles import BrowserProfiles
 from gumloop.resources.chat import AsyncChat
 from gumloop.resources.chat import Chat
+from gumloop.resources.decisions import AsyncDecisions
+from gumloop.resources.decisions import Decisions
 from gumloop.resources.evaluations import AsyncEvaluations
 from gumloop.resources.evaluations import Evaluations
 from gumloop.resources.mcp import MCP
@@ -35,6 +37,7 @@ __all__ = [
     "AsyncBrain",
     "AsyncBrowserProfiles",
     "AsyncChat",
+    "AsyncDecisions",
     "AsyncEvaluations",
     "AsyncMCP",
     "AsyncModels",
@@ -45,6 +48,7 @@ __all__ = [
     "Brain",
     "BrowserProfiles",
     "Chat",
+    "Decisions",
     "Evaluations",
     "Models",
     "Organizations",

{gumloop-0.5.2 → gumloop-0.5.4}/src/gumloop/resources/agents.py

@@ -7,15 +7,29 @@ from typing import Any
 
 from gumloop._http import AsyncHttpClient
 from gumloop._http import HttpClient
+from gumloop.types import AgentAbilitiesResponse
+from gumloop.types import AgentAbilitiesUpdateRequest
+from gumloop.types import AgentAppRulesResponse
 from gumloop.types import AgentCreateRequest
+from gumloop.types import AgentDeleteResponse
 from gumloop.types import AgentEvaluationMetricsResponse
 from gumloop.types import AgentEvaluationOptionsResponse
+from gumloop.types import AgentKnowledgeSourceDetachResponse
+from gumloop.types import AgentKnowledgeSourceResponse
+from gumloop.types import AgentKnowledgeSourcesResponse
 from gumloop.types import AgentListResponse
 from gumloop.types import AgentMcpServerDetachResponse
 from gumloop.types import AgentMcpServerResponse
 from gumloop.types import AgentMcpServersResponse
 from gumloop.types import AgentResponse
 from gumloop.types import AgentSkillsResponse
+from gumloop.types import AgentSubagentsResponse
+from gumloop.types import AgentTriggerCreateRequest
+from gumloop.types import AgentTriggerDeleteResponse
+from gumloop.types import AgentTriggerResponse
+from gumloop.types import AgentTriggersResponse
+from gumloop.types import AgentTriggerUpdateRequest
+from gumloop.types import AgentTriggerWebhookUrlResponse
 from gumloop.types import AgentUpdateRequest
 from gumloop.types import AgentVersionResponse
 from gumloop.types import AgentVersionsResponse
@@ -25,6 +39,7 @@ from gumloop.types import EvaluationResultListResponse
 from gumloop.types import EvaluationResultResponse
 from gumloop.types import EvaluationRunRequest
 from gumloop.types import EvaluationRunResponse
+from gumloop.types import KnowledgeSourceScope
 from gumloop.types import ModelListResponse
 from gumloop.types import ModelRouteRequest
 from gumloop.types import ModelRouteResponse
@@ -35,6 +50,14 @@ def _skill_id_list(skill_ids: str | Sequence[str]) -> list[str]:
     return [skill_ids] if isinstance(skill_ids, str) else list(skill_ids)
 
 
+def _knowledge_scope_body(config: KnowledgeSourceScope | Mapping[str, Any] | None) -> dict[str, Any]:
+    # The key is always sent: null means the whole source.
+    if config is None:
+        return {"config": None}
+    scope = config if isinstance(config, KnowledgeSourceScope) else KnowledgeSourceScope.model_validate(config)
+    return {"config": scope.model_dump(exclude_unset=True)}
+
+
 class Agents:
     def __init__(self, client: HttpClient) -> None:
         self._client = client
@@ -99,9 +122,11 @@ class Agents:
         request: AgentUpdateRequest | Mapping[str, Any] | None = None,
         **kwargs: Any,
     ) -> AgentResponse:
-        """``tools`` replaces the entire list when provided (legacy bulk path); prefer
-        attach_mcp_server/detach_mcp_server for individual MCP servers and
-        attach_skills/detach_skills for skills."""
+        """Settings live under ``metadata`` and merge section by section. Pass ``version``
+        from a previous read to refuse the update if the agent changed since
+        (``agent_version_conflict``). ``tools`` replaces the whole list when provided;
+        prefer update_abilities, attach_mcp_server/detach_mcp_server and
+        attach_skills/detach_skills."""
         return AgentResponse.model_validate(
             self._client.patch(f"agents/{agent_id}", json=AgentUpdateRequest.build(request, **kwargs))
         )
@@ -139,6 +164,111 @@ class Agents:
     def list_mcp_servers(self, agent_id: str) -> AgentMcpServersResponse:
         return AgentMcpServersResponse.model_validate(self._client.get(f"agents/{agent_id}/mcp-servers"))
 
+    def delete(self, agent_id: str) -> AgentDeleteResponse:
+        """Delete a custom agent. Platform agents (``gumball``, ``analytics``) are refused."""
+        return AgentDeleteResponse.model_validate(self._client.delete(f"agents/{agent_id}"))
+
+    def update_abilities(
+        self,
+        agent_id: str,
+        request: AgentAbilitiesUpdateRequest | Mapping[str, Any] | None = None,
+        **abilities: Any,
+    ) -> AgentAbilitiesResponse:
+        """Turn native abilities on or off and set their options, e.g.
+        ``update_abilities(agent_id, web_search={"enabled": True, "provider": "exa"},
+        ask_question={"enabled": False})``. Only the abilities you send change."""
+        return AgentAbilitiesResponse.model_validate(
+            self._client.patch(
+                f"agents/{agent_id}/abilities",
+                json=AgentAbilitiesUpdateRequest.build(request, **abilities),
+            )
+        )
+
+    def list_knowledge_sources(self, agent_id: str) -> AgentKnowledgeSourcesResponse:
+        return AgentKnowledgeSourcesResponse.model_validate(self._client.get(f"agents/{agent_id}/knowledge-sources"))
+
+    def attach_knowledge_source(
+        self,
+        agent_id: str,
+        connector_id: str,
+        *,
+        config: KnowledgeSourceScope | Mapping[str, Any] | None = None,
+    ) -> AgentKnowledgeSourceResponse:
+        """Attach a Brain source, or change its scope if already attached (idempotent upsert).
+        ``config=None`` attaches the whole source."""
+        return AgentKnowledgeSourceResponse.model_validate(
+            self._client.put(
+                f"agents/{agent_id}/knowledge-sources/{connector_id}",
+                json=_knowledge_scope_body(config),
+            )
+        )
+
+    def detach_knowledge_source(self, agent_id: str, connector_id: str) -> AgentKnowledgeSourceDetachResponse:
+        """Detach a Brain source. Idempotent: safe to retry."""
+        return AgentKnowledgeSourceDetachResponse.model_validate(
+            self._client.delete(f"agents/{agent_id}/knowledge-sources/{connector_id}")
+        )
+
+    def attach_subagent(self, agent_id: str, subagent_id: str) -> AgentSubagentsResponse:
+        """Allow the agent to delegate to ``subagent_id``. Idempotent; the subagent must live in the same workspace."""
+        return AgentSubagentsResponse.model_validate(self._client.put(f"agents/{agent_id}/subagents/{subagent_id}"))
+
+    def detach_subagent(self, agent_id: str, subagent_id: str) -> AgentSubagentsResponse:
+        return AgentSubagentsResponse.model_validate(self._client.delete(f"agents/{agent_id}/subagents/{subagent_id}"))
+
+    def list_triggers(
+        self,
+        agent_id: str,
+        *,
+        page_size: int | None = None,
+        cursor: str | None = None,
+    ) -> AgentTriggersResponse:
+        return AgentTriggersResponse.model_validate(
+            self._client.get(f"agents/{agent_id}/triggers", params={"page_size": page_size, "cursor": cursor})
+        )
+
+    def create_trigger(
+        self,
+        agent_id: str,
+        request: AgentTriggerCreateRequest | Mapping[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> AgentTriggerResponse:
+        """Create a ``schedule`` (``cron_expression`` or ``run_at``) or ``webhook`` trigger.
+        A webhook's URL is returned here and from ``get_trigger_webhook_url``, never in lists."""
+        return AgentTriggerResponse.model_validate(
+            self._client.post(f"agents/{agent_id}/triggers", json=AgentTriggerCreateRequest.build(request, **kwargs))
+        )
+
+    def update_trigger(
+        self,
+        agent_id: str,
+        trigger_id: str,
+        request: AgentTriggerUpdateRequest | Mapping[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> AgentTriggerResponse:
+        """Edit, enable or disable a schedule or webhook trigger. Only the fields you send change."""
+        return AgentTriggerResponse.model_validate(
+            self._client.patch(
+                f"agents/{agent_id}/triggers/{trigger_id}",
+                json=AgentTriggerUpdateRequest.build(request, **kwargs),
+            )
+        )
+
+    def delete_trigger(self, agent_id: str, trigger_id: str) -> AgentTriggerDeleteResponse:
+        return AgentTriggerDeleteResponse.model_validate(
+            self._client.delete(f"agents/{agent_id}/triggers/{trigger_id}")
+        )
+
+    def get_trigger_webhook_url(self, agent_id: str, trigger_id: str) -> AgentTriggerWebhookUrlResponse:
+        """The webhook URL embeds its secret; fetch it on demand rather than storing it."""
+        return AgentTriggerWebhookUrlResponse.model_validate(
+            self._client.get(f"agents/{agent_id}/triggers/{trigger_id}/webhook-url")
+        )
+
+    def list_app_rules(self, agent_id: str) -> AgentAppRulesResponse:
+        """Rules the agent has authored for its connectors. Read only."""
+        return AgentAppRulesResponse.model_validate(self._client.get(f"agents/{agent_id}/app-rules"))
+
     def get_evaluation_options(self) -> AgentEvaluationOptionsResponse:
         return AgentEvaluationOptionsResponse.model_validate(self._client.get("agents/evaluation-options"))
 
@@ -295,9 +425,11 @@ class AsyncAgents:
         request: AgentUpdateRequest | Mapping[str, Any] | None = None,
         **kwargs: Any,
     ) -> AgentResponse:
-        """``tools`` replaces the entire list when provided (legacy bulk path); prefer
-        attach_mcp_server/detach_mcp_server for individual MCP servers and
-        attach_skills/detach_skills for skills."""
+        """Settings live under ``metadata`` and merge section by section. Pass ``version``
+        from a previous read to refuse the update if the agent changed since
+        (``agent_version_conflict``). ``tools`` replaces the whole list when provided;
+        prefer update_abilities, attach_mcp_server/detach_mcp_server and
+        attach_skills/detach_skills."""
         data = await self._client.patch(f"agents/{agent_id}", json=AgentUpdateRequest.build(request, **kwargs))
         return AgentResponse.model_validate(data)
 
@@ -332,6 +464,99 @@ class AsyncAgents:
         data = await self._client.get(f"agents/{agent_id}/mcp-servers")
         return AgentMcpServersResponse.model_validate(data)
 
+    async def delete(self, agent_id: str) -> AgentDeleteResponse:
+        """Delete a custom agent. Platform agents (``gumball``, ``analytics``) are refused."""
+        return AgentDeleteResponse.model_validate(await self._client.delete(f"agents/{agent_id}"))
+
+    async def update_abilities(
+        self,
+        agent_id: str,
+        request: AgentAbilitiesUpdateRequest | Mapping[str, Any] | None = None,
+        **abilities: Any,
+    ) -> AgentAbilitiesResponse:
+        """Turn native abilities on or off and set their options. Only the abilities you send change."""
+        data = await self._client.patch(
+            f"agents/{agent_id}/abilities", json=AgentAbilitiesUpdateRequest.build(request, **abilities)
+        )
+        return AgentAbilitiesResponse.model_validate(data)
+
+    async def list_knowledge_sources(self, agent_id: str) -> AgentKnowledgeSourcesResponse:
+        data = await self._client.get(f"agents/{agent_id}/knowledge-sources")
+        return AgentKnowledgeSourcesResponse.model_validate(data)
+
+    async def attach_knowledge_source(
+        self,
+        agent_id: str,
+        connector_id: str,
+        *,
+        config: KnowledgeSourceScope | Mapping[str, Any] | None = None,
+    ) -> AgentKnowledgeSourceResponse:
+        """Attach a Brain source, or change its scope if already attached (idempotent upsert).
+        ``config=None`` attaches the whole source."""
+        data = await self._client.put(
+            f"agents/{agent_id}/knowledge-sources/{connector_id}", json=_knowledge_scope_body(config)
+        )
+        return AgentKnowledgeSourceResponse.model_validate(data)
+
+    async def detach_knowledge_source(self, agent_id: str, connector_id: str) -> AgentKnowledgeSourceDetachResponse:
+        data = await self._client.delete(f"agents/{agent_id}/knowledge-sources/{connector_id}")
+        return AgentKnowledgeSourceDetachResponse.model_validate(data)
+
+    async def attach_subagent(self, agent_id: str, subagent_id: str) -> AgentSubagentsResponse:
+        data = await self._client.put(f"agents/{agent_id}/subagents/{subagent_id}")
+        return AgentSubagentsResponse.model_validate(data)
+
+    async def detach_subagent(self, agent_id: str, subagent_id: str) -> AgentSubagentsResponse:
+        data = await self._client.delete(f"agents/{agent_id}/subagents/{subagent_id}")
+        return AgentSubagentsResponse.model_validate(data)
+
+    async def list_triggers(
+        self,
+        agent_id: str,
+        *,
+        page_size: int | None = None,
+        cursor: str | None = None,
+    ) -> AgentTriggersResponse:
+        data = await self._client.get(f"agents/{agent_id}/triggers", params={"page_size": page_size, "cursor": cursor})
+        return AgentTriggersResponse.model_validate(data)
+
+    async def create_trigger(
+        self,
+        agent_id: str,
+        request: AgentTriggerCreateRequest | Mapping[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> AgentTriggerResponse:
+        """Create a ``schedule`` (``cron_expression`` or ``run_at``) or ``webhook`` trigger.
+        A webhook's URL is returned here and from ``get_trigger_webhook_url``, never in lists."""
+        data = await self._client.post(
+            f"agents/{agent_id}/triggers", json=AgentTriggerCreateRequest.build(request, **kwargs)
+        )
+        return AgentTriggerResponse.model_validate(data)
+
+    async def update_trigger(
+        self,
+        agent_id: str,
+        trigger_id: str,
+        request: AgentTriggerUpdateRequest | Mapping[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> AgentTriggerResponse:
+        data = await self._client.patch(
+            f"agents/{agent_id}/triggers/{trigger_id}", json=AgentTriggerUpdateRequest.build(request, **kwargs)
+        )
+        return AgentTriggerResponse.model_validate(data)
+
+    async def delete_trigger(self, agent_id: str, trigger_id: str) -> AgentTriggerDeleteResponse:
+        data = await self._client.delete(f"agents/{agent_id}/triggers/{trigger_id}")
+        return AgentTriggerDeleteResponse.model_validate(data)
+
+    async def get_trigger_webhook_url(self, agent_id: str, trigger_id: str) -> AgentTriggerWebhookUrlResponse:
+        data = await self._client.get(f"agents/{agent_id}/triggers/{trigger_id}/webhook-url")
+        return AgentTriggerWebhookUrlResponse.model_validate(data)
+
+    async def list_app_rules(self, agent_id: str) -> AgentAppRulesResponse:
+        data = await self._client.get(f"agents/{agent_id}/app-rules")
+        return AgentAppRulesResponse.model_validate(data)
+
     async def get_evaluation_options(self) -> AgentEvaluationOptionsResponse:
         data = await self._client.get("agents/evaluation-options")
         return AgentEvaluationOptionsResponse.model_validate(data)

gumloop-0.5.4/src/gumloop/resources/decisions.py

@@ -0,0 +1,72 @@
+"""Decisions resource — OpenRouter request shape."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from pydantic import ValidationError
+
+from gumloop._http import AsyncHttpClient
+from gumloop._http import HttpClient
+from gumloop.errors import GumloopError
+from gumloop.spec import DecisionsQuestion
+from gumloop.spec import DecisionsRequest
+from gumloop.spec import DecisionsResponse
+from gumloop.spec._compat import to_wire_dict
+from gumloop.spec._decisions import Json
+
+_PATH = "decisions"
+
+
+def _build_request(
+    request: DecisionsRequest | Mapping[str, Any] | None,
+    kwargs: dict[str, Any],
+) -> DecisionsRequest:
+    if isinstance(request, DecisionsRequest):
+        base = to_wire_dict(request)
+    elif request is None:
+        base = {}
+    else:
+        base = dict(request)
+    base.update({k: v for k, v in kwargs.items() if v is not None})
+    try:
+        return DecisionsRequest.model_validate(base)
+    except ValidationError as exc:
+        raise GumloopError(f"invalid decisions request: {exc}") from exc
+
+
+class Decisions:
+    def __init__(self, client: HttpClient) -> None:
+        self._client = client
+
+    def create(
+        self,
+        request: DecisionsRequest | Mapping[str, Any] | None = None,
+        *,
+        model: str | None = None,
+        state: Json | None = None,
+        questions: Mapping[str, DecisionsQuestion | Mapping[str, Any]] | None = None,
+        **kwargs: Any,
+    ) -> DecisionsResponse:
+        body = _build_request(request, {"model": model, "state": state, "questions": questions, **kwargs})
+        data = self._client.post(_PATH, json=to_wire_dict(body))
+        return DecisionsResponse.model_validate(data)
+
+
+class AsyncDecisions:
+    def __init__(self, client: AsyncHttpClient) -> None:
+        self._client = client
+
+    async def create(
+        self,
+        request: DecisionsRequest | Mapping[str, Any] | None = None,
+        *,
+        model: str | None = None,
+        state: Json | None = None,
+        questions: Mapping[str, DecisionsQuestion | Mapping[str, Any]] | None = None,
+        **kwargs: Any,
+    ) -> DecisionsResponse:
+        body = _build_request(request, {"model": model, "state": state, "questions": questions, **kwargs})
+        data = await self._client.post(_PATH, json=to_wire_dict(body))
+        return DecisionsResponse.model_validate(data)

{gumloop-0.5.2 → gumloop-0.5.4}/src/gumloop/spec/__init__.py

@@ -17,6 +17,20 @@ from openrouter.components import ProviderPreferences
 from openrouter.components import ResponseHealingPlugin
 from openrouter.components import WebSearchPlugin
 
+from gumloop.spec._decisions import DecisionsAnswer
+from gumloop.spec._decisions import DecisionsChoiceAnswer
+from gumloop.spec._decisions import DecisionsChoiceQuestion
+from gumloop.spec._decisions import DecisionsNoulAnswer
+from gumloop.spec._decisions import DecisionsNoulQuestion
+from gumloop.spec._decisions import DecisionsNoulQuestionCriteria
+from gumloop.spec._decisions import DecisionsQuestion
+from gumloop.spec._decisions import DecisionsRequest
+from gumloop.spec._decisions import DecisionsResponse
+from gumloop.spec._decisions import DecisionsResponseUsage
+from gumloop.spec._decisions import DecisionsScoreAnswer
+from gumloop.spec._decisions import DecisionsScoreQuestion
+from gumloop.spec._decisions import TraceConfig
+
 # ChatStreamDelta/ChatStreamChoice/ChatStreamChunk/ChatUsage subclassed to add
 # fields Speakeasy 0.9.1 drops + Gumloop-only `gumloop_extensions` bucket.
 from gumloop.spec._extensions import ChatStreamChunk
@@ -36,9 +50,22 @@ __all__ = [
     "ChatStreamDelta",
     "ChatToolChoice",
     "ChatUsage",
+    "DecisionsAnswer",
+    "DecisionsChoiceAnswer",
+    "DecisionsChoiceQuestion",
+    "DecisionsNoulAnswer",
+    "DecisionsNoulQuestion",
+    "DecisionsNoulQuestionCriteria",
+    "DecisionsQuestion",
+    "DecisionsRequest",
+    "DecisionsResponse",
+    "DecisionsResponseUsage",
+    "DecisionsScoreAnswer",
+    "DecisionsScoreQuestion",
     "FormatJSONObjectConfig",
     "ImageConfig",
     "ProviderPreferences",
     "ResponseHealingPlugin",
+    "TraceConfig",
     "WebSearchPlugin",
 ]

gumloop-0.5.4/src/gumloop/spec/_decisions.py

@@ -0,0 +1,101 @@
+"""OpenRouter Decisions models, named as in ``openrouter.components`` 1.3.14;
+the pinned ``openrouter`` predates them."""
+
+from __future__ import annotations
+
+from typing import Annotated
+from typing import Any
+from typing import Literal
+
+from openrouter.components import ProviderPreferences
+from pydantic import BaseModel
+from pydantic import Field
+
+Json = str | dict[str, Any] | list[Any]
+
+
+class DecisionsNoulQuestionCriteria(BaseModel):
+    true: Json | None = None
+    false: Json | None = None
+
+
+class DecisionsNoulQuestion(BaseModel):
+    type: Literal["noul"]
+    instructions: Json
+    criteria: DecisionsNoulQuestionCriteria | None = None
+
+
+class DecisionsChoiceQuestion(BaseModel):
+    type: Literal["choice"]
+    instructions: Json
+    criteria: dict[str, Json | None]
+
+
+class DecisionsScoreQuestion(BaseModel):
+    type: Literal["score"]
+    instructions: Json
+    criteria: list[Json]
+
+
+DecisionsQuestion = Annotated[
+    DecisionsNoulQuestion | DecisionsChoiceQuestion | DecisionsScoreQuestion,
+    Field(discriminator="type"),
+]
+
+
+class TraceConfig(BaseModel):
+    trace_id: str | None = None
+    trace_name: str | None = None
+    span_name: str | None = None
+    generation_name: str | None = None
+    parent_span_id: str | None = None
+
+
+class DecisionsRequest(BaseModel):
+    model: str
+    state: Json
+    questions: dict[str, DecisionsQuestion]
+    provider: ProviderPreferences | None = None
+    session_id: str | None = Field(default=None, max_length=256)
+    trace: TraceConfig | None = None
+    user: str | None = None
+
+
+class DecisionsNoulAnswer(BaseModel):
+    type: Literal["noul"]
+    noul: float
+
+
+class DecisionsChoiceAnswer(BaseModel):
+    type: Literal["choice"]
+    choice: str
+    confidence: float | None = None
+    probabilities: dict[str, float] | None = None
+
+
+class DecisionsScoreAnswer(BaseModel):
+    type: Literal["score"]
+    score: float
+    confidence: float | None = None
+    legend: dict[str, Json] | None = None
+    probabilities: dict[str, float] | None = None
+
+
+DecisionsAnswer = Annotated[
+    DecisionsNoulAnswer | DecisionsChoiceAnswer | DecisionsScoreAnswer,
+    Field(discriminator="type"),
+]
+
+
+class DecisionsResponseUsage(BaseModel):
+    input_tokens: int
+    output_tokens: int
+    cost: float | None = None
+
+
+class DecisionsResponse(BaseModel):
+    answers: dict[str, DecisionsAnswer]
+    model: str
+    usage: DecisionsResponseUsage
+    id: str | None = None
+    provider: str | None = None