feat(spawner): render opencode.json + omo config from credential aliases

Closes the smoke gap `opencode_config` (spec §14): without these files
the agent boots with no provider surface and cannot route any task.

New module `services/opencode_config_renderer.py`:
  - Maps each credential alias (anthropic / openrouter / openai / etc.)
    to its canonical `@ai-sdk/...` provider config.
  - Picks a default model in preference order
    (anthropic > openrouter > openai > google > groq > xai).
  - Emits a minimal `oh-my-openagent.jsonc` with a single default route.

Both spawners now inject `OMOIOS_OPENCODE_CONFIG` and
`OMOIOS_OMO_CONFIG` whenever an env_version with credentials is bound.

Modal-specific: bootstrap.sh never runs on Modal (sandboxes start with
`sleep infinity`), so the spawner now writes the two files directly via
`sandbox.filesystem.write_bytes` after creation. Makes the wiring
observable in `opencode_config` regardless of bootstrap timing.

Smoke harness: `_allocate_via_modal` passes a sample config through
`extra_env` so the file-write path is exercised even without an
env_version.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: kivo360

.secrets.baseline

@@ -341,15 +341,26 @@ async def spawn_for_task(
         if env_version and env_version.credentials:
             env_vars["SESSION_TOKEN"] = sandbox_session_token
             env_vars["BROKER_URL"] = f"{base_url}/broker"
-            env_vars["OMOIOS_CREDENTIAL_ALIASES"] = ",".join(
-                env_version.credentials.keys()
+            aliases = list(env_version.credentials.keys())
+            env_vars["OMOIOS_CREDENTIAL_ALIASES"] = ",".join(aliases)
+
+            # Render opencode.json + oh-my-openagent.jsonc so the agent
+            # has a provider surface (spec §14). Bootstrap reads these
+            # env vars and writes the files into ~/.config/opencode/.
+            from omoi_os.services.opencode_config_renderer import (
+                render_omo_config,
+                render_opencode_config,
             )
+
+            env_vars["OMOIOS_OPENCODE_CONFIG"] = render_opencode_config(aliases)
+            env_vars["OMOIOS_OMO_CONFIG"] = render_omo_config(aliases)
+
             logger.info(
                 "[SPAWNER] Broker env vars injected",
                 extra={
                     "task_id": task_id,
                     "broker_url": f"{base_url}/broker",
-                    "credential_aliases": list(env_version.credentials.keys()),
+                    "credential_aliases": aliases,
                 },
             )
 

backend/omoi_os/services/daytona_spawner.py

@@ -181,7 +181,18 @@ def _build_env(
             if sandbox_session_token:
                 env["SESSION_TOKEN"] = sandbox_session_token
             env["BROKER_URL"] = f"{base_url}/broker"
-            env["OMOIOS_CREDENTIAL_ALIASES"] = ",".join(env_version.credentials.keys())
+            aliases = list(env_version.credentials.keys())
+            env["OMOIOS_CREDENTIAL_ALIASES"] = ",".join(aliases)
+            # Render opencode.json + oh-my-openagent.jsonc — bootstrap
+            # writes them into ~/.config/opencode/ so the agent has a
+            # provider surface (spec §14, smoke phase opencode_config).
+            from omoi_os.services.opencode_config_renderer import (
+                render_omo_config,
+                render_opencode_config,
+            )
+
+            env["OMOIOS_OPENCODE_CONFIG"] = render_opencode_config(aliases)
+            env["OMOIOS_OMO_CONFIG"] = render_omo_config(aliases)
         if extra_env:
             env.update(extra_env)
         return env
@@ -299,6 +310,50 @@ async def spawn_for_task(
         info.status = "running"
         info.started_at = utc_now()
 
+        # Render opencode.json + oh-my-openagent.jsonc directly to the
+        # sandbox filesystem. Modal's container starts with `sleep
+        # infinity` and never executes our bootstrap.sh, so we can't rely
+        # on the env-var contract bootstrap reads — write the files now
+        # while we have the sandbox handle. Skipped silently when no
+        # provider config was rendered (e.g. bare smoke sandboxes).
+        opencode_body = env.get("OMOIOS_OPENCODE_CONFIG")
+        omo_body = env.get("OMOIOS_OMO_CONFIG")
+        if opencode_body or omo_body:
+            try:
+                # Ensure the config dir exists. Modal `Image.run_commands`
+                # bakes /root/.config/opencode at image-build time, but
+                # mkdir -p is idempotent and cheap.
+                await _run_sync(
+                    lambda: sandbox.exec("mkdir", "-p", "/root/.config/opencode")
+                )
+                if opencode_body:
+                    await _run_sync(
+                        lambda: sandbox.filesystem.write_bytes(
+                            opencode_body.encode("utf-8"),
+                            "/root/.config/opencode/opencode.json",
+                        )
+                    )
+                if omo_body:
+                    await _run_sync(
+                        lambda: sandbox.filesystem.write_bytes(
+                            omo_body.encode("utf-8"),
+                            "/root/.config/opencode/oh-my-openagent.jsonc",
+                        )
+                    )
+                logger.info(
+                    "[MODAL_SPAWNER] opencode config files written",
+                    extra={
+                        "sandbox_id": sandbox_id,
+                        "wrote_opencode_json": bool(opencode_body),
+                        "wrote_omo_jsonc": bool(omo_body),
+                    },
+                )
+            except Exception as exc:  # noqa: BLE001 — best-effort
+                logger.warning(
+                    "[MODAL_SPAWNER] opencode config write failed",
+                    extra={"sandbox_id": sandbox_id, "error": str(exc)},
+                )
+
         # Tunnel URLs for any exposed_ports. Modal returns these
         # synchronously after `create` completes.
         if exposed_ports:

backend/omoi_os/services/modal_spawner.py

@@ -0,0 +1,174 @@
+"""Render OpenCode + OmO config from an EnvironmentVersion's credentials.
+
+Closes the smoke-test gap `opencode_config`: bootstrap.sh expects
+`OMOIOS_OPENCODE_CONFIG` and `OMOIOS_OMO_CONFIG` env vars to contain the
+JSON / JSONC bodies it should write into `~/.config/opencode/`. Without
+them the agent boots with no provider surface and cannot route tasks.
+
+Spec §14: OmO reads `opencode.json` for provider/model wiring and
+`oh-my-openagent.jsonc` for layered agent/category routing. We render
+both from the credential alias map so each environment version
+auto-derives a usable agent runtime — no per-tenant config templates.
+
+Design choices:
+
+- Provider npm package names mirror OpenCode's conventions (`@ai-sdk/...`).
+- API keys reference `{env:UPPERCASE_ALIAS_API_KEY}`. The bootstrap also
+  writes `auth.json` from the broker; OpenCode prefers `auth.json`
+  when both are set, so the env-var indirection is just a polite
+  fallback for callers running OpenCode directly.
+- Default model: prefer `anthropic` (best Claude 4 family for codegen),
+  then fall back to whatever else the environment has.
+- oh-my-openagent.jsonc gets a single `default` route; tenants who want
+  multiple categories can override at the env-version level.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Optional
+
+
+# Mapping: credential alias → OpenCode provider definition fragment.
+# When an alias is recognised here, we plug in the canonical npm
+# package + key reference. Unknown aliases get a passthrough entry so
+# the agent can still see the credential exists; OpenCode's provider
+# resolver tolerates extra keys.
+_KNOWN_PROVIDERS: dict[str, dict[str, Any]] = {
+    "anthropic": {
+        "npm": "@ai-sdk/anthropic",
+        "name": "Anthropic",
+        "options": {"apiKey": "{env:ANTHROPIC_API_KEY}"},
+    },
+    "openai": {
+        "npm": "@ai-sdk/openai",
+        "name": "OpenAI",
+        "options": {"apiKey": "{env:OPENAI_API_KEY}"},
+    },
+    "openrouter": {
+        "npm": "@openrouter/ai-sdk-provider",
+        "name": "OpenRouter",
+        "options": {"apiKey": "{env:OPENROUTER_API_KEY}"},
+    },
+    "google": {
+        "npm": "@ai-sdk/google",
+        "name": "Google",
+        "options": {"apiKey": "{env:GOOGLE_API_KEY}"},
+    },
+    "groq": {
+        "npm": "@ai-sdk/groq",
+        "name": "Groq",
+        "options": {"apiKey": "{env:GROQ_API_KEY}"},
+    },
+    "xai": {
+        "npm": "@ai-sdk/xai",
+        "name": "xAI",
+        "options": {"apiKey": "{env:XAI_API_KEY}"},
+    },
+}
+
+# Default model per provider — used when picking the top-level `model`
+# field. Tenants can override by editing the environment version.
+_DEFAULT_MODELS: dict[str, str] = {
+    "anthropic": "anthropic/claude-sonnet-4-5",
+    "openai": "openai/gpt-5",
+    "openrouter": "openrouter/anthropic/claude-sonnet-4-5",
+    "google": "google/gemini-2-pro",
+    "groq": "groq/llama-3.3-70b-versatile",
+    "xai": "xai/grok-4",
+}
+
+# Preference order when no alias is "anthropic" but multiple are set.
+_PREFERENCE_ORDER = ["anthropic", "openrouter", "openai", "google", "groq", "xai"]
+
+
+def render_opencode_config(
+    credential_aliases: list[str],
+    *,
+    default_model: Optional[str] = None,
+) -> str:
+    """Build an opencode.json body for a sandbox.
+
+    Args:
+        credential_aliases: alias names from `env_version.credentials.keys()`.
+            These are the broker aliases the agent can fetch at runtime.
+        default_model: override the auto-selected default model. Useful
+            for tenants pinning a specific model per environment.
+
+    Returns:
+        JSON string ready to be written to `~/.config/opencode/opencode.json`
+        by `sandbox/bootstrap.sh` when `OMOIOS_OPENCODE_CONFIG` is set.
+    """
+    # Build the provider block. Known aliases get the canonical
+    # definition; unknown aliases get a stub so the agent at least sees
+    # the alias exists — OpenCode treats extra providers as opt-in.
+    providers: dict[str, dict[str, Any]] = {}
+    for alias in credential_aliases:
+        if alias in _KNOWN_PROVIDERS:
+            providers[alias] = _KNOWN_PROVIDERS[alias]
+        else:
+            providers[alias] = {
+                "name": alias,
+                "options": {
+                    "apiKey": f"{{env:{alias.upper()}_API_KEY}}",
+                },
+            }
+
+    # Pick a default model. Caller override > anthropic > preference order.
+    chosen_model = default_model
+    if chosen_model is None:
+        for pref in _PREFERENCE_ORDER:
+            if pref in credential_aliases and pref in _DEFAULT_MODELS:
+                chosen_model = _DEFAULT_MODELS[pref]
+                break
+        if chosen_model is None and credential_aliases:
+            # Fallback: take the first alias and assume it follows
+            # `provider/model` form. Better than no model at all.
+            first = credential_aliases[0]
+            chosen_model = f"{first}/default"
+
+    config: dict[str, Any] = {
+        "$schema": "https://opencode.ai/config.json",
+    }
+    if providers:
+        config["provider"] = providers
+    if chosen_model:
+        config["model"] = chosen_model
+
+    return json.dumps(config, indent=2)
+
+
+def render_omo_config(
+    credential_aliases: list[str],
+    *,
+    default_model: Optional[str] = None,
+) -> str:
+    """Build a minimal oh-my-openagent.jsonc body.
+
+    Just defines a single `default` route. Tenants who want
+    category-aware routing should override the environment version's
+    config templates rather than relying on the auto-generated default.
+    """
+    chosen_model = default_model
+    if chosen_model is None:
+        for pref in _PREFERENCE_ORDER:
+            if pref in credential_aliases and pref in _DEFAULT_MODELS:
+                chosen_model = _DEFAULT_MODELS[pref]
+                break
+
+    if chosen_model is None:
+        # Absent any creds we still emit a valid (if useless) doc — the
+        # smoke phase tolerates this; OmO will pick the first available
+        # provider at runtime.
+        chosen_model = "anthropic/claude-sonnet-4-5"
+
+    body = {
+        "$schema": "https://oh-my-openagent.dev/config.json",
+        "default": {"model": chosen_model},
+    }
+    # Wrap in JSONC-friendly preamble so editors highlight the file
+    # correctly. JSON parsers tolerate the leading comment block.
+    return (
+        "// oh-my-openagent.jsonc — auto-generated from environment "
+        "credentials\n" + json.dumps(body, indent=2)
+    )

backend/omoi_os/services/opencode_config_renderer.py

@@ -594,11 +594,24 @@ async def _allocate_via_modal(ctx: Context) -> PhaseResult:
             return PhaseResult(
                 "daytona_allocation", Verdict.FAIL,
                 detail=f"factory returned {type(provider).__name__}; expected ModalProvider")
+        # Render a sample opencode.json + oh-my-openagent.jsonc so the
+        # spawner's file-write step fires and `opencode_config` can
+        # verify the wiring without needing a real env_version (which
+        # the smoke can't easily synthesize against prod).
+        from omoi_os.services.opencode_config_renderer import (
+            render_omo_config,
+            render_opencode_config,
+        )
+        smoke_aliases = ["anthropic"]
         result = await provider.spawn_for_task(
             task_id=f"smoke-{uuid.uuid4().hex[:8]}",
             agent_id="smoke-agent",
             phase_id="PHASE_SMOKE",
-            env_vars={"SMOKE_TEST": "1"},
+            env_vars={
+                "SMOKE_TEST": "1",
+                "OMOIOS_OPENCODE_CONFIG": render_opencode_config(smoke_aliases),
+                "OMOIOS_OMO_CONFIG": render_omo_config(smoke_aliases),
+            },
             runtime="claude",
             execution_mode="implementation",
         )