okstra 0.163.2 → 0.165.0

package/runtime/python/okstra_ctl/adapters/providers/grok/adapter.py

@@ -0,0 +1,76 @@
+"""Bundled Grok provider catalog."""
+from okstra_ctl.domain.provider import LeadLaunchSpec, ModelSpec, ProviderSpec
+from okstra_ctl.domain.worker_exec import (
+    STREAM_JSON,
+    ExecCommand,
+    PolicySupport,
+    WorkerExecRequest,
+)
+from okstra_ctl.domain.worker_stream import content_block_events
+
+
+GROK = {
+    "grok-build-0.1": ModelSpec(
+        "grok-build-0.1", "grok-build-0.1", (1.00, 0.20, 2.00), in_picker=True
+    ),
+    "grok-4.5": ModelSpec("grok-4.5", "grok-4.5", (2.00, 0.30, 6.00), in_picker=True),
+}
+
+GROK_LEAD_LAUNCH = LeadLaunchSpec(
+    executable="grok",
+    model_flag="--model",
+    resume_session_id_flag="--resume",
+)
+
+
+class GrokExecution:
+    """grok CLI invocation.
+
+    Runs inside the stage tree when there is one. That is where this provider's
+    production path already puts it, and it is why the working directory is part
+    of the returned command rather than something the runner picks.
+    """
+
+    def build_command(self, request: WorkerExecRequest) -> ExecCommand:
+        cwd = request.worktree_path or request.project_root
+        return ExecCommand(
+            argv=(
+                "grok",
+                "-p",
+                request.prompt_text,
+                "-m",
+                request.model,
+                "--output-format",
+                "streaming-json",
+                "--cwd",
+                str(cwd),
+            ),
+            stdin_text=None,
+            stream_format=STREAM_JSON,
+            normalise=content_block_events,
+            cwd=cwd,
+        )
+
+    def policy_support(self) -> PolicySupport:
+        return PolicySupport(
+            can_auto_approve=False,
+            can_bound_write_scope=False,
+            note="this CLI exposes no approval or sandbox flag",
+        )
+
+
+def create_provider() -> ProviderSpec:
+    return ProviderSpec(
+        provider="grok",
+        display_label="Grok",
+        models=GROK,
+        default_models={
+            "lead": "grok-build-0.1",
+            "analyser": "grok-build-0.1",
+            "critic": "grok-4.5",
+        },
+        wrapper="okstra-grok-exec.sh",
+        supported_roles=frozenset({"lead", "analyser", "critic"}),
+        lead_launch=GROK_LEAD_LAUNCH,
+        exec_strategy=GrokExecution(),
+    )

package/runtime/python/okstra_ctl/adapters/providers/grok/manifest.json

@@ -0,0 +1 @@
+{"schemaVersion": 1, "id": "grok", "factory": "adapter.py:create_provider"}

package/runtime/python/okstra_ctl/adapters/providers/kimi/adapter.py

