Flatten CopilotClient options + drop unused SessionConfig TypedDicts

Make the Python public API idiomatically Pythonic, matching the
conventions used by ``openai``, ``anthropic``, ``httpx``, etc.

**CopilotClient: flat kw-only ctor params**

The ``CopilotClientOptions`` dataclass was a port of the TS / .NET
``CopilotClientOptions`` interface and is not how a Python API client is
typically configured. Python users expect ``CopilotClient(connection=...,
log_level=..., github_token=...)`` rather than
``CopilotClient(CopilotClientOptions(connection=..., log_level=...,
github_token=...))``.

Changes:

- All 12 options previously on ``CopilotClientOptions`` are now kw-only
  parameters on ``CopilotClient.__init__``: ``connection``,
  ``working_directory``, ``log_level``, ``env``, ``github_token``,
  ``base_directory``, ``use_logged_in_user``, ``telemetry``,
  ``session_fs``, ``session_idle_timeout_seconds``,
  ``enable_remote_sessions``, ``on_list_models``.
- ``CopilotClientOptions`` is renamed to ``_CopilotClientOptions`` and is
  now an implementation detail used only internally to carry the resolved
  options around. The public ``__all__`` no longer exports it.
- IDE autocomplete on ``CopilotClient(`` now lists every option directly
  with its type, default, and docstring. Pyright / ty catch unknown
  kwargs at the call site.

**Drop vestigial SessionConfig / ResumeSessionConfig / SessionConfigBase**

These TypedDicts mirrored the TS / .NET ``SessionConfig`` interfaces but
were never used anywhere in Python — ``create_session()`` and
``resume_session()`` already take flat kw-only parameters (the idiomatic
form). The TypedDicts were just unreferenced documentation noise.

Updates:

- README, all docs Python snippets, all 25 ``test/scenarios/**/python/main.py``
  fixtures, every E2E test, every unit test now use the new flat ctor.
- The test class ``TestSubprocessOptions`` (E2E) and the unit-style
  ``test_telemetry_config_in_subprocess_config`` test exercised the
  ``CopilotClientOptions`` dataclass shape itself; they're deleted since
  Python's type system already enforces ctor-kwarg correctness.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: SteveSandersonMS

docs/auth/byok.md

@@ -369,22 +369,20 @@ const client = new CopilotClient({
 <summary><strong>Python</strong></summary>
 
 ```python
-from copilot import CopilotClient, CopilotClientOptions
+from copilot import CopilotClient
 from copilot.client import ModelInfo, ModelCapabilities, ModelSupports, ModelLimits
 
 client = CopilotClient(
-    CopilotClientOptions(
-        on_list_models=lambda: [
-            ModelInfo(
-                id="my-custom-model",
-                name="My Custom Model",
-                capabilities=ModelCapabilities(
-                    supports=ModelSupports(vision=False, reasoning_effort=False),
-                    limits=ModelLimits(max_context_window_tokens=128000),
-                ),
-            )
-        ],
-    ),
+    on_list_models=lambda: [
+        ModelInfo(
+            id="my-custom-model",
+            name="My Custom Model",
+            capabilities=ModelCapabilities(
+                supports=ModelSupports(vision=False, reasoning_effort=False),
+                limits=ModelLimits(max_context_window_tokens=128000),
+            ),
+        )
+    ],
 )
 ```
 

docs/features/remote-sessions.md

@@ -38,9 +38,9 @@ session.on("session.info", (event) => {
 
 <!-- docs-validate: skip -->
 ```python
-from copilot import CopilotClient, CopilotClientOptions
+from copilot import CopilotClient
 
-client = CopilotClient(CopilotClientOptions(enable_remote_sessions=True))
+client = CopilotClient(enable_remote_sessions=True)
 session = await client.create_session(
     working_directory="/path/to/github-repo",
     on_permission_request=lambda req: {"allowed": True},

docs/observability/opentelemetry.md

@@ -27,13 +27,13 @@ const client = new CopilotClient({
 
 <!-- docs-validate: skip -->
 ```python
-from copilot import CopilotClient, CopilotClientOptions
+from copilot import CopilotClient
 
-client = CopilotClient(CopilotClientOptions(
+client = CopilotClient(
     telemetry={
         "otlp_endpoint": "http://localhost:4318",
     },
-))
+)
 ```
 
 </details>

docs/setup/backend-services.md

@@ -144,12 +144,12 @@ res.json({ content: response?.data.content });
 <summary><strong>Python</strong></summary>
 
 ```python
-from copilot import CopilotClient, CopilotClientOptions, RuntimeConnection
+from copilot import CopilotClient, RuntimeConnection
 from copilot.session import PermissionHandler
 
-client = CopilotClient(CopilotClientOptions(
+client = CopilotClient(
     connection=RuntimeConnection.for_uri("localhost:4321"),
-))
+)
 await client.start()
 
 session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="gpt-4.1", session_id=f"user-{user_id}-{int(time.time())}")

docs/troubleshooting/debugging.md

@@ -32,9 +32,9 @@ const client = new CopilotClient({
 <summary><strong>Python</strong></summary>
 
 ```python
-from copilot import CopilotClient, CopilotClientOptions
+from copilot import CopilotClient
 
-client = CopilotClient(CopilotClientOptions(log_level="debug"))
+client = CopilotClient(log_level="debug")
 ```
 
 </details>

python/README.md

@@ -133,22 +133,20 @@ async with CopilotClient() as client:
 > **Note:** For manual lifecycle management, see [Manual Resource Management](#manual-resource-management) above.
 
 ```python
-from copilot import CopilotClient, CopilotClientOptions, RuntimeConnection
+from copilot import CopilotClient, RuntimeConnection
 
 # Connect to an existing CLI server
-client = CopilotClient(
-    CopilotClientOptions(connection=RuntimeConnection.for_uri("localhost:3000"))
-)
+client = CopilotClient(connection=RuntimeConnection.for_uri("localhost:3000"))
 ```
 
 **CopilotClient Constructor:**
 
 ```python
-CopilotClient()                          # spawn the bundled runtime with defaults
-CopilotClient(CopilotClientOptions(...)) # customise via options
+CopilotClient()                                                   # spawn the bundled runtime with defaults
+CopilotClient(connection=..., log_level="debug", github_token=..., ...)
 ```
 
-**CopilotClientOptions** — configure the client:
+All options are kw-only parameters:
 
 - `connection` (RuntimeConnection | None): How to reach the runtime. Use
   `RuntimeConnection.for_stdio(...)`, `RuntimeConnection.for_tcp(...)`, or
@@ -161,6 +159,7 @@ CopilotClient(CopilotClientOptions(...)) # customise via options
 - `use_logged_in_user` (bool | None): Whether to use logged-in user for authentication (default: True, but False when `github_token` is provided).
 - `telemetry` (dict | None): OpenTelemetry configuration for the CLI process. Providing this enables telemetry — no separate flag needed. See [Telemetry](#telemetry) below.
 - `enable_remote_sessions` (bool): Enable remote/cloud session support (default: False).
+- `on_list_models` (callable | None): Custom handler for `list_models()`. When provided, the handler is called instead of querying the runtime.
 
 **RuntimeConnection variants:**
 
@@ -531,13 +530,13 @@ async with await client.create_session(
 The SDK supports OpenTelemetry for distributed tracing. Provide a `telemetry` config to enable trace export and automatic W3C Trace Context propagation.
 
 ```python
-from copilot import CopilotClient, CopilotClientOptions
+from copilot import CopilotClient
 
-client = CopilotClient(CopilotClientOptions(
+client = CopilotClient(
     telemetry={
         "otlp_endpoint": "http://localhost:4318",
     },
-))
+)
 ```
 
 **TelemetryConfig options:**

python/copilot/__init__.py

@@ -9,7 +9,6 @@
     CloudSessionOptions,
     CloudSessionRepository,
     CopilotClient,
-    CopilotClientOptions,
     GetAuthStatusResponse,
     GetStatusResponse,
     LogLevel,
@@ -87,10 +86,7 @@
     PreToolUseHookInput,
     PreToolUseHookOutput,
     ProviderConfig,
-    ResumeSessionConfig,
     SessionCapabilities,
-    SessionConfig,
-    SessionConfigBase,
     SessionEndHandler,
     SessionEndHookInput,
     SessionEndHookOutput,
@@ -140,7 +136,6 @@
     "CommandContext",
     "CommandDefinition",
     "CopilotClient",
-    "CopilotClientOptions",
     "CopilotSession",
     "CreateSessionFsHandler",
     "ElicitationContext",
@@ -188,12 +183,9 @@
     "PreToolUseHookOutput",
     "ProviderConfig",
     "RemoteSessionMode",
-    "ResumeSessionConfig",
     "RuntimeConnection",
     "SessionBackgroundEvent",
     "SessionCapabilities",
-    "SessionConfig",
-    "SessionConfigBase",
     "SessionContext",
     "SessionCreatedEvent",
     "SessionDeletedEvent",

python/copilot/client.py

@@ -165,9 +165,7 @@ class RuntimeConnection:
 
     Example:
         >>> CopilotClient()  # default: stdio with the bundled runtime
-        >>> CopilotClient(
-        ...     CopilotClientOptions(connection=RuntimeConnection.for_uri("localhost:3000"))
-        ... )
+        >>> CopilotClient(connection=RuntimeConnection.for_uri("localhost:3000"))
     """
 
     @staticmethod
@@ -282,73 +280,25 @@ class UriRuntimeConnection(RuntimeConnection):
 
 
 @dataclass
-class CopilotClientOptions:
-    """Configuration options for a :class:`CopilotClient`.
+class _CopilotClientOptions:
+    """Internal configuration carrier used by :class:`CopilotClient`.
 
-    All process-management options (``working_directory``, ``log_level``,
-    ``env``, ``github_token``, …) apply only when the SDK spawns the runtime
-    (stdio / tcp connections). They are ignored when connecting to an
-    existing runtime via :meth:`RuntimeConnection.uri`.
+    This is not part of the public API: ``CopilotClient`` accepts all of
+    these options as keyword arguments directly.
     """
 
     connection: RuntimeConnection | None = None
-    """How to reach the runtime.
-
-    Defaults to :meth:`RuntimeConnection.stdio` with the bundled binary.
-    """
-
     working_directory: str | None = None
-    """Working directory for the runtime process. ``None`` uses the current directory."""
-
     log_level: LogLevel = "info"
-    """Log level for the runtime process."""
-
     env: dict[str, str] | None = None
-    """Environment variables for the runtime process. ``None`` inherits the current env."""
-
     github_token: str | None = None
-    """GitHub token for authentication. Takes priority over other auth methods."""
-
     base_directory: str | None = None
-    """Base directory for Copilot data (session state, config, etc.).
-
-    Sets the ``COPILOT_HOME`` environment variable on the spawned runtime.
-    When ``None``, the runtime defaults to ``~/.copilot``.
-    """
-
     use_logged_in_user: bool | None = None
-    """Use the logged-in user for authentication.
-
-    ``None`` (default) resolves to ``True`` unless ``github_token`` is set.
-    """
-
     telemetry: TelemetryConfig | None = None
-    """OpenTelemetry configuration. Providing this enables telemetry."""
-
     session_fs: SessionFsConfig | None = None
-    """Connection-level session filesystem provider configuration."""
-
     session_idle_timeout_seconds: int | None = None
-    """Server-wide session idle timeout in seconds.
-
-    Sessions without activity for this duration are automatically cleaned up.
-    Set to ``None`` or ``0`` to disable.
-    """
-
     enable_remote_sessions: bool = False
-    """Enable remote session support (Mission Control integration).
-
-    When ``True``, sessions in a GitHub repository working directory are
-    accessible from GitHub web and mobile.
-    """
-
     on_list_models: Callable[[], list[ModelInfo] | Awaitable[list[ModelInfo]]] | None = None
-    """Custom handler for :meth:`CopilotClient.list_models`.
-
-    When provided, the handler is called instead of querying the runtime
-    server. Matches the ``onListModels`` / ``OnListModels`` option in the
-    TypeScript and .NET SDKs.
-    """
 
 
 # ============================================================================
@@ -1082,46 +1032,100 @@ class CopilotClient:
 
         >>> # Or connect to an existing server
         >>> client = CopilotClient(
-        ...     CopilotClientOptions(connection=RuntimeConnection.for_uri("localhost:3000"))
+        ...     connection=RuntimeConnection.for_uri("localhost:3000"),
         ... )
     """
 
     def __init__(
         self,
-        options: CopilotClientOptions | None = None,
+        *,
+        connection: RuntimeConnection | None = None,
+        working_directory: str | None = None,
+        log_level: LogLevel = "info",
+        env: dict[str, str] | None = None,
+        github_token: str | None = None,
+        base_directory: str | None = None,
+        use_logged_in_user: bool | None = None,
+        telemetry: TelemetryConfig | None = None,
+        session_fs: SessionFsConfig | None = None,
+        session_idle_timeout_seconds: int | None = None,
+        enable_remote_sessions: bool = False,
+        on_list_models: Callable[[], list[ModelInfo] | Awaitable[list[ModelInfo]]] | None = None,
     ):
         """
         Initialize a new CopilotClient.
 
+        All process-management options (``working_directory``, ``log_level``,
+        ``env``, ``github_token``, …) apply only when the SDK spawns the runtime
+        (stdio / tcp connections). They are ignored when connecting to an
+        existing runtime via :meth:`RuntimeConnection.for_uri`.
+
         Args:
-            options: Client configuration. Defaults to ``CopilotClientOptions()``
-                with a default :meth:`RuntimeConnection.for_stdio` connection using
-                the bundled runtime binary.
+            connection: How to reach the runtime. Defaults to
+                :meth:`RuntimeConnection.for_stdio` with the bundled binary.
+            working_directory: Working directory for the runtime process.
+                ``None`` uses the current directory.
+            log_level: Log level for the runtime process. Defaults to ``"info"``.
+            env: Environment variables for the runtime process. ``None`` inherits
+                the current env.
+            github_token: GitHub token for authentication. Takes priority over
+                other auth methods.
+            base_directory: Base directory for Copilot data (session state,
+                config, etc.). Sets the ``COPILOT_HOME`` environment variable on
+                the spawned runtime. When ``None``, the runtime defaults to
+                ``~/.copilot``.
+            use_logged_in_user: Use the logged-in user for authentication.
+                ``None`` (default) resolves to ``True`` unless ``github_token``
+                is set.
+            telemetry: OpenTelemetry configuration. Providing this enables
+                telemetry.
+            session_fs: Connection-level session filesystem provider
+                configuration.
+            session_idle_timeout_seconds: Server-wide session idle timeout in
+                seconds. Sessions without activity for this duration are
+                automatically cleaned up. Set to ``None`` or ``0`` to disable.
+            enable_remote_sessions: Enable remote session support (Mission
+                Control integration). When ``True``, sessions in a GitHub
+                repository working directory are accessible from GitHub web
+                and mobile.
+            on_list_models: Custom handler for :meth:`list_models`. When
+                provided, the handler is called instead of querying the runtime
+                server.
 
         Example:
             >>> # Default — spawns runtime using stdio with the bundled binary
             >>> client = CopilotClient()
             >>>
             >>> # Connect to an existing runtime
             >>> client = CopilotClient(
-            ...     CopilotClientOptions(connection=RuntimeConnection.for_uri("localhost:3000"))
+            ...     connection=RuntimeConnection.for_uri("localhost:3000"),
             ... )
             >>>
             >>> # Custom runtime path with specific log level
             >>> client = CopilotClient(
-            ...     CopilotClientOptions(
-            ...         connection=RuntimeConnection.for_stdio(path="/usr/local/bin/copilot"),
-            ...         log_level="debug",
-            ...     )
+            ...     connection=RuntimeConnection.for_stdio(path="/usr/local/bin/copilot"),
+            ...     log_level="debug",
             ... )
         """
-        if options is None:
-            options = CopilotClientOptions()
+        options = _CopilotClientOptions(
+            connection=connection,
+            working_directory=working_directory,
+            log_level=log_level,
+            env=env,
+            github_token=github_token,
+            base_directory=base_directory,
+            use_logged_in_user=use_logged_in_user,
+            telemetry=telemetry,
+            session_fs=session_fs,
+            session_idle_timeout_seconds=session_idle_timeout_seconds,
+            enable_remote_sessions=enable_remote_sessions,
+            on_list_models=on_list_models,
+        )
         connection = (
             options.connection if options.connection is not None else RuntimeConnection.for_stdio()
         )
 
-        self._options: CopilotClientOptions = options
+        self._options: _CopilotClientOptions = options
         self._connection: RuntimeConnection = connection
         self._on_list_models = options.on_list_models