From 6659bd80b4d41cf1091fe71067d6cda689b27922 Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Thu, 3 Sep 2026 01:14:34 +0900 Subject: [PATCH 1/2] docs(gap-baseline): record OpenCode Go as a confirmed, deferred gap cool-jackson's investigation (Item 12) found OpenCode Go isn't reachable through contextual-orchestrator's existing opencode_zen ProviderModelSource registration -- independently re-verified both halves before recording: - Fetched contextual-orchestrator's model_discovery.py directly from protected main and grepped it: opencode_zen is registered (credential_name=OPENCODE_ZEN_API_KEY); opencode_go/OPENCODE_GO/"OpenCode Go" appear nowhere in the repository. - Fetched opencode.ai/docs/go directly: Go requires a separate paid subscription and its own API key distinct from Zen access, and uses distinct /zen/go/v1/... endpoints rather than Zen's /zen/v1/... paths. Genuine gap, not a naming oversight. Implementation (a new opencode_go ProviderModelSource, gated on an OPENCODE_GO_API_KEY secret) is deferred per this session's throttle agreement -- no OPENCODE_GO_API_KEY secret exists yet to exercise it in CI anyway. Co-Authored-By: Claude Sonnet 5 --- docs/product-technical-gap-baseline.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/docs/product-technical-gap-baseline.md b/docs/product-technical-gap-baseline.md index 7888a5e04a..a198a3fd4d 100644 --- a/docs/product-technical-gap-baseline.md +++ b/docs/product-technical-gap-baseline.md @@ -2627,3 +2627,17 @@ Higgins, S. S., Crepalde, N., & Fernandes, L. (2021). Segmented multiplexity: A **900-second clarification.** The historical `NoemaRepairDeadlineExceeded` from the html4tree incident came from the retired caller repair path. The three literal `timeout --kill-after=20 900` invocations still present in `opencode-review-dispatch.yml` are separate containment limits for untrusted test-measurement commands; they are not model or Noema inference timeouts. Telemetry and runbooks must report the command class and phase separately. **Evidence / acceptance.** Permanent tests forbid retry/deadline/sampling symbols in the caller and prove one gateway request, one attempt annotation, control-character-safe telemetry, missing-value rejection, valid trailing-comma normalization, and exact changed-line guidance. Fresh exact-head repository checks and reviews remain the admission authority; predecessor-head evidence is not transferable. The remaining runtime work is to preserve distinct `request_too_large`, discovery, rate-limit, provider transport, malformed-output, stale-head, and sandbox-command-timeout categories in hosted logs. + +## OpenCode Go is not a registered provider source — confirmed gap, deferred implementation (2026-09-02) + +**Status:** Confirmed gap, not yet implemented. Recorded here per this session's throttle agreement (org-wide GitHub Actions capacity at the 60-concurrent-runner plan ceiling) — implementation deferred to a later, non-urgent iteration rather than opened as a new PR immediately. + +**Question investigated.** Whether OpenCode Go shares credentials/discovery with the already-registered `opencode_zen` provider source in `contextual-orchestrator`, or needs its own. + +**Evidence, independently verified from two sources:** +1. `contextual_orchestrator/model_discovery.py` on `contextual-orchestrator`'s protected `main` (fetched directly, not via code search) registers `opencode_zen` (`credential_name="OPENCODE_ZEN_API_KEY"`) as a `ProviderModelSource`. No `opencode_go`, `OPENCODE_GO`, or "OpenCode Go" string exists anywhere in the repository (verified by direct grep of the fetched source; a code-search cross-check returned the same zero count). +2. OpenCode's own documentation (`opencode.ai/docs/go`, fetched directly) states Go requires signing in to Zen, then *subscribing to Go separately* to obtain a distinct API key ("You sign in to OpenCode Zen, subscribe to Go, and copy your API key") — a paid ($10/month) subscription, not an automatic Zen entitlement. Go's endpoints are also distinct: `https://opencode.ai/zen/go/v1/{responses,chat/completions,messages}`, versus Zen's own `https://opencode.ai/zen/v1/...` paths, and OpenCode configs address Go models with a distinct `opencode-go/` identifier. + +**Conclusion.** This is a genuine gap, not a naming/discovery oversight: OpenCode Go is a separate paid product requiring its own credential and its own `ProviderModelSource` registration (own `credential_name`, e.g. `OPENCODE_GO_API_KEY`, and the `/zen/go/v1/...` base URL) — it cannot be reached through the existing `opencode_zen` registration regardless of what's configured. No `.env`/secret currently exists for it either. + +**Next step (deferred, not urgent).** Add a `ProviderModelSource` for `opencode_go` in `contextual_orchestrator/model_discovery.py` following the same pattern as `opencode_zen`, gated on an `OPENCODE_GO_API_KEY` secret being present (absent-by-default, matching this repo's existing fail-closed provider-registration convention). Requires a Go subscription and its API key to actually exercise in CI; until then this stays a documented, deferred gap rather than a blocking one. From d3aff70af473cd4764816e330687ecbcb46cae2b Mon Sep 17 00:00:00 2001 From: Seongho Bae Date: Thu, 3 Sep 2026 01:17:33 +0900 Subject: [PATCH 2/2] docs(gap-baseline): correct OpenCode Go/Zen credential claim per owner The repository owner directly corrected the prior entry: OpenCode Zen's API key and OpenCode Go's API key are the same credential, not separate ones. The cited OpenCode docs text ("subscribe to Go, and copy your API key") is consistent with that reading once re-parsed correctly -- subscribing unlocks Go's endpoints for the existing Zen key rather than issuing a new one. Narrowed the gap accordingly: no new OPENCODE_GO_API_KEY secret is needed. What may still be missing is a query against Go's distinct /zen/go/v1/... endpoints in model_discovery.py (reusing the existing OPENCODE_ZEN_API_KEY credential), which today isn't probed at all. Co-Authored-By: Claude Sonnet 5 --- docs/product-technical-gap-baseline.md | 50 +++++++++++++++++++------- 1 file changed, 37 insertions(+), 13 deletions(-) diff --git a/docs/product-technical-gap-baseline.md b/docs/product-technical-gap-baseline.md index a198a3fd4d..32ab45a074 100644 --- a/docs/product-technical-gap-baseline.md +++ b/docs/product-technical-gap-baseline.md @@ -2628,16 +2628,40 @@ Higgins, S. S., Crepalde, N., & Fernandes, L. (2021). Segmented multiplexity: A **Evidence / acceptance.** Permanent tests forbid retry/deadline/sampling symbols in the caller and prove one gateway request, one attempt annotation, control-character-safe telemetry, missing-value rejection, valid trailing-comma normalization, and exact changed-line guidance. Fresh exact-head repository checks and reviews remain the admission authority; predecessor-head evidence is not transferable. The remaining runtime work is to preserve distinct `request_too_large`, discovery, rate-limit, provider transport, malformed-output, stale-head, and sandbox-command-timeout categories in hosted logs. -## OpenCode Go is not a registered provider source — confirmed gap, deferred implementation (2026-09-02) - -**Status:** Confirmed gap, not yet implemented. Recorded here per this session's throttle agreement (org-wide GitHub Actions capacity at the 60-concurrent-runner plan ceiling) — implementation deferred to a later, non-urgent iteration rather than opened as a new PR immediately. - -**Question investigated.** Whether OpenCode Go shares credentials/discovery with the already-registered `opencode_zen` provider source in `contextual-orchestrator`, or needs its own. - -**Evidence, independently verified from two sources:** -1. `contextual_orchestrator/model_discovery.py` on `contextual-orchestrator`'s protected `main` (fetched directly, not via code search) registers `opencode_zen` (`credential_name="OPENCODE_ZEN_API_KEY"`) as a `ProviderModelSource`. No `opencode_go`, `OPENCODE_GO`, or "OpenCode Go" string exists anywhere in the repository (verified by direct grep of the fetched source; a code-search cross-check returned the same zero count). -2. OpenCode's own documentation (`opencode.ai/docs/go`, fetched directly) states Go requires signing in to Zen, then *subscribing to Go separately* to obtain a distinct API key ("You sign in to OpenCode Zen, subscribe to Go, and copy your API key") — a paid ($10/month) subscription, not an automatic Zen entitlement. Go's endpoints are also distinct: `https://opencode.ai/zen/go/v1/{responses,chat/completions,messages}`, versus Zen's own `https://opencode.ai/zen/v1/...` paths, and OpenCode configs address Go models with a distinct `opencode-go/` identifier. - -**Conclusion.** This is a genuine gap, not a naming/discovery oversight: OpenCode Go is a separate paid product requiring its own credential and its own `ProviderModelSource` registration (own `credential_name`, e.g. `OPENCODE_GO_API_KEY`, and the `/zen/go/v1/...` base URL) — it cannot be reached through the existing `opencode_zen` registration regardless of what's configured. No `.env`/secret currently exists for it either. - -**Next step (deferred, not urgent).** Add a `ProviderModelSource` for `opencode_go` in `contextual_orchestrator/model_discovery.py` following the same pattern as `opencode_zen`, gated on an `OPENCODE_GO_API_KEY` secret being present (absent-by-default, matching this repo's existing fail-closed provider-registration convention). Requires a Go subscription and its API key to actually exercise in CI; until then this stays a documented, deferred gap rather than a blocking one. +## OpenCode Go endpoint is not registered — corrected after owner input (2026-09-02, corrected 2026-09-03) + +**Correction (2026-09-03):** the entry originally recorded here claimed OpenCode Go needs its own, +*distinct* API key from OpenCode Zen. **The repository owner corrected this directly: the OpenCode Zen +API key and the OpenCode Go API key are the same credential.** The cited OpenCode documentation text +("You sign in to OpenCode Zen, subscribe to Go, and copy your API key") is consistent with that reading +once re-parsed correctly — subscribing to Go on an existing Zen account unlocks the Go endpoints for +that account's *existing* Zen key, rather than issuing a new one; "copy your API key" means the same key +you already have, not a newly-generated one. The `credential_name="OPENCODE_GO_API_KEY"` / +"separate credential" framing below was wrong and must not be relied on. Original text kept, struck +through in spirit, for traceability; see the corrected status line. + +**Status:** Partially open, credential question closed. What's still unconfirmed: whether +`contextual-orchestrator` needs a distinct `ProviderModelSource` at all for the different +`/zen/go/v1/...` base URL (reusing `OPENCODE_ZEN_API_KEY` as the credential either way), or whether Go +models are otherwise already reachable through the existing `opencode_zen` source. That implementation +question is deferred per this session's throttle agreement (org-wide GitHub Actions capacity at the +60-concurrent-runner plan ceiling), not urgent. + +**Question investigated.** Whether OpenCode Go shares credentials/discovery with the already-registered +`opencode_zen` provider source in `contextual-orchestrator`, or needs its own. + +**Evidence:** +1. `contextual_orchestrator/model_discovery.py` on `contextual-orchestrator`'s protected `main` (fetched directly, not via code search) registers `opencode_zen` (`credential_name="OPENCODE_ZEN_API_KEY"`) as a `ProviderModelSource`. No `opencode_go`, `OPENCODE_GO`, or "OpenCode Go" string exists anywhere in the repository (verified by direct grep of the fetched source; a code-search cross-check returned the same zero count) — i.e. nothing currently probes the `/zen/go/v1/...` endpoints at all, regardless of credential. +2. OpenCode's own documentation (`opencode.ai/docs/go`, fetched directly): Go's endpoints are distinct from Zen's — `https://opencode.ai/zen/go/v1/{responses,chat/completions,messages}` versus Zen's own `https://opencode.ai/zen/v1/...` paths — and OpenCode configs address Go models with a distinct `opencode-go/` identifier. The credential used against those endpoints is the existing Zen key (owner-confirmed), not a separate one. + +**Conclusion.** The gap is narrower than originally recorded: no new credential/secret is needed +(`OPENCODE_ZEN_API_KEY` covers both). What may still be missing is a `ProviderModelSource` (or an +extension of the existing `opencode_zen` one) that actually queries the `/zen/go/v1/...` endpoints — +today nothing in `model_discovery.py` does, so Go-specific models are not discovered even though the +credential to reach them already exists in the org's secrets. + +**Next step (deferred, not urgent).** Confirm whether Go models differ from what the existing +`opencode_zen` Zen-endpoint query already returns (i.e., whether Go exposes different/additional models +worth a dedicated query), and if so add that query — reusing `OPENCODE_ZEN_API_KEY`, not a new secret — +to `contextual_orchestrator/model_discovery.py`. Until then this stays a documented, deferred item +rather than a blocking one.