@@ -0,0 +1,80 @@
+"""Bundled Kimi provider catalog."""
+from okstra_ctl.domain.provider import LeadLaunchSpec, ModelSpec, ProviderSpec
+from okstra_ctl.domain.worker_exec import (
+    STREAM_JSON,
+    ExecCommand,
+    PolicySupport,
+    WorkerExecRequest,
+)
+from okstra_ctl.domain.worker_stream import content_block_events
+
+
+KIMI = {
+    "kimi-k2.7-code": ModelSpec(
+        "Kimi K2.7 Code", "kimi-k2.7-code", (0.95, 0.19, 4.00), in_picker=True
+    ),
+    "kimi k2.7 code": ModelSpec("Kimi K2.7 Code", "kimi-k2.7-code"),
+    "kimi-for-coding": ModelSpec("Kimi K2.7 Code", "kimi-for-coding", in_picker=True),
+    "kimi-k3": ModelSpec("Kimi K3", "kimi-k3", (3.00, 0.30, 15.00), in_picker=True),
+    "kimi k3": ModelSpec("Kimi K3", "kimi-k3"),
+    "k3": ModelSpec("Kimi K3", "k3", in_picker=True),
+    "k3-256k": ModelSpec("Kimi K3 256K", "k3-256k", in_picker=True),
+    "kimi k3 256k": ModelSpec("Kimi K3 256K", "k3-256k"),
+}
+
+KIMI_LEAD_LAUNCH = LeadLaunchSpec(
+    executable="kimi",
+    model_flag="--model",
+    resume_session_id_flag="--session",
+)
+
+
+class KimiExecution:
+    """kimi CLI invocation.
+
+    No flag names the working directory, so the process's own is the only
+    control. Returning it in the command keeps that fact inside the contract
+    instead of leaving the runner to infer it.
+    """
+
+    def build_command(self, request: WorkerExecRequest) -> ExecCommand:
+        cwd = request.worktree_path or request.project_root
+        return ExecCommand(
+            argv=(
+                "kimi",
+                "-p",
+                request.prompt_text,
+                "-m",
+                request.model,
+                "--output-format",
+                "stream-json",
+            ),
+            stdin_text=None,
+            stream_format=STREAM_JSON,
+            normalise=content_block_events,
+            cwd=cwd,
+        )
+
+    def policy_support(self) -> PolicySupport:
+        return PolicySupport(
+            can_auto_approve=False,
+            can_bound_write_scope=False,
+            note="this CLI exposes no approval or sandbox flag",
+        )
+
+
+def create_provider() -> ProviderSpec:
+    return ProviderSpec(
+        provider="kimi",
+        display_label="Kimi",
+        models=KIMI,
+        default_models={
+            "lead": "kimi-k2.7-code",
+            "analyser": "kimi-k2.7-code",
+            "critic": "kimi-k3",
+        },
+        wrapper="okstra-kimi-exec.sh",
+        supported_roles=frozenset({"lead", "analyser", "critic"}),
+        lead_launch=KIMI_LEAD_LAUNCH,
+        exec_strategy=KimiExecution(),
+    )

package/runtime/python/okstra_ctl/adapters/providers/kimi/manifest.json

@@ -0,0 +1 @@
+{"schemaVersion": 1, "id": "kimi", "factory": "adapter.py:create_provider"}

package/runtime/python/okstra_ctl/application/__init__.py

@@ -0,0 +1 @@
+"""Host-neutral application services."""

package/runtime/python/okstra_ctl/application/advance_wizard.py

