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

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

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

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

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

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

@@ -61,6 +61,14 @@ from .auth import (
     qodercli_auth,
 )
 from .client import QoderSDKClient
+from .plugins import (
+    PluginError,
+    disable_plugin,
+    enable_plugin,
+    install_plugin,
+    list_plugins,
+    uninstall_plugin,
+)
 from .query import query
 from .settings import filter_escalating_default_mode
 from .types import (
@@ -109,7 +117,9 @@ from .types import (
     HookJSONOutput,
     HookMatcher,
     HookSpecificOutput,
+    InstallPluginResult,
     InstructionsLoadedHookInput,
+    LocalizedModelText,
     McpOAuthCallbackUrlResolution,
     McpOAuthCodeResolution,
     McpOAuthRequest,
@@ -135,6 +145,7 @@ from .types import (
     ModelPolicyContext,
     ModelPolicyProvider,
     ModelPolicyResult,
+    ModelPromotion,
     ModelThinkingConfig,
     ModelThinkingDisabled,
     ModelThinkingEnabled,
@@ -154,7 +165,9 @@ from .types import (
     PermissionResultAllow,
     PermissionResultDeny,
     PermissionUpdate,
+    PluginDetails,
     PluginInfo,
+    PluginResources,
     PostCompactHookInput,
     PostToolUseFailureHookInput,
     PostToolUseFailureHookSpecificOutput,
@@ -174,9 +187,6 @@ from .types import (
     ResolvedSettingsSource,
     ResultMessage,
     RewindFilesResult,
-    SandboxIgnoreViolations,
-    SandboxNetworkConfig,
-    SandboxSettings,
     SdkBeta,
     SDKCapabilities,
     SDKControlGetByokConfigRequest,
@@ -187,6 +197,8 @@ from .types import (
     SDKPermissionDeniedMessage,
     SdkPluginConfig,
     SDKSessionInfo,
+    ServerModelJson,
+    ServerModelJsonValue,
     SessionCreateParams,
     SessionEndHookInput,
     SessionMessage,
@@ -217,6 +229,11 @@ from .types import (
     ToolProgressMessage,
     ToolResultBlock,
     ToolUseBlock,
+    UninstallPluginResult,
+    UsageAddOnQuotaBucket,
+    UsageInfo,
+    UsageOrgResourcePackage,
+    UsageQuotaBucket,
     UserMessage,
     UserPromptSubmitHookInput,
     UserPromptSubmitHookSpecificOutput,
@@ -823,6 +840,10 @@ __all__ = [
     "ContentBlock",
     "ContextUsageCategory",
     "ContextUsageResponse",
+    "UsageAddOnQuotaBucket",
+    "UsageInfo",
+    "UsageOrgResourcePackage",
+    "UsageQuotaBucket",
     # Tool callbacks
     "CanUseTool",
     "ToolPermissionContext",
@@ -902,7 +923,17 @@ __all__ = [
     # Plugin support
     "SdkPluginConfig",
     "PluginInfo",
+    "PluginDetails",
+    "PluginResources",
+    "InstallPluginResult",
+    "UninstallPluginResult",
     "ReloadPluginsResponse",
+    "list_plugins",
+    "enable_plugin",
+    "disable_plugin",
+    "install_plugin",
+    "uninstall_plugin",
+    "PluginError",
     # File checkpointing
     "RewindFilesResult",
     # Session listing
@@ -919,10 +950,6 @@ __all__ = [
     "ForkSessionResult",
     # Beta support
     "SdkBeta",
-    # Sandbox support
-    "SandboxSettings",
-    "SandboxNetworkConfig",
-    "SandboxIgnoreViolations",
     # MCP Server Support
     "create_sdk_mcp_server",
     "tool",
@@ -948,6 +975,10 @@ __all__ = [
     "ModelThinkingConfig",
     "ModelThinkingDisabled",
     "ModelThinkingEnabled",
+    "ModelPromotion",
+    "LocalizedModelText",
+    "ServerModelJson",
+    "ServerModelJsonValue",
     "ModelPolicyContext",
     "ModelPolicyProvider",
     "ModelPolicyResult",

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

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

{qoder_agent_sdk-1.0.2 → qoder_agent_sdk-1.0.8}/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.8}/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.8}/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,174 @@ 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)
+    if source is None:
+        return None
+    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")
+    bucket: UsageQuotaBucket = {}
+    if total is not None:
+        bucket["total"] = total
+    if used is not None:
+        bucket["used"] = used
+    if remaining is not None:
+        bucket["remaining"] = remaining
+    if percentage is not None:
+        bucket["percentage"] = percentage
+    if unit is not None:
+        bucket["unit"] = unit
+    if not bucket:
+        return None
+    return bucket
+
+
+def _normalize_usage_add_on_quota(value: Any) -> UsageAddOnQuotaBucket | None:
+    source = _record_or_none(value)
+    if source is None:
+        return None
+    quota = _normalize_usage_quota_bucket(source)
+    result: UsageAddOnQuotaBucket = {}
+    if quota is not None:
+        if "total" in quota:
+            result["total"] = quota["total"]
+        if "used" in quota:
+            result["used"] = quota["used"]
+        if "remaining" in quota:
+            result["remaining"] = quota["remaining"]
+        if "percentage" in quota:
+            result["percentage"] = quota["percentage"]
+        if "unit" in quota:
+            result["unit"] = quota["unit"]
+    detail_url = _read_str(source, "detailUrl")
+    if detail_url is not None:
+        result["detailUrl"] = detail_url
+    if not result:
+        return None
+    return result
+
+
+def _normalize_usage_org_resource_package(
+    value: Any,
+) -> UsageOrgResourcePackage | None:
+    source = _record_or_none(value)
+    if source is None:
+        return None
+    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")
+    bucket: UsageOrgResourcePackage = {}
+    if used is not None:
+        bucket["used"] = used
+    if cap is not None:
+        bucket["cap"] = cap
+    if remaining is not None:
+        bucket["remaining"] = remaining
+    if percentage is not None:
+        bucket["percentage"] = percentage
+    if available is not None:
+        bucket["available"] = available
+    if unit is not None:
+        bucket["unit"] = unit
+    if not bucket:
+        return None
+    return bucket
+
+
+def _normalize_usage_info(value: Any) -> UsageInfo | None:
+    source = _record_or_none(value)
+    if source is None:
+        return None
+    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"))
+    add_on_quota = _normalize_usage_add_on_quota(source.get("addOnQuota"))
+    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")
+    )
+    usage: UsageInfo = {}
+    if user_id is not None:
+        usage["userId"] = user_id
+    if user_type is not None:
+        usage["userType"] = user_type
+    if total_usage_percentage is not None:
+        usage["totalUsagePercentage"] = total_usage_percentage
+    if is_highest_tier is not None:
+        usage["isHighestTier"] = is_highest_tier
+    if expires_at is not None:
+        usage["expiresAt"] = expires_at
+    if upgrade_url is not None:
+        usage["upgradeUrl"] = upgrade_url
+    if user_quota is not None:
+        usage["userQuota"] = user_quota
+    if add_on_quota is not None:
+        usage["addOnQuota"] = add_on_quota
+    if is_quota_exceeded is not None:
+        usage["isQuotaExceeded"] = is_quota_exceeded
+    if is_plan_quota_prorated is not None:
+        usage["isPlanQuotaProrated"] = is_plan_quota_prorated
+    if org_resource_package is not None:
+        usage["orgResourcePackage"] = org_resource_package
+    return usage
+
+
 def _resolve_exit_plan_mode_details(
     request: SDKControlPermissionRequest,
 ) -> ExitPlanModeApprovalDetails | None:
@@ -323,7 +519,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 +590,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 +607,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 +649,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 +755,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 +815,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 +1478,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 +1509,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 +1610,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 +1814,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 +1824,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 +1836,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.8}/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",
@@ -301,7 +302,6 @@ class SubprocessCLITransport(Transport):
         - None if no settings are needed
         """
         has_settings = self._options.settings is not None
-        has_sandbox = self._options.sandbox is not None
         has_add_dirs = bool(self._options.add_dirs)
         has_file_checkpointing = bool(self._options.enable_file_checkpointing)
         mcp_policy_rules = self._collect_mcp_policy_permission_rules()
@@ -309,7 +309,6 @@ class SubprocessCLITransport(Transport):
 
         if (
             not has_settings
-            and not has_sandbox
             and not has_add_dirs
             and not has_file_checkpointing
             and not has_mcp_policy_rules
@@ -319,7 +318,6 @@ class SubprocessCLITransport(Transport):
         if (
             has_settings
             and isinstance(self._options.settings, (str, Path))
-            and not has_sandbox
             and not has_add_dirs
             and not has_file_checkpointing
             and not has_mcp_policy_rules
@@ -338,9 +336,6 @@ class SubprocessCLITransport(Transport):
         self._apply_additional_directories(settings_obj)
         self._apply_mcp_policy_rules(settings_obj, mcp_policy_rules)
 
-        if has_sandbox:
-            settings_obj["sandbox"] = self._options.sandbox
-
         if has_file_checkpointing:
             general = settings_obj.get("general")
             if not isinstance(general, dict):
@@ -469,7 +464,6 @@ class SubprocessCLITransport(Transport):
         if self._options.session_id:
             cmd.extend(["--session-id", self._options.session_id])
 
-        # Handle settings and sandbox: merge sandbox into settings if both are provided
         settings_value = self._build_settings_value()
         if settings_value:
             cmd.extend(["--settings", settings_value])
@@ -516,14 +510,12 @@ class SubprocessCLITransport(Transport):
         if self._options.agent:
             cmd.extend(["--agent", self._options.agent])
 
-        # Always pass --setting-sources to ensure SDK mode runs in isolation by default.
-        # Empty string = no sources loaded (sandboxed); explicit list = only those sources.
-        sources_value = (
-            ",".join(self._options.setting_sources)
-            if self._options.setting_sources
-            else ""
-        )
-        cmd.extend(["--setting-sources", sources_value])
+        # Pass --setting-sources only when explicitly configured.
+        # None (default) = CLI uses its default behavior (loads all sources).
+        # [] (empty list) = explicitly disable all filesystem sources (isolation).
+        if self._options.setting_sources is not None:
+            sources_value = ",".join(self._options.setting_sources)
+            cmd.extend(["--setting-sources", sources_value])
 
         # SDK mode never wants the CLI's bundled / built-in skills (simplify,
         # debug, security-review, ...) silently joining the Skill tool surface.
@@ -683,6 +675,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.8}/src/qoder_agent_sdk/_version.py

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