qoder-agent-sdk 1.0.0__tar.gz → 1.0.2__tar.gz

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qoder-agent-sdk
-Version: 1.0.0
+Version: 1.0.2
 Summary: Python SDK for Qoder Agent
 Author: Qoder
 License: Copyright (c) 2026 Qoder

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "qoder-agent-sdk"
-version = "1.0.0"
+version = "1.0.2"
 description = "Python SDK for Qoder Agent"
 readme = "README.md"
 requires-python = ">=3.10"

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/src/qoder_agent_sdk/__init__.py

@@ -128,10 +128,16 @@ from .types import (
     McpToolAnnotations,
     McpToolInfo,
     Message,
+    ModelContextConfig,
+    ModelContextWindowEntry,
+    ModelEffortEntry,
     ModelInfo,
     ModelPolicyContext,
     ModelPolicyProvider,
     ModelPolicyResult,
+    ModelThinkingConfig,
+    ModelThinkingDisabled,
+    ModelThinkingEnabled,
     OAuthToken,
     OnElicitation,
     OnMcpOAuthRequired,
@@ -936,6 +942,12 @@ __all__ = [
     "ModelPolicyTimeoutError",
     # Model Policy
     "ModelInfo",
+    "ModelContextConfig",
+    "ModelContextWindowEntry",
+    "ModelEffortEntry",
+    "ModelThinkingConfig",
+    "ModelThinkingDisabled",
+    "ModelThinkingEnabled",
     "ModelPolicyContext",
     "ModelPolicyProvider",
     "ModelPolicyResult",

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/src/qoder_agent_sdk/_cli_version.py

@@ -1,3 +1,3 @@
 """Bundled runtime CLI version."""
 
-__cli_version__ = "1.0.0"
+__cli_version__ = "1.0.3"

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/src/qoder_agent_sdk/_internal/cloud_agent.py

@@ -34,7 +34,7 @@ from ..types import (
 from .auth_helpers import once_callback
 
 CLOUD_AGENT_API_BASE_ENV = "QODER_CLOUD_AGENT_API_BASE"
-DEFAULT_CLOUD_AGENT_API_BASE = "https://openapi.qoder.sh/api/v1/cloud"
+DEFAULT_CLOUD_AGENT_API_BASE = "https://api.qoder.com/api/v1/cloud"
 
 CLOUD_EVENT_AGENT_MESSAGE = "agent.message"
 CLOUD_EVENT_MODEL_REQUEST_END = "span.model_request_end"

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/src/qoder_agent_sdk/_internal/query.py

@@ -1290,7 +1290,8 @@ class Query:
 
         Sends a ``get_models`` control request and returns the ``models``
         array from the response. Each entry is a :class:`ModelInfo`-shaped
-        dict with at least ``value`` and ``isEnabled``.
+        dict, including rich catalog fields such as ``context_config`` and
+        ``thinking_config`` when the CLI provides them.
 
         Returns:
             A list of model info dicts, or an empty list when the CLI

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/src/qoder_agent_sdk/_version.py

@@ -1,3 +1,3 @@
 """Version information for qoder-agent-sdk."""
 
-__version__ = "1.0.0"
+__version__ = "1.0.2"

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/src/qoder_agent_sdk/client.py

@@ -317,7 +317,8 @@ class QoderSDKClient:
         """Query the CLI for the list of available models.
 
         Returns the current set of models the CLI exposes. Each entry is a
-        :class:`ModelInfo` dict with at least ``value`` and ``isEnabled``.
+        :class:`ModelInfo` dict, including rich catalog fields such as
+        ``context_config`` and ``thinking_config`` when the CLI provides them.
 
         Returns:
             A list of model info dicts, or an empty list when no models

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/src/qoder_agent_sdk/types.py

@@ -5,7 +5,7 @@ import sys
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any, Literal, TypeAlias
 
 from .auth import InternalAuthOptions
 
@@ -2022,16 +2022,57 @@ QoderModelPurpose = Literal[
 """LLM call purpose sent by the CLI in a get_model_policy request."""
 
 
-class ModelInfo(TypedDict, total=False):
+class ModelContextWindowEntry(TypedDict):
+    """Context-window entry returned in a model catalog response."""
+
+    token_count: int
+    is_default: NotRequired[bool]
+
+
+ModelContextConfig: TypeAlias = dict[str, ModelContextWindowEntry]
+"""Server-side ``context_config``, keyed by tier label such as ``200K``."""
+
+
+class ModelEffortEntry(TypedDict, total=False):
+    """Thinking-effort entry returned in a model catalog response."""
+
+    description: str
+    is_default: bool
+
+
+class ModelThinkingDisabled(TypedDict, total=False):
+    """Configuration shown when thinking is disabled for a model."""
+
+    description: str
+
+
+class ModelThinkingEnabled(TypedDict, total=False):
+    """Configuration shown when thinking is enabled for a model."""
+
+    description: str
+    efforts: dict[str, ModelEffortEntry]
+    is_default: bool
+
+
+class ModelThinkingConfig(TypedDict, total=False):
+    """Server-side ``thinking_config`` block, preserved 1:1."""
+
+    disabled: ModelThinkingDisabled
+    enabled: ModelThinkingEnabled
+
+
+class ModelInfo(TypedDict):
     """Model entry returned by the CLI in get_model_policy requests."""
 
     value: str
     displayName: str
-    isEnabled: bool
-    isFree: bool
-    priceFactor: float
     description: str
-    isNew: bool
+    isEnabled: bool
+    isFree: NotRequired[bool]
+    priceFactor: NotRequired[float]
+    isNew: NotRequired[bool]
+    context_config: NotRequired[ModelContextConfig]
+    thinking_config: NotRequired[ModelThinkingConfig]
 
 
 class ModelPolicyContext(TypedDict, total=False):

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/tests/cloud_agent/test_cloud_agent_query.py

@@ -435,6 +435,24 @@ async def test_cloud_agent_uses_existing_agent_to_create_session(
     }
 
 
+def test_cloud_agent_uses_api_qoder_com_as_default_openapi_prefix(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("QODER_CLOUD_AGENT_API_BASE", raising=False)
+
+    q = CloudAgentQuery(
+        prompt="hello default endpoint",
+        options=QoderAgentOptions(
+            auth=access_token("test-pat"),
+            experimental_cloud_agent={"session": {"id": "sess_existing"}},
+        ),
+    )
+
+    q._prepare_connection()
+
+    assert q._api_base == "https://api.qoder.com/api/v1/cloud"
+
+
 @pytest.mark.asyncio
 async def test_cloud_agent_usage_and_text_blocks_flow_into_result(
     monkeypatch: pytest.MonkeyPatch,

qoder_agent_sdk-1.0.2/tests/query_model_policy/functional/test_list_available_models_rich_fields.py

@@ -0,0 +1,133 @@
+"""Functional test for rich fields returned by ``get_available_models()``.
+
+The SDK should preserve the model-catalog payload shape from qodercli. In
+particular, server-side snake_case blocks such as ``context_config`` and
+``thinking_config`` must pass through without flattening or renaming.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from tests._shared.e2e import client, has_qoder_cli, no_qoder_cli_reason
+
+
+def _is_json_number(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+@pytest.mark.e2e
+@pytest.mark.asyncio
+@pytest.mark.timeout(60)
+async def test_get_available_models_reports_and_validates_returned_fields():
+    if not has_qoder_cli():
+        pytest.skip(no_qoder_cli_reason())
+
+    async with client(
+        cwd="/tmp",
+        permission_mode="bypassPermissions",
+        allow_dangerously_skip_permissions=True,
+        model="qmodel",
+        max_turns=1,
+    ) as q:
+        models = await q.get_available_models()
+
+    assert models, "expected non-empty model list"
+    returned_fields = sorted({key for model in models for key in model})
+    print("get_available_models returned fields:", ", ".join(returned_fields))
+
+    for model in models:
+        assert isinstance(model.get("value"), str)
+        if "displayName" in model:
+            assert isinstance(model["displayName"], str)
+        if "description" in model:
+            assert isinstance(model["description"], str)
+        if "isEnabled" in model:
+            assert isinstance(model["isEnabled"], bool)
+        if "isNew" in model:
+            assert isinstance(model["isNew"], bool)
+        if "isFree" in model:
+            assert isinstance(model["isFree"], bool)
+        if "priceFactor" in model:
+            assert _is_json_number(model["priceFactor"])
+
+    with_context = next(
+        (
+            model
+            for model in models
+            if isinstance(model.get("context_config"), dict) and model["context_config"]
+        ),
+        None,
+    )
+    if with_context is None:
+        print("get_available_models did not return context_config")
+    else:
+        context_config = with_context["context_config"]
+        context_defaults = 0
+        for tier, entry in context_config.items():
+            assert isinstance(tier, str)
+            assert isinstance(entry, dict), (
+                f"context_config[{tier}] on {with_context.get('value')} must be a dict"
+            )
+            assert _is_json_number(entry.get("token_count")), (
+                f"context_config[{tier}].token_count must be numeric, got {entry!r}"
+            )
+            if "is_default" in entry:
+                assert isinstance(entry["is_default"], bool)
+                if entry["is_default"]:
+                    context_defaults += 1
+        assert context_defaults <= 1, (
+            "at most one context_config tier may be is_default on "
+            f"{with_context.get('value')}"
+        )
+
+    with_thinking = next(
+        (
+            model
+            for model in models
+            if isinstance(model.get("thinking_config"), dict)
+            and model["thinking_config"]
+        ),
+        None,
+    )
+    if with_thinking is None:
+        print("get_available_models did not return thinking_config")
+        return
+
+    thinking_config = with_thinking["thinking_config"]
+    disabled = thinking_config.get("disabled")
+    enabled = thinking_config.get("enabled")
+    assert isinstance(disabled, dict) or isinstance(enabled, dict), (
+        f"thinking_config on {with_thinking.get('value')} must include "
+        "disabled or enabled"
+    )
+
+    if isinstance(disabled, dict) and "description" in disabled:
+        assert isinstance(disabled["description"], str)
+
+    if isinstance(enabled, dict):
+        if "description" in enabled:
+            assert isinstance(enabled["description"], str)
+        if "is_default" in enabled:
+            assert isinstance(enabled["is_default"], bool)
+
+        efforts = enabled.get("efforts")
+        if isinstance(efforts, dict):
+            effort_defaults = 0
+            for level, effort in efforts.items():
+                assert isinstance(level, str)
+                assert isinstance(effort, dict), (
+                    f"thinking_config.enabled.efforts[{level}] must be a dict"
+                )
+                if "description" in effort:
+                    assert isinstance(effort["description"], str)
+                if "is_default" in effort:
+                    assert isinstance(effort["is_default"], bool)
+                    if effort["is_default"]:
+                        effort_defaults += 1
+            assert effort_defaults <= 1, (
+                "at most one thinking effort may be is_default on "
+                f"{with_thinking.get('value')}"
+            )

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/tests/query_model_policy/functional/test_model_policy_e2e.py

@@ -22,7 +22,6 @@ from typing import Any
 import pytest
 
 from qoder_agent_sdk import QoderSDKClient, query
-from qoder_agent_sdk.auth import access_token_from_env
 from qoder_agent_sdk.types import (
     ModelPolicyContext,
     ModelPolicyResult,
@@ -43,14 +42,14 @@ skip_if_no_cli = pytest.mark.skipif(
 
 def make_options(**overrides) -> QoderAgentOptions:
     """Build standard options for functional tests."""
-    base = dict(
-        cwd="/tmp",
-        cli_path=CLI_PATH,
-        permission_mode="bypassPermissions",
-        allow_dangerously_skip_permissions=True,
-        model=DEFAULT_MODEL,
-        max_turns=1,
-    )
+    base = {
+        "cwd": "/tmp",
+        "cli_path": CLI_PATH,
+        "permission_mode": "bypassPermissions",
+        "allow_dangerously_skip_permissions": True,
+        "model": DEFAULT_MODEL,
+        "max_turns": 1,
+    }
     base.update(overrides)
     return QoderAgentOptions(**base)
 
@@ -216,9 +215,7 @@ class TestPullTimeout:
 
         messages = asyncio.run(_run())
         # The query should have failed - no success result
-        results = [
-            m for m in messages if hasattr(m, "type") and m.type == "result"
-        ]
+        results = [m for m in messages if hasattr(m, "type") and m.type == "result"]
         if results:
             # If we got a result, it should NOT be success
             assert results[0].subtype != "success"
@@ -245,9 +242,7 @@ class TestPullThrows:
             return messages
 
         messages = asyncio.run(_run())
-        results = [
-            m for m in messages if hasattr(m, "type") and m.type == "result"
-        ]
+        results = [m for m in messages if hasattr(m, "type") and m.type == "result"]
         if results:
             assert results[0].subtype != "success"
 
@@ -568,7 +563,7 @@ class TestPullPurposeWebFetch:
                 max_turns=3,
             )
             async for msg in query(
-                prompt='Fetch https://example.com and summarize it.',
+                prompt="Fetch https://example.com and summarize it.",
                 options=options,
             ):
                 if hasattr(msg, "type") and msg.type == "result":
@@ -597,7 +592,7 @@ class TestPullPurposeImageGen:
                 max_turns=3,
             )
             async for msg in query(
-                prompt='Generate an image of a sunset.',
+                prompt="Generate an image of a sunset.",
                 options=options,
             ):
                 if hasattr(msg, "type") and msg.type == "result":

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/tests/query_model_policy/unit/test_pull_suppresses_model_flag.py

@@ -111,7 +111,6 @@ class TestModelPolicyProviderInvocation:
                 ],
             }
         sent: list[dict] = []
-        original_write = query_obj.transport.write
 
         async def capture_write(data):
             sent.append(json.loads(data))
@@ -184,7 +183,10 @@ class TestModelPolicyProviderInvocation:
         """Provider returning parameters → forwarded on wire."""
 
         def provider(ctx: ModelPolicyContext) -> ModelPolicyResult:
-            return {"model": "qmodel", "parameters": {"temperature": 0.3, "max_tokens": 100}}
+            return {
+                "model": "qmodel",
+                "parameters": {"temperature": 0.3, "max_tokens": 100},
+            }
 
         async def _test():
             q = self._make_query_with_provider(provider)
@@ -511,7 +513,6 @@ class TestPurposeSpecificInvocations:
 
         async def _send(query_obj):
             sent: list[dict] = []
-            original_write = query_obj.transport.write
 
             async def capture_write(data):
                 sent.append(json.loads(data))
@@ -649,7 +650,6 @@ class TestCustomModelWireFormat:
         async def _test():
             q = self._make_query_with_provider(provider)
             sent: list[dict] = []
-            original_write = q.transport.write
 
             async def capture_write(data):
                 sent.append(json.loads(data))
@@ -982,9 +982,39 @@ class TestGetAvailableModels:
                         "request_id": request_id,
                         "response": {
                             "models": [
-                                {"value": "qmodel", "isEnabled": True, "displayName": "Q Model"},
-                                {"value": "qmodel-preview", "isEnabled": True, "displayName": "Q Model Preview"},
-                                {"value": "legacy", "isEnabled": False, "displayName": "Legacy"},
+                                {
+                                    "value": "qmodel",
+                                    "isEnabled": True,
+                                    "displayName": "Q Model",
+                                    "description": "Primary model",
+                                    "context_config": {
+                                        "200K": {
+                                            "token_count": 200000,
+                                            "is_default": True,
+                                        }
+                                    },
+                                    "thinking_config": {
+                                        "enabled": {
+                                            "description": "Enable thinking",
+                                            "efforts": {
+                                                "high": {
+                                                    "description": "More reasoning",
+                                                    "is_default": True,
+                                                }
+                                            },
+                                        }
+                                    },
+                                },
+                                {
+                                    "value": "qmodel-preview",
+                                    "isEnabled": True,
+                                    "displayName": "Q Model Preview",
+                                },
+                                {
+                                    "value": "legacy",
+                                    "isEnabled": False,
+                                    "displayName": "Legacy",
+                                },
                             ]
                         },
                     }
@@ -1022,6 +1052,12 @@ class TestGetAvailableModels:
             assert len(models) == 3
             assert models[0]["value"] == "qmodel"
             assert models[0]["displayName"] == "Q Model"
+            assert models[0]["description"] == "Primary model"
+            assert models[0]["context_config"]["200K"]["token_count"] == 200000
+            assert (
+                models[0]["thinking_config"]["enabled"]["efforts"]["high"]["is_default"]
+                is True
+            )
             assert models[1]["value"] == "qmodel-preview"
             assert models[2]["isEnabled"] is False
 

{qoder_agent_sdk-1.0.0 → qoder_agent_sdk-1.0.2}/tests/test_download_cli.py

@@ -43,6 +43,10 @@ def test_dev_versions_use_dev_release_bucket(monkeypatch):
     download_cli = load_download_cli()
 
     monkeypatch.delenv("QODER_CLI_MIRROR", raising=False)
+    assert (
+        download_cli.PROD_DOWNLOAD_BASE_URL
+        == "https://download.qoder.com/qodercli/releases"
+    )
     assert download_cli.is_dev_cli_version("0.2.0-nightly.20260518.0117548")
     assert (
         download_cli.get_download_base_url("0.2.17-alpha.1")