kodelet-sdk 0.2.2__tar.gz → 0.4.0__tar.gz

{kodelet_sdk-0.2.2 → kodelet_sdk-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: kodelet-sdk
-Version: 0.2.2
+Version: 0.4.0
 Summary: Python SDK for authoring Kodelet extensions
 Project-URL: Repository, https://github.com/jingkaihe/kodelet
 Author: Kodelet
@@ -108,7 +108,30 @@ Session options include:
 | `cwd` | Working directory on the runner |
 | `resume` | An existing conversation ID |
 
-Inline settings cannot include provider secrets, endpoints, or local prompt paths.
+Pass an `ExecutionOptions` instance directly as `create_session(options=...)` for model settings, execution limits, and tool selection. The optional `profile="work"` selects a model profile already configured on the daemon; omit it to use the daemon's default. Inline settings cannot include provider secrets, endpoints, or local prompt paths.
+
+### Extension model profiles
+
+```python
+ext = Extension()
+SEARCH_PROFILE = ext.register_profile(
+    "code-search",
+    provider="openai",
+    model="gpt-5.6-luna",
+    reasoning_effort="none",
+    hidden=True,
+)
+CLAUDE_PROFILE = ext.register_profile(
+    "claude",
+    provider="anthropic",
+    model="claude-sonnet-4-6",
+    anthropic={"platform": "anthropic"},
+    anthropic_api_access="subscription",
+)
+session = await client.create_session(profile=SEARCH_PROFILE)
+```
+
+`register_profile(name, *, provider, model, hidden=False, **options)` returns the flat name unchanged. Names are ASCII slugs (1–128 characters; `default` is reserved). `hidden=True` hides the profile from pickers.
 
 ### Inline extensions
 
@@ -149,7 +172,9 @@ if __name__ == "__main__":
 
 Inline extensions require ACP session-extension protocol v1; older hosts fail with a clear error. On resume, reattach extensions in the same order. Callbacks are not saved or replayed, and pending work is cancelled when the channel or session closes.
 
-Host calls such as `ctx.update()` and `ctx.children` go to the runner. File, process, and storage helpers remain local. Legacy `extension_transport="unix"` and `"tcp"` options are accepted but ignored; ACP manages the connection.
+To customize the prompt, attach an inline `agent.init` handler that returns a `systemPrompt` patch and leave extensions enabled. Prompt hooks work alongside typed session options.
+
+Host calls such as `ctx.update()` and `ctx.fork_conversation()` go to the runner. File, process, and storage helpers remain local. Legacy `extension_transport="unix"` and `"tcp"` options are accepted but ignored; ACP manages the connection.
 
 ### Steering
 
@@ -179,7 +204,6 @@ Create an `Extension(name=..., version=...)`, then register synchronous or async
 | `@ext.command(...)` | Slash command or recipe, with optional aliases |
 | `@ext.on(event, ...)` | Lifecycle handler, such as `session.start`, `tool.call`, or `agent.end` |
 | `@ext.shortcut(...)` | Native TUI keyboard shortcut |
-| `ext.register_profile(...)` | Child execution preset |
 | `ext.run_sync()` / `await ext.run()` | Serve an executable extension over stdio |
 
 ### Tool results and progress
@@ -292,54 +316,22 @@ Handlers receive `ctx` with call metadata and these helpers:
 - `ctx.process.exec(...)` and `ctx.process.spawn(...)` for async process execution.
 - `ctx.env.get(...)` for environment access.
 - `ctx.log.debug/info/warn/error(...)` for JSON logs to stderr.
-- `ctx.children.start(...)` for delegated agent work.
+- `await ctx.fork_conversation(name=...)` to snapshot the active tool's conversation for an ACP session.
 - `await ctx.acquire_background_task(...)` to keep runtime resources alive after a handler returns.
 - `ctx.ui.input/confirm/select/notify(...)` for host UI reverse-RPC calls.
 - `ctx.ui.append_transcript(...)`, `ctx.ui.set_widget(...)`, and `ctx.ui.open_surface(...)` for capability-gated persistent native-TUI content.
 
-### Child agents
-
-Use `ctx.children` for agent work inside a tool, rather than creating a nested `Client`. Register a preset on the extension, then start a child with that preset:
-
-```python
-class TaskInput(BaseModel):
-    task: str
-
-
-ext.register_profile({
-    "name": "code_search",
-    "options": {
-        "allowed_tools": ["file_read", "grep_tool", "glob_tool"],
-        "no_extensions": True,
-        "no_skills": True,
-        "enable_fs_search_tools": True,
-        "max_turns": 3,
-    },
-})
-
-
-@ext.tool("code_search", description="Search the repository", input_schema=TaskInput)
-async def code_search(input: TaskInput, ctx: ToolContext) -> str:
-    child = await ctx.children.start(profile="code_search", message=input.task)
-    result = await child.wait(on_event=lambda event: ctx.update(event.get("text") or event["kind"]))
-    return result["output"]
-```
-
-- `read()` checks progress; `cancel()` cancels only that child. Cancelling `wait()` also cancels the child.
-- Children start with fresh context. Use `context_mode="fork"` inside the active tool handler to copy the parent's history.
-- Use `resume=child.conversation_id` for a follow-up. It creates a new run; old handles still target the old run. Resume cannot be combined with fork.
-- `child.steer(message)` queues guidance without starting a turn. Like session steering, it returns `injected` or `promptRequired`.
-- Child settings cannot expand the parent's permissions or limits. `system_prompt_path` in a preset is resolved on the runner.
+### Agent work inside tools
 
-Start and steer calls do not retry automatically. Supply a stable `request_id` when you need to reconcile an uncertain submission; reuse it only for the same input. A disconnected start may already be running, so keep its ID and any lease until cancellation or cleanup is confirmed.
+Use `Client.create_session(options=ExecutionOptions(...))` with normal client credentials and server/runner targeting. Attach `TaskProgress` for activity updates and await client/progress cleanup on every exit path. A cancelled response is not success, even with partial text.
 
-For a history snapshot without execution, use `ctx.fork_conversation()`. It raises `ConversationForkUnavailableError` when unavailable. `Client.create_session(inherit_context=...)` is unsupported.
+Sessions start fresh. For inherited context, call `ctx.fork_conversation(name="worker-name")` inside the active tool, then pass the returned ID as `resume`. `inherit_context` remains unsupported. Reuse or resume the session for follow-ups; steering only affects a running turn.
 
 ### Background work
 
-Children normally end with their tool handler. To let work outlive it, acquire a lease with `await ctx.acquire_background_task(...)` and pass `lease=lease` when first starting the child inside the tool. Close the lease after the work and final updates finish.
+To let extension work outlive its handler, acquire a lease with `await ctx.acquire_background_task(...)` while the handler is active. Retain and manage the background task yourself, close any ACP client it owns, and release the lease after the work and final UI updates finish. A lease keeps extension resources alive; it does not authorize ACP sessions or keep a completed tool's `ctx.update()` channel open.
 
-Runner leases last at most one hour and end on release, cancellation, or runner/extension shutdown. They keep resources alive, not Python task state. Resuming after a restart requires a new authorized tool call; saved IDs alone are insufficient.
+Runner leases last at most one hour and end on release, cancellation, or runner/extension shutdown. They keep resources alive, not Python task state; background tasks must be recreated after a restart.
 
 ### User input
 

{kodelet_sdk-0.2.2 → kodelet_sdk-0.4.0}/README.md

@@ -95,7 +95,30 @@ Session options include:
 | `cwd` | Working directory on the runner |
 | `resume` | An existing conversation ID |
 
-Inline settings cannot include provider secrets, endpoints, or local prompt paths.
+Pass an `ExecutionOptions` instance directly as `create_session(options=...)` for model settings, execution limits, and tool selection. The optional `profile="work"` selects a model profile already configured on the daemon; omit it to use the daemon's default. Inline settings cannot include provider secrets, endpoints, or local prompt paths.
+
+### Extension model profiles
+
+```python
+ext = Extension()
+SEARCH_PROFILE = ext.register_profile(
+    "code-search",
+    provider="openai",
+    model="gpt-5.6-luna",
+    reasoning_effort="none",
+    hidden=True,
+)
+CLAUDE_PROFILE = ext.register_profile(
+    "claude",
+    provider="anthropic",
+    model="claude-sonnet-4-6",
+    anthropic={"platform": "anthropic"},
+    anthropic_api_access="subscription",
+)
+session = await client.create_session(profile=SEARCH_PROFILE)
+```
+
+`register_profile(name, *, provider, model, hidden=False, **options)` returns the flat name unchanged. Names are ASCII slugs (1–128 characters; `default` is reserved). `hidden=True` hides the profile from pickers.
 
 ### Inline extensions
 
@@ -136,7 +159,9 @@ if __name__ == "__main__":
 
 Inline extensions require ACP session-extension protocol v1; older hosts fail with a clear error. On resume, reattach extensions in the same order. Callbacks are not saved or replayed, and pending work is cancelled when the channel or session closes.
 
-Host calls such as `ctx.update()` and `ctx.children` go to the runner. File, process, and storage helpers remain local. Legacy `extension_transport="unix"` and `"tcp"` options are accepted but ignored; ACP manages the connection.
+To customize the prompt, attach an inline `agent.init` handler that returns a `systemPrompt` patch and leave extensions enabled. Prompt hooks work alongside typed session options.
+
+Host calls such as `ctx.update()` and `ctx.fork_conversation()` go to the runner. File, process, and storage helpers remain local. Legacy `extension_transport="unix"` and `"tcp"` options are accepted but ignored; ACP manages the connection.
 
 ### Steering
 
@@ -166,7 +191,6 @@ Create an `Extension(name=..., version=...)`, then register synchronous or async
 | `@ext.command(...)` | Slash command or recipe, with optional aliases |
 | `@ext.on(event, ...)` | Lifecycle handler, such as `session.start`, `tool.call`, or `agent.end` |
 | `@ext.shortcut(...)` | Native TUI keyboard shortcut |
-| `ext.register_profile(...)` | Child execution preset |
 | `ext.run_sync()` / `await ext.run()` | Serve an executable extension over stdio |
 
 ### Tool results and progress
@@ -279,54 +303,22 @@ Handlers receive `ctx` with call metadata and these helpers:
 - `ctx.process.exec(...)` and `ctx.process.spawn(...)` for async process execution.
 - `ctx.env.get(...)` for environment access.
 - `ctx.log.debug/info/warn/error(...)` for JSON logs to stderr.
-- `ctx.children.start(...)` for delegated agent work.
+- `await ctx.fork_conversation(name=...)` to snapshot the active tool's conversation for an ACP session.
 - `await ctx.acquire_background_task(...)` to keep runtime resources alive after a handler returns.
 - `ctx.ui.input/confirm/select/notify(...)` for host UI reverse-RPC calls.
 - `ctx.ui.append_transcript(...)`, `ctx.ui.set_widget(...)`, and `ctx.ui.open_surface(...)` for capability-gated persistent native-TUI content.
 
-### Child agents
-
-Use `ctx.children` for agent work inside a tool, rather than creating a nested `Client`. Register a preset on the extension, then start a child with that preset:
-
-```python
-class TaskInput(BaseModel):
-    task: str
-
-
-ext.register_profile({
-    "name": "code_search",
-    "options": {
-        "allowed_tools": ["file_read", "grep_tool", "glob_tool"],
-        "no_extensions": True,
-        "no_skills": True,
-        "enable_fs_search_tools": True,
-        "max_turns": 3,
-    },
-})
-
-
-@ext.tool("code_search", description="Search the repository", input_schema=TaskInput)
-async def code_search(input: TaskInput, ctx: ToolContext) -> str:
-    child = await ctx.children.start(profile="code_search", message=input.task)
-    result = await child.wait(on_event=lambda event: ctx.update(event.get("text") or event["kind"]))
-    return result["output"]
-```
-
-- `read()` checks progress; `cancel()` cancels only that child. Cancelling `wait()` also cancels the child.
-- Children start with fresh context. Use `context_mode="fork"` inside the active tool handler to copy the parent's history.
-- Use `resume=child.conversation_id` for a follow-up. It creates a new run; old handles still target the old run. Resume cannot be combined with fork.
-- `child.steer(message)` queues guidance without starting a turn. Like session steering, it returns `injected` or `promptRequired`.
-- Child settings cannot expand the parent's permissions or limits. `system_prompt_path` in a preset is resolved on the runner.
+### Agent work inside tools
 
-Start and steer calls do not retry automatically. Supply a stable `request_id` when you need to reconcile an uncertain submission; reuse it only for the same input. A disconnected start may already be running, so keep its ID and any lease until cancellation or cleanup is confirmed.
+Use `Client.create_session(options=ExecutionOptions(...))` with normal client credentials and server/runner targeting. Attach `TaskProgress` for activity updates and await client/progress cleanup on every exit path. A cancelled response is not success, even with partial text.
 
-For a history snapshot without execution, use `ctx.fork_conversation()`. It raises `ConversationForkUnavailableError` when unavailable. `Client.create_session(inherit_context=...)` is unsupported.
+Sessions start fresh. For inherited context, call `ctx.fork_conversation(name="worker-name")` inside the active tool, then pass the returned ID as `resume`. `inherit_context` remains unsupported. Reuse or resume the session for follow-ups; steering only affects a running turn.
 
 ### Background work
 
-Children normally end with their tool handler. To let work outlive it, acquire a lease with `await ctx.acquire_background_task(...)` and pass `lease=lease` when first starting the child inside the tool. Close the lease after the work and final updates finish.
+To let extension work outlive its handler, acquire a lease with `await ctx.acquire_background_task(...)` while the handler is active. Retain and manage the background task yourself, close any ACP client it owns, and release the lease after the work and final UI updates finish. A lease keeps extension resources alive; it does not authorize ACP sessions or keep a completed tool's `ctx.update()` channel open.
 
-Runner leases last at most one hour and end on release, cancellation, or runner/extension shutdown. They keep resources alive, not Python task state. Resuming after a restart requires a new authorized tool call; saved IDs alone are insufficient.
+Runner leases last at most one hour and end on release, cancellation, or runner/extension shutdown. They keep resources alive, not Python task state; background tasks must be recreated after a restart.
 
 ### User input
 

kodelet_sdk-0.4.0/VERSION.txt

@@ -0,0 +1 @@
+0.4.0

{kodelet_sdk-0.2.2 → kodelet_sdk-0.4.0}/src/kodelet_sdk/__init__.py

@@ -65,7 +65,6 @@ from .api import (
     define_extension,
     on,
 )
-from .child import ChildClient, ChildExecution, ChildSteerResult
 from .context import (
     BackgroundTaskLease,
     CommandContext,
@@ -115,7 +114,7 @@ from .context import (
     run_with_host_rpc_client,
     set_active_host_rpc_client,
 )
-from .execution import ExecutionOptions, ExecutionProfile
+from .execution import ExecutionOptions
 from .runtime import run_extension
 from .schemas import JSONSchema, ToolInputSchema
 from .task_progress import (
@@ -153,9 +152,6 @@ __all__ = [
     "BackgroundTaskLease",
     "BaseModel",
     "BridgeTransport",
-    "ChildClient",
-    "ChildExecution",
-    "ChildSteerResult",
     "Client",
     "ClientOptions",
     "CommandContext",
@@ -176,7 +172,6 @@ __all__ = [
     "EventResult",
     "ExecResult",
     "ExecutionOptions",
-    "ExecutionProfile",
     "Extension",
     "ExtensionEvent",
     "ExtensionHost",

{kodelet_sdk-0.2.2 → kodelet_sdk-0.4.0}/src/kodelet_sdk/agent/client.py

@@ -79,8 +79,10 @@ class Client:
 
         merged_options: dict[str, Any] = {**dict(session_options or {}), **kwargs}
         if merged_options.get("inherit_context") is not None:
-            raise ValueError("Use ctx.children for scoped execution; live forking remains "
-                             "available separately through ctx.fork_conversation")
+            raise ValueError(
+                "inherit_context is unsupported; call ctx.fork_conversation() "
+                "and pass the returned conversation ID as resume"
+            )
         extensions = tuple(
             cast(Sequence[Entrypoint | Extension], merged_options.get("extensions") or ())
         )

{kodelet_sdk-0.2.2 → kodelet_sdk-0.4.0}/src/kodelet_sdk/agent/types.py

@@ -78,7 +78,8 @@ class CreateSessionOptions(TypedDict, total=False):
     protocol; supply them again on resume in the same order. ``ui`` services
     input, confirm, select and notify requests locally when handlers are supplied.
     ``extension_transport`` accepts legacy unix/tcp values but is now a no-op.
-    ``inherit_context`` remains unsupported; use ``ctx.children`` instead.
+    ``inherit_context`` remains unsupported; call ``ctx.fork_conversation()``
+    explicitly and pass its returned conversation ID as ``resume`` instead.
     """
 
     profile: str | Profile | ProfileInput

{kodelet_sdk-0.2.2 → kodelet_sdk-0.4.0}/src/kodelet_sdk/api.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import inspect
+import re
 from collections.abc import Awaitable, Callable, Mapping, Sequence
 from dataclasses import dataclass
 from typing import (
@@ -36,7 +37,7 @@ from .context import (
     create_shortcut_context,
     create_tool_context,
 )
-from .execution import ExecutionProfile
+from .execution import ExtensionProfileOptions
 from .schemas import SchemaAdapter, SchemaLike, infer_schema_from_callable
 
 _MISSING = object()
@@ -326,8 +327,8 @@ class Extension:
             self._metadata["name"] = name
         if version is not None:
             self._metadata["version"] = version
-        self._tools: dict[str, ToolRegistration] = {}
         self._profiles: dict[str, dict[str, Any]] = {}
+        self._tools: dict[str, ToolRegistration] = {}
         self._commands_by_name: dict[str, CommandRegistration] = {}
         self._command_registrations: list[CommandRegistration] = []
         self._shortcuts: dict[str, ShortcutRegistration] = {}
@@ -352,6 +353,49 @@ class Extension:
             if value is not None:
                 self._metadata[key] = value
 
+    def register_profile(
+        self,
+        name: str,
+        *,
+        provider: Literal["openai", "anthropic"],
+        model: str,
+        hidden: bool = False,
+        **options: Any,
+    ) -> str:
+        """Declare a model profile and return its name unchanged.
+
+        Names are 1–128-character ASCII slugs; default is reserved (case-insensitive).
+        Requires host acceptance before ACP selection.
+        Optional settings: weak_model, max_tokens, weak_model_max_tokens,
+        thinking_budget_tokens, reasoning_effort, openai, anthropic, and
+        anthropic_api_access (camelCase also accepted at the top level).
+        Provider blocks use daemon config keys unchanged; the daemon validates them.
+        """
+        if not isinstance(name, str) or not re.fullmatch(
+            r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}", name,
+        ):
+            raise ValueError(
+                "Extension profile names must be ASCII slugs "
+                "matching [A-Za-z0-9][A-Za-z0-9._-]* (1–128 characters)"
+            )
+        if name.lower() == "default":
+            raise ValueError('Extension profile name "default" is reserved')
+        if name in self._profiles:
+            raise ValueError(f"Duplicate extension profile registration: {name}")
+        if not isinstance(hidden, bool):
+            raise ValueError("Extension profile hidden must be a boolean")
+        validated = ExtensionProfileOptions.model_validate({
+            "provider": provider,
+            "model": model,
+            **options,
+        })
+        self._profiles[name] = {
+            "name": name,
+            "options": validated.to_wire(),
+            "hidden": hidden,
+        }
+        return name
+
     def register_tool(
         self,
         *,
@@ -650,16 +694,6 @@ class Extension:
             return decorator(cast(HandlerT, handler))
         return decorator
 
-    def register_profile(self, profile: ExecutionProfile | Mapping[str, Any]) -> None:
-        """Register an extension-scoped child preset without daemon YAML setup."""
-        snapshot = ExecutionProfile.model_validate(profile).to_wire()
-        name = str(snapshot["name"])
-        if name in self._profiles:
-            raise ValueError(f"Duplicate execution preset: {name}")
-        if len(self._profiles) >= 32:
-            raise ValueError("An extension supports at most 32 execution presets")
-        self._profiles[name] = snapshot
-
     def initialize(self, params: Mapping[str, Any]) -> dict[str, Any]:
         """Handle Kodelet's ``extension.initialize`` JSON-RPC request.
 
@@ -671,6 +705,13 @@ class Extension:
             registrations, shortcut registrations, and event subscriptions.
         """
 
+        capabilities = _mapping_or_empty(params.get("capabilities"))
+        profiles_capability = _mapping_or_empty(capabilities.get("profiles"))
+        if self._profiles and profiles_capability.get("remote") is not True:
+            raise RuntimeError(
+                "Remote extension profiles are not supported by this host; update the Kodelet "
+                "daemon and runner (capabilities.profiles.remote is required)"
+            )
         self._init_params = params
         extension = params.get("extension")
         extension_id = extension.get("id") if isinstance(extension, Mapping) else None

{kodelet_sdk-0.2.2 → kodelet_sdk-0.4.0}/src/kodelet_sdk/context.py

@@ -14,8 +14,6 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Literal, NotRequired, Protocol, Required, TypeAlias, TypedDict, cast
 
-from .child import ChildClient
-
 CommandFlagValue: TypeAlias = str | bool | list[str]
 
 
@@ -1432,6 +1430,7 @@ class SharedContext:
         )
         data_dir = Path(str(data_dir_value)).resolve(strict=False)
         self.session_id = _optional_str(context.get("sessionId"))
+        self.runner_id = _optional_str(extension.get("runnerId"))
         self.conversation_id = _optional_str(context.get("conversationId"))
         self.ui_scope_id = _normalize_ui_scope_id(context.get("uiScopeId")) or None
         self.cwd = str(cwd)
@@ -1447,7 +1446,6 @@ class SharedContext:
         self.env = EnvContext()
         self.log = LogContext(_optional_str(extension.get("id")))
         self._host_rpc_client = _current_host_rpc_client()
-        self.children = ChildClient(self._host_rpc_client)
         self._background_tasks_enabled = _runtime_capability_supported(
             init,
             "backgroundTasks",

{kodelet_sdk-0.2.2 → kodelet_sdk-0.4.0}/src/kodelet_sdk/execution.py

@@ -1,4 +1,4 @@
-"""Credential-free execution options and runner-owned preset registrations."""
+"""Typed ACP execution and extension profile options."""
 
 from __future__ import annotations
 
@@ -6,9 +6,9 @@ import csv
 import io
 import re
 from collections.abc import Mapping
-from typing import Annotated, Any, Literal
+from typing import Annotated, Any, Literal, Self
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, JsonValue, model_validator
 from pydantic.alias_generators import to_camel
 
 
@@ -45,6 +45,52 @@ class ExecutionOptions(BaseModel):
         return self.model_dump(by_alias=True, exclude_none=True)
 
 
+class ExtensionProfileOptions(BaseModel):
+    """Registration-only settings; nested provider configuration is validated by the daemon."""
+
+    model_config = ConfigDict(
+        extra="forbid",
+        strict=True,
+        alias_generator=to_camel,
+        populate_by_name=True,
+    )
+
+    provider: Literal["openai", "anthropic"]
+    model: str = Field(min_length=1)
+    weak_model: str | None = Field(default=None, min_length=1)
+    max_tokens: int | None = Field(default=None, gt=0)
+    weak_model_max_tokens: int | None = Field(default=None, gt=0)
+    thinking_budget_tokens: int | None = Field(default=None, ge=0)
+    reasoning_effort: str | None = Field(default=None, min_length=1)
+    openai: dict[str, JsonValue] | None = None
+    anthropic: dict[str, JsonValue] | None = None
+    anthropic_api_access: Literal["auto", "subscription", "api-key"] | None = Field(
+        default=None,
+        alias="anthropicAPIAccess",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def reject_null(cls, value: Any) -> Any:
+        if isinstance(value, Mapping) and any(item is None for item in value.values()):
+            raise ValueError("Omit absent profile settings; null is not inheritance")
+        return value
+
+    @model_validator(mode="after")
+    def validate_provider_settings(self) -> Self:
+        if self.provider != "openai" and self.openai is not None:
+            raise ValueError("openai settings require the openai provider")
+        if self.provider != "anthropic" and (
+            self.anthropic is not None or self.anthropic_api_access is not None
+        ):
+            raise ValueError("anthropic settings require the anthropic provider")
+        return self
+
+    def to_wire(self) -> dict[str, Any]:
+        """Return an independent wire snapshot, preserving nested provider config keys."""
+        return self.model_dump(by_alias=True, exclude_none=True)
+
+
 def execution_args(options: ExecutionOptions) -> list[str]:
     """Encode typed options for the daemon-only ACP client, including empty/false values."""
     args: list[str] = []
@@ -62,31 +108,3 @@ def execution_args(options: ExecutionOptions) -> list[str]:
             encoded = str(value)
         args.append(f"--{flag}={encoded}")
     return args
-
-
-class ExecutionProfile(BaseModel):
-    """Extension-owned preset; prompt paths are resolved on the runner."""
-
-    model_config = ConfigDict(extra="forbid", strict=True, alias_generator=to_camel,
-                              populate_by_name=True)
-    name: str = Field(min_length=1, max_length=128, pattern=r"^[^/\\\x00]+$")
-    options: ExecutionOptions | None = None
-    system_prompt_path: str | None = Field(default=None, max_length=8192)
-    system_prompt: str | None = Field(default=None, max_length=256 * 1024)
-
-    @model_validator(mode="before")
-    @classmethod
-    def reject_null(cls, value: Any) -> Any:
-        if isinstance(value, Mapping) and any(item is None for item in value.values()):
-            raise ValueError("Omit absent preset fields instead of null")
-        return value
-
-    @model_validator(mode="after")
-    def check_prompt(self) -> ExecutionProfile:
-        if self.system_prompt and self.system_prompt_path:
-            raise ValueError("Use prompt content or a prompt path, not both")
-        return self
-
-    def to_wire(self) -> dict[str, Any]:
-        """Return the serializable registration for extension.initialize."""
-        return self.model_dump(by_alias=True, exclude_none=True)