@@ -0,0 +1,25 @@
+"""Plan a wizard prompt through the selected host interaction boundary."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from okstra_ctl.domain.host import HostSessionContext
+from okstra_ctl.domain.wizard.interaction import InteractionPlan, WizardPrompt
+from okstra_ctl.ports import InteractionPort
+
+
+@dataclass(frozen=True)
+class PlannedWizardPrompt:
+    prompt: WizardPrompt
+    interaction: InteractionPlan
+
+
+def plan_prompt(
+    prompt: WizardPrompt,
+    context: HostSessionContext,
+    interaction_port: InteractionPort,
+) -> PlannedWizardPrompt:
+    return PlannedWizardPrompt(
+        prompt=prompt,
+        interaction=interaction_port.plan(prompt, context),
+    )

package/runtime/python/okstra_ctl/application/collect_usage.py

@@ -0,0 +1,15 @@
+"""Collect a usage snapshot through the selected host boundary."""
+from __future__ import annotations
+
+from okstra_ctl.ports.usage_accounting import (
+    UsageAccountingPort,
+    UsageRequest,
+    UsageSnapshot,
+)
+
+
+def collect_usage(
+    request: UsageRequest,
+    port: UsageAccountingPort,
+) -> UsageSnapshot:
+    return port.collect(request)

package/runtime/python/okstra_ctl/application/dispatch_assignments.py

@@ -0,0 +1,15 @@
+"""Route one normalized worker-dispatch request through its host port."""
+from __future__ import annotations
+
+from ..ports.worker_dispatch import (
+    WorkerDispatchPlan,
+    WorkerDispatchPort,
+    WorkerDispatchRequest,
+)
+
+
+def dispatch_assignments(
+    request: WorkerDispatchRequest,
+    port: WorkerDispatchPort,
+) -> WorkerDispatchPlan:
+    return port.build_plan(request)

package/runtime/python/okstra_ctl/application/resolve_assignment.py

@@ -0,0 +1,93 @@
+"""Resolve provider assignments from host and provider capabilities."""
+from __future__ import annotations
+
+from okstra_ctl.domain.host import (
+    HostCapabilityMismatch,
+    HostDescriptor,
+    ProviderUnavailable,
+)
+from okstra_ctl.domain.provider import (
+    LeadProviderAssignment,
+    ProviderSpec,
+    RunnerResolution,
+)
+
+
+NATIVE_SESSION = "native-session"
+CLI_WRAPPER = "cli-wrapper"
+RUNNER_VALUES = frozenset({NATIVE_SESSION, CLI_WRAPPER})
+
+
+def resolve_assignment_runner(
+    *,
+    host: HostDescriptor,
+    provider: ProviderSpec,
+    role: str,
+    requested_runner: str = "",
+) -> RunnerResolution:
+    if role not in provider.supported_roles:
+        raise ProviderUnavailable(
+            f"provider {provider.provider!r} does not support role {role!r}"
+        )
+    requested = (requested_runner or "").strip()
+    if requested and requested not in RUNNER_VALUES:
+        allowed = ", ".join(sorted(RUNNER_VALUES))
+        raise HostCapabilityMismatch(
+            f"unknown runner {requested!r}. Allowed values: {allowed}"
+        )
+    is_native = provider.provider == host.native_provider_id
+    if requested == NATIVE_SESSION and not is_native:
+        raise HostCapabilityMismatch(
+            f"host {host.id!r} does not provide native "
+            f"{provider.provider!r} execution"
+        )
+    if requested == NATIVE_SESSION or (not requested and is_native):
+        return RunnerResolution(
+            NATIVE_SESSION,
+            "",
+            f"{host.id} provides native {provider.provider} execution",
+        )
+    if not provider.wrapper:
+        raise ProviderUnavailable(
+            f"provider {provider.provider!r} has no CLI wrapper for role {role!r}"
+        )
+    return RunnerResolution(
+        CLI_WRAPPER,
+        provider.wrapper,
+        f"{host.id} uses the registered {provider.provider} CLI wrapper",
+    )
+
+
+def resolve_lead_provider(
+    *,
+    host_id: str,
+    requested_provider: str,
+    host_registry,
+    provider_registry,
+) -> LeadProviderAssignment:
+    host = host_registry.resolve(host_id).descriptor
+    requested = (requested_provider or "").strip().lower()
+    if not requested and not host.native_provider_id:
+        raise HostCapabilityMismatch(
+            f"host {host.id!r} has no native lead provider; select an explicit "
+            "provider with lead capability"
+        )
+    if host.native_provider_id and requested not in {"", host.native_provider_id}:
+        raise HostCapabilityMismatch(
+            f"{host.agent_label.removesuffix(' CLI')} host requires provider "
+            f"{host.native_provider_id!r} for the in-session lead; provider "
+            f"{requested!r} must be selected as a worker instead"
+        )
+    provider_id = requested or host.native_provider_id
+    provider = provider_registry.resolve(provider_id)
+    resolution = resolve_assignment_runner(
+        host=host,
+        provider=provider,
+        role="lead",
+    )
+    return LeadProviderAssignment(
+        provider=provider.provider,
+        runner=resolution.runner,
+        wrapper=resolution.wrapper,
+        reason=resolution.reason,
+    )

package/runtime/python/okstra_ctl/application/resume_run.py

@@ -0,0 +1,21 @@
+"""Prepare a lead resume plan through a ready host adapter."""
+from __future__ import annotations
+
+from okstra_ctl.domain.host import (
+    HostSessionContext,
+    HostUnavailable,
+    LeadResumeRequest,
+    LeadSessionPlan,
+)
+from okstra_ctl.ports import HostAdapter
+
+
+def resume_run(
+    request: LeadResumeRequest,
+    context: HostSessionContext,
+    adapter: HostAdapter,
+) -> LeadSessionPlan:
+    readiness = adapter.probe(context)
+    if not readiness.ok:
+        raise HostUnavailable(readiness.reason)
+    return adapter.lead_session().build_resume(request, context)

package/runtime/python/okstra_ctl/application/start_run.py

@@ -0,0 +1,21 @@
+"""Prepare a lead start plan through a ready host adapter."""
+from __future__ import annotations
+
+from okstra_ctl.domain.host import (
+    HostSessionContext,
+    HostUnavailable,
+    LeadSessionPlan,
+    LeadStartRequest,
+)
+from okstra_ctl.ports import HostAdapter
+
+
+def start_run(
+    request: LeadStartRequest,
+    context: HostSessionContext,
+    adapter: HostAdapter,
+) -> LeadSessionPlan:
+    readiness = adapter.probe(context)
+    if not readiness.ok:
+        raise HostUnavailable(readiness.reason)
+    return adapter.lead_session().build_start(request, context)