gumloop 0.5.2__tar.gz → 0.5.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gumloop
-Version: 0.5.2
+Version: 0.5.3
 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.3}/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.3}/src/gumloop/_version.py

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

{gumloop-0.5.2 → gumloop-0.5.3}/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.3/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.3}/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.3/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

gumloop-0.5.3/tests/sdk/test_decisions.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import asyncio
+
+import httpx
+import respx
+
+from gumloop import AsyncGumloop
+from gumloop import Gumloop
+from gumloop.spec import DecisionsChoiceAnswer
+from gumloop.spec import DecisionsNoulAnswer
+from gumloop.spec import DecisionsRequest
+from tests.sdk.helpers import API_BASE
+from tests.sdk.helpers import request_json
+
+RESPONSE = {
+    "id": "dec-1",
+    "model": "typesafe/jev-1.13",
+    "answers": {
+        "is_bug": {"type": "noul", "noul": 0.91},
+        "segment": {"type": "choice", "choice": "enterprise", "probabilities": {"enterprise": 0.8, "smb": 0.2}},
+    },
+    "usage": {"input_tokens": 120, "output_tokens": 0, "cost": 0.0001},
+}
+
+QUESTIONS = {
+    "is_bug": {"type": "noul", "instructions": "Is this a software defect?"},
+    "segment": {"type": "choice", "instructions": "Which segment?", "criteria": {"enterprise": None, "smb": None}},
+}
+
+
+@respx.mock
+def test_decisions_create_returns_typed_answers(client: Gumloop) -> None:
+    route = respx.post(f"{API_BASE}/decisions").mock(return_value=httpx.Response(200, json=RESPONSE))
+
+    result = client.decisions.create(model="typesafe/jev-1.13", state={"ticket": "blank screen"}, questions=QUESTIONS)
+
+    is_bug, segment = result.answers["is_bug"], result.answers["segment"]
+    assert isinstance(is_bug, DecisionsNoulAnswer) and is_bug.noul == 0.91
+    assert isinstance(segment, DecisionsChoiceAnswer) and segment.choice == "enterprise"
+    assert result.usage.input_tokens == 120
+    body = request_json(route.calls[0].request)
+    assert body["model"] == "typesafe/jev-1.13"
+    assert body["state"] == {"ticket": "blank screen"}
+    assert body["questions"]["segment"]["criteria"] == {"enterprise": None, "smb": None}
+    assert "provider" not in body
+
+
+@respx.mock
+def test_decisions_accepts_request_instance(client: Gumloop) -> None:
+    route = respx.post(f"{API_BASE}/decisions").mock(return_value=httpx.Response(200, json=RESPONSE))
+    request = DecisionsRequest(model="typesafe/jev-1.13", state="x", questions=QUESTIONS)
+
+    client.decisions.create(request)
+
+    assert request_json(route.calls[0].request)["state"] == "x"
+
+
+@respx.mock
+def test_async_decisions_create(async_client: AsyncGumloop) -> None:
+    respx.post(f"{API_BASE}/decisions").mock(return_value=httpx.Response(200, json=RESPONSE))
+
+    result = asyncio.run(
+        async_client.decisions.create(model="typesafe/jev-1.13", state={"ticket": "x"}, questions=QUESTIONS)
+    )
+
+    assert result.model == "typesafe/jev-1.13"