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

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

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

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

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

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

@@ -61,6 +61,7 @@ from .auth import (
     qodercli_auth,
 )
 from .client import QoderSDKClient
+from .plugins import PluginError, disable_plugin, enable_plugin, list_plugins
 from .query import query
 from .settings import filter_escalating_default_mode
 from .types import (
@@ -154,7 +155,9 @@ from .types import (
     PermissionResultAllow,
     PermissionResultDeny,
     PermissionUpdate,
+    PluginDetails,
     PluginInfo,
+    PluginResources,
     PostCompactHookInput,
     PostToolUseFailureHookInput,
     PostToolUseFailureHookSpecificOutput,
@@ -217,6 +220,10 @@ from .types import (
     ToolProgressMessage,
     ToolResultBlock,
     ToolUseBlock,
+    UsageAddOnQuotaBucket,
+    UsageInfo,
+    UsageOrgResourcePackage,
+    UsageQuotaBucket,
     UserMessage,
     UserPromptSubmitHookInput,
     UserPromptSubmitHookSpecificOutput,
@@ -823,6 +830,10 @@ __all__ = [
     "ContentBlock",
     "ContextUsageCategory",
     "ContextUsageResponse",
+    "UsageAddOnQuotaBucket",
+    "UsageInfo",
+    "UsageOrgResourcePackage",
+    "UsageQuotaBucket",
     # Tool callbacks
     "CanUseTool",
     "ToolPermissionContext",
@@ -902,7 +913,13 @@ __all__ = [
     # Plugin support
     "SdkPluginConfig",
     "PluginInfo",
+    "PluginDetails",
+    "PluginResources",
     "ReloadPluginsResponse",
+    "list_plugins",
+    "enable_plugin",
+    "disable_plugin",
+    "PluginError",
     # File checkpointing
     "RewindFilesResult",
     # Session listing

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

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

{qoder_agent_sdk-1.0.2 → qoder_agent_sdk-1.0.5}/src/qoder_agent_sdk/_internal/client.py

@@ -1,7 +1,6 @@
 """Internal client implementation."""
 
 import json
-import os
 from collections.abc import AsyncIterable, AsyncIterator
 from dataclasses import asdict, replace
 from typing import Any
@@ -14,7 +13,7 @@ from ..types import (
 )
 from .auth_helpers import get_fetch_job_token, once_callback
 from .message_parser import parse_message
-from .query import Query
+from .query import Query, resolve_initialize_timeout
 from .transport import Transport
 from .transport.subprocess_cli import SubprocessCLITransport
 
@@ -99,11 +98,7 @@ class InternalClient:
                 for name, agent_def in configured_options.agents.items()
             }
 
-        # Match QoderSDKClient.connect().
-        initialize_timeout_ms = int(
-            os.environ.get("QODER_STREAM_CLOSE_TIMEOUT", "60000")
-        )
-        initialize_timeout = max(initialize_timeout_ms / 1000.0, 60.0)
+        initialize_timeout = resolve_initialize_timeout()
 
         # Create Query to handle control protocol
         # Always use streaming mode internally (matching TypeScript SDK)

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

@@ -768,9 +768,7 @@ class CloudAgentQuery:
         if self._result_emitted or self._closed:
             return
         self._result_emitted = True
-        self._queue.put_nowait(
-            ResultMessage(**self._build_result_base(), **kwargs)
-        )
+        self._queue.put_nowait(ResultMessage(**self._build_result_base(), **kwargs))
 
     def _build_result_base(self) -> dict[str, Any]:
         elapsed_ms = int((time.monotonic() - self._started_at) * 1000)
@@ -936,6 +934,9 @@ class CloudAgentClientSession:
     async def set_model(self, _model: str | None = None) -> None:
         self._unsupported("set_model")
 
+    async def set_proxy(self, _proxy: str | None = None) -> None:
+        self._unsupported("set_proxy")
+
     async def get_available_models(self) -> list[Any]:
         self._unsupported("get_available_models")
 
@@ -987,6 +988,9 @@ class CloudAgentClientSession:
     async def get_context_usage(self) -> Any:
         self._unsupported("get_context_usage")
 
+    async def get_usage_info(self) -> None:
+        return None
+
     async def _run_turn(self, prompt: str | AsyncIterable[dict[str, Any]]) -> None:
         async with self._turn_lock:
             if self._closed or self._turn_options is None:

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

@@ -36,11 +36,16 @@ from ..types import (
     PermissionMode,
     PermissionResultAllow,
     PermissionResultDeny,
+    PluginDetails,
     SDKControlPermissionRequest,
     SDKControlRequest,
     SDKControlResponse,
     SDKHookCallbackRequest,
     ToolPermissionContext,
+    UsageAddOnQuotaBucket,
+    UsageInfo,
+    UsageOrgResourcePackage,
+    UsageQuotaBucket,
 )
 from .mcp_serialize import serialize_mcp_servers
 from .transport import Transport
@@ -50,6 +55,29 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+INITIALIZE_TIMEOUT_MS = 120_000
+INITIALIZE_TIMEOUT = INITIALIZE_TIMEOUT_MS / 1000.0
+CATALOG_READY_INITIALIZE_MIN_TIMEOUT_MS = INITIALIZE_TIMEOUT_MS
+
+
+def resolve_initialize_timeout() -> float:
+    """Resolve the initialize timeout from env var or default.
+
+    Shared by ``QoderSDKClient.connect()`` and ``InternalClient.process_query()``
+    to avoid duplicating the env-var lookup and floor logic.
+    """
+    _timeout_env = os.environ.get("QODER_STREAM_CLOSE_TIMEOUT")
+    initialize_timeout_ms = (
+        int(_timeout_env) if _timeout_env is not None else INITIALIZE_TIMEOUT_MS
+    )
+    return max(initialize_timeout_ms / 1000.0, 60.0)
+
+
+class ControlProtocolError(Exception):
+    def __init__(self, message: str, code: str | None = None) -> None:
+        super().__init__(message)
+        self.code = code
+
 
 def _normalize_oauth_resolution(
     resolution: McpOAuthResolution,
@@ -252,6 +280,161 @@ def _normalize_control_error(err: Exception) -> tuple[str, str | None]:
     return message, None
 
 
+def _error_payload_from_exception(err: Exception) -> dict[str, Any]:
+    message, code = _normalize_control_error(err)
+    payload: dict[str, Any] = {"type": "error", "error": message}
+    if code:
+        payload["code"] = code
+    return payload
+
+
+def _exception_from_error_payload(message: dict[str, Any]) -> Exception:
+    error = message.get("error", "Unknown error")
+    code = message.get("code")
+    return ControlProtocolError(
+        error if isinstance(error, str) else str(error),
+        code if isinstance(code, str) and code else None,
+    )
+
+
+def _record_or_none(value: Any) -> dict[str, Any] | None:
+    return value if isinstance(value, dict) else None
+
+
+def _read_str(source: dict[str, Any] | None, key: str) -> str | None:
+    value = source.get(key) if source is not None else None
+    return value if isinstance(value, str) else None
+
+
+def _read_bool(source: dict[str, Any] | None, key: str) -> bool | None:
+    value = source.get(key) if source is not None else None
+    return value if isinstance(value, bool) else None
+
+
+def _read_number(source: dict[str, Any] | None, key: str) -> float | None:
+    value = source.get(key) if source is not None else None
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str) and value.strip():
+        try:
+            return float(value)
+        except ValueError:
+            return None
+    return None
+
+
+def _normalize_usage_quota_bucket(value: Any) -> UsageQuotaBucket | None:
+    source = _record_or_none(value)
+    total = _read_number(source, "total")
+    used = _read_number(source, "used")
+    remaining = _read_number(source, "remaining")
+    percentage = _read_number(source, "percentage")
+    unit = _read_str(source, "unit")
+    if (
+        total is None
+        or used is None
+        or remaining is None
+        or percentage is None
+        or unit is None
+    ):
+        return None
+    return {
+        "total": total,
+        "used": used,
+        "remaining": remaining,
+        "percentage": percentage,
+        "unit": unit,
+    }
+
+
+def _normalize_usage_add_on_quota(value: Any) -> UsageAddOnQuotaBucket | None:
+    source = _record_or_none(value)
+    quota = _normalize_usage_quota_bucket(source)
+    detail_url = _read_str(source, "detailUrl")
+    if quota is None or detail_url is None:
+        return None
+    return {**quota, "detailUrl": detail_url}
+
+
+def _normalize_usage_org_resource_package(
+    value: Any,
+) -> UsageOrgResourcePackage | None:
+    source = _record_or_none(value)
+    used = _read_number(source, "used")
+    cap = _read_number(source, "cap")
+    remaining = _read_number(source, "remaining")
+    percentage = _read_number(source, "percentage")
+    available = _read_bool(source, "available")
+    unit = _read_str(source, "unit")
+    if (
+        used is None
+        or cap is None
+        or remaining is None
+        or percentage is None
+        or available is None
+        or unit is None
+    ):
+        return None
+    return {
+        "used": used,
+        "cap": cap,
+        "remaining": remaining,
+        "percentage": percentage,
+        "available": available,
+        "unit": unit,
+    }
+
+
+def _normalize_usage_info(value: Any) -> UsageInfo | None:
+    source = _record_or_none(value)
+    user_id = _read_str(source, "userId")
+    user_type = _read_str(source, "userType")
+    total_usage_percentage = _read_number(source, "totalUsagePercentage")
+    is_highest_tier = _read_bool(source, "isHighestTier")
+    expires_at = _read_number(source, "expiresAt")
+    upgrade_url = _read_str(source, "upgradeUrl")
+    user_quota = _normalize_usage_quota_bucket(
+        source.get("userQuota") if source is not None else None
+    )
+    add_on_quota = _normalize_usage_add_on_quota(
+        source.get("addOnQuota") if source is not None else None
+    )
+    is_quota_exceeded = _read_bool(source, "isQuotaExceeded")
+    is_plan_quota_prorated = _read_bool(source, "isPlanQuotaProrated")
+    org_resource_package = _normalize_usage_org_resource_package(
+        source.get("orgResourcePackage") if source is not None else None
+    )
+    if (
+        user_id is None
+        or user_type is None
+        or total_usage_percentage is None
+        or is_highest_tier is None
+        or expires_at is None
+        or upgrade_url is None
+        or user_quota is None
+        or add_on_quota is None
+        or is_quota_exceeded is None
+        or is_plan_quota_prorated is None
+        or org_resource_package is None
+    ):
+        return None
+    return {
+        "userId": user_id,
+        "userType": user_type,
+        "totalUsagePercentage": total_usage_percentage,
+        "isHighestTier": is_highest_tier,
+        "expiresAt": expires_at,
+        "upgradeUrl": upgrade_url,
+        "userQuota": user_quota,
+        "addOnQuota": add_on_quota,
+        "isQuotaExceeded": is_quota_exceeded,
+        "isPlanQuotaProrated": is_plan_quota_prorated,
+        "orgResourcePackage": org_resource_package,
+    }
+
+
 def _resolve_exit_plan_mode_details(
     request: SDKControlPermissionRequest,
 ) -> ExitPlanModeApprovalDetails | None:
@@ -323,7 +506,7 @@ class Query:
         | None = None,
         hooks: dict[str, list[dict[str, Any]]] | None = None,
         sdk_mcp_servers: dict[str, "McpServer"] | None = None,
-        initialize_timeout: float = 60.0,
+        initialize_timeout: float = INITIALIZE_TIMEOUT,
         agents: dict[str, dict[str, Any]] | None = None,
         enable_file_checkpointing: bool | None = None,
         on_mcp_oauth_required: OnMcpOAuthRequired | None = None,
@@ -394,6 +577,7 @@ class Query:
         self._initialized = False
         self._closed = False
         self._initialization_result: dict[str, Any] | None = None
+        self._initialization_task: asyncio.Task[dict[str, Any] | None] | None = None
         # Query observes auth failures in stream-json messages. Keep a local
         # guard because the transport may also observe an auth-error exit code,
         # while the client wrapper protects the final user callback.
@@ -410,6 +594,21 @@ class Query:
         """
         if not self.is_streaming_mode:
             return None
+        if self._initialized:
+            return self._initialization_result
+        if self._initialization_task is not None:
+            return await self._initialization_task
+
+        loop = asyncio.get_running_loop()
+        self._initialization_task = loop.create_task(self._perform_initialize())
+        try:
+            return await self._initialization_task
+        finally:
+            if not self._initialized:
+                self._initialization_task = None
+
+    async def _perform_initialize(self) -> dict[str, Any] | None:
+        initialize_timeout_ms = int(self._initialize_timeout * 1000)
 
         # Build hooks configuration for initialization
         hooks_config: dict[str, Any] = {}
@@ -437,7 +636,10 @@ class Query:
             "type": "initialize",
             "subtype": "initialize",
             "modelPolicyProvider": False,
+            "initializeTimeoutMs": initialize_timeout_ms,
         }
+        if initialize_timeout_ms >= CATALOG_READY_INITIALIZE_MIN_TIMEOUT_MS:
+            request["supportsCatalogReadyInitialize"] = True
         if self.resolve_model is not None:
             request["modelPolicyProvider"] = True
             logger.debug("initialize: pull-mode enabled (modelPolicyProvider=True)")
@@ -540,8 +742,8 @@ class Query:
                     if request_id in self.pending_control_responses:
                         event = self.pending_control_responses[request_id]
                         if response.get("subtype") == "error":
-                            self.pending_control_results[request_id] = Exception(
-                                response.get("error", "Unknown error")
+                            self.pending_control_results[request_id] = (
+                                _exception_from_error_payload(response)
                             )
                         else:
                             self.pending_control_results[request_id] = response
@@ -600,7 +802,7 @@ class Query:
                     self.pending_control_results[request_id] = e
                     event.set()
             # Put error in stream so iterators can handle it
-            await self._message_send.send({"type": "error", "error": str(e)})
+            await self._message_send.send(_error_payload_from_exception(e))
         finally:
             # Unblock any waiters (e.g. string-prompt path waiting for first
             # result) so they don't stall for the full timeout on early exit.
@@ -1263,6 +1465,15 @@ class Query:
         """Get a breakdown of current context window usage by category."""
         return await self._send_control_request({"subtype": "get_context_usage"})
 
+    async def get_usage_info(self) -> UsageInfo | None:
+        """Get account quota and usage information."""
+        try:
+            resp = await self._send_control_request({"subtype": "get_usage_info"})
+        except Exception:
+            # Compat: older CLIs reject unknown control subtypes.
+            return None
+        return _normalize_usage_info(resp.get("usage"))
+
     async def interrupt(self) -> None:
         """Send interrupt control request."""
         await self._send_control_request({"subtype": "interrupt"})
@@ -1285,6 +1496,15 @@ class Query:
             }
         )
 
+    async def set_proxy(self, proxy: str | None = None) -> None:
+        """Set or clear the proxy for the running CLI session."""
+        await self._send_control_request(
+            {
+                "subtype": "set_proxy",
+                "proxy": proxy,
+            }
+        )
+
     async def get_available_models(self) -> list[ModelInfo]:
         """Query the CLI for the list of available models.
 
@@ -1377,6 +1597,11 @@ class Query:
         """
         return await self._send_control_request({"subtype": "reload_plugins"})
 
+    async def list_plugins(self) -> list[PluginDetails]:
+        """List plugins loaded in the current session."""
+        result = await self._send_control_request({"subtype": "list_plugins"})
+        return cast(list[PluginDetails], result["plugins"])
+
     async def reconnect_mcp_server(self, server_name: str) -> None:
         """Reconnect a disconnected or failed MCP server.
 
@@ -1576,6 +1801,8 @@ class Query:
         before closing stdin to allow bidirectional control protocol communication.
         """
         try:
+            await self.initialize()
+
             async for message in stream:
                 if self._closed:
                     break
@@ -1584,6 +1811,10 @@ class Query:
             await self.wait_for_result_and_end_input()
         except Exception as e:
             logger.debug(f"Error streaming input: {e}")
+            try:
+                await self._message_send.send(_error_payload_from_exception(e))
+            finally:
+                await self.transport.end_input()
 
     async def receive_messages(self) -> AsyncIterator[dict[str, Any]]:
         """Receive SDK messages (not control messages)."""
@@ -1592,13 +1823,18 @@ class Query:
             if message.get("type") == "end":
                 break
             elif message.get("type") == "error":
-                raise Exception(message.get("error", "Unknown error"))
+                raise _exception_from_error_payload(message)
 
             yield message
 
     async def close(self) -> None:
         """Close the query and transport."""
         self._closed = True
+        if (
+            self._initialization_task is not None
+            and not self._initialization_task.done()
+        ):
+            self._initialization_task.cancel()
         for task in list(self._child_tasks):
             task.cancel()
         if self._read_task is not None and not self._read_task.done():

{qoder_agent_sdk-1.0.2 → qoder_agent_sdk-1.0.5}/src/qoder_agent_sdk/_internal/transport/subprocess_cli.py

@@ -44,6 +44,7 @@ logger = logging.getLogger(__name__)
 _DEFAULT_MAX_BUFFER_SIZE = 1024 * 1024  # 1MB buffer limit
 MINIMUM_RUNTIME_VERSION = "0.2.0"
 CLI_EXIT_CODE_AUTH_ERROR = 41
+PROXY_ENV_VARS = ("HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy")
 
 _PERMISSION_POLICY_TO_RULE_KEY = {
     "always_allow": "allow",
@@ -683,6 +684,9 @@ class SubprocessCLITransport(Transport):
                     process_env[key] = value
                 else:
                     process_env.pop(key, None)
+            if self._options.proxy is not None:
+                for key in PROXY_ENV_VARS:
+                    process_env[key] = self._options.proxy
             if self._auth_payload_path is not None:
                 process_env["QODER_SDK_AUTH_PAYLOAD_FILE"] = str(
                     self._auth_payload_path

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

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

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

@@ -1,7 +1,6 @@
 """Qoder SDK client for interactive agent sessions."""
 
 import json
-import os
 from collections.abc import AsyncIterable, AsyncIterator
 from dataclasses import asdict, replace
 from typing import Any, cast
@@ -20,10 +19,12 @@ from .types import (
     ModelInfo,
     OAuthToken,
     PermissionMode,
+    PluginDetails,
     QoderAgentOptions,
     ReloadPluginsResponse,
     ResultMessage,
     RewindFilesResult,
+    UsageInfo,
 )
 
 
@@ -98,7 +99,7 @@ class QoderSDKClient:
             await self._query.connect(prompt=prompt)
             return
 
-        from ._internal.query import Query
+        from ._internal.query import Query, resolve_initialize_timeout
         from ._internal.transport.subprocess_cli import SubprocessCLITransport
 
         # Auto-connect with empty async iterable if no prompt is provided
@@ -148,11 +149,7 @@ class QoderSDKClient:
                 if isinstance(config, dict) and config.get("type") == "sdk":
                     sdk_mcp_servers[name] = config["instance"]  # type: ignore[typeddict-item]
 
-        # QODER_STREAM_CLOSE_TIMEOUT is the SDK env var for initialize timeout.
-        initialize_timeout_ms = int(
-            os.environ.get("QODER_STREAM_CLOSE_TIMEOUT", "60000")
-        )
-        initialize_timeout = max(initialize_timeout_ms / 1000.0, 60.0)
+        initialize_timeout = resolve_initialize_timeout()
 
         # Convert agents to dict format for initialize request
         agents_dict: dict[str, dict[str, Any]] | None = None
@@ -313,6 +310,18 @@ class QoderSDKClient:
             raise CLIConnectionError("Not connected. Call connect() first.")
         await self._query.set_model(model)
 
+    async def set_proxy(self, proxy: str | None = None) -> None:
+        """Set or clear the proxy during conversation.
+
+        Args:
+            proxy: Proxy URL for the running qodercli session. Supports
+                ``http://``, ``https://``, ``socks5://``, and ``socks://``.
+                Pass ``None`` or an empty string to clear the proxy.
+        """
+        if not self._query:
+            raise CLIConnectionError("Not connected. Call connect() first.")
+        await self._query.set_proxy(proxy)
+
     async def get_available_models(self) -> list[ModelInfo]:
         """Query the CLI for the list of available models.
 
@@ -461,6 +470,13 @@ class QoderSDKClient:
         result = await self._query.reload_plugins()
         return cast(ReloadPluginsResponse, result)
 
+    async def list_plugins(self) -> list[PluginDetails]:
+        """List plugins loaded in the current session."""
+        if not self._query:
+            raise CLIConnectionError("Not connected. Call connect() first.")
+        result: list[PluginDetails] = await self._query.list_plugins()
+        return result
+
     async def reconnect_mcp_server(self, server_name: str) -> None:
         """Reconnect a disconnected or failed MCP server (only works with streaming mode).
 
@@ -696,6 +712,30 @@ class QoderSDKClient:
         result: ContextUsageResponse = await self._query.get_context_usage()
         return result
 
+    async def get_usage_info(self) -> UsageInfo | None:
+        """Get current account quota and usage information.
+
+        Returns the same account usage payload exposed by the CLI's usage API.
+        Missing required fields are not synthesized by the SDK; when the
+        running CLI cannot provide a complete usage payload this returns
+        ``None``.
+
+        Returns:
+            UsageInfo dictionary, or ``None`` when unavailable.
+
+        Example:
+            ```python
+            async with QoderSDKClient() as client:
+                usage = await client.get_usage_info()
+                if usage is not None:
+                    print(usage["totalUsagePercentage"])
+            ```
+        """
+        if not self._query:
+            raise CLIConnectionError("Not connected. Call connect() first.")
+        result = await self._query.get_usage_info()
+        return cast(UsageInfo | None, result)
+
     async def get_server_info(self) -> dict[str, Any] | None:
         """Get server initialization info including available commands and output styles.