feat: advertise session capabilities, implement cancel and set_mode #11

Merged
sam merged 3 commits from feat/acp-session-capabilities into main 2026-09-24 21:30:20 +00:00
Collaborator

Summary

Fixes Paseo's ACP import listing and completes the session command surface.

1. Advertise session/list, session/close, session/resume (fixes import listing)

Initialize previously advertised only loadSession: true. Paseo (and any spec-compliant ACP client) gates its session/list, session/close, and session/resume calls on the sessionCapabilities flags, so brainless's handlers for those commands were dead code in the Paseo flow:

  • session/list — Paseo returns [] without calling it (acp-agent.ts:1161), so the session-import listing showed nothing.
  • session/close — Paseo skips the close-cleanup call (acp-agent.ts:1275).
  • session/resume — Paseo prefers session/load when loadSession is advertised, but other clients gate on sessionCapabilities.resume; advertising it makes the implemented handler reachable.

Initialize now advertises sessionCapabilities: {list, close, resume} alongside loadSession: true. The handlers were already correct — this is purely advertisement.

2. Implement session/cancel

The acp-go-sdk transport already cancels the in-flight prompt's context when session/cancel arrives, then dispatches to Agent.Cancel. Prompt now observes the canceled context and settles the turn with stopReason: "cancelled" instead of returning a JSON-RPC error — Paseo renders that as "turn canceled" (Interrupted) rather than "turn failed". Cancel remains a no-op by design; the cancellation is transport-handled.

Note: the ADK runner stops waiting on cancellation but does not abort the underlying in-flight model HTTP call (ADK v2.4.0 behavior). It is bounded by process lifetime — Paseo tree-kills the agent on close. Documented in Prompt.

3. Implement session/set_mode

The harness now advertises three modes — fast, normal, deep — in the modes field of session/new, session/load, and session/resume responses (Paseo's deriveModesFromACP reads this and shows a mode switcher). A mode is a preset over the thinking selector, applied to the active model:

  • fast → reasoning off
  • normal → the model's default effort
  • deep → the model's maximum declared effort

SetSessionMode validates the mode id (unknown modes are rejected), applies it, and persists it in the selection so it survives load/resume. Switching models falls back to normal mode when the new model cannot honor the current level, so the advertised currentModeId never lies.

Tests

  • TestACPInitializeAdvertisesSessionCapabilities — initialize advertises loadSession + list/close/resume.
  • TestACPCancelStopsInflightPrompt — session/cancel settles an in-flight prompt (against a blocking model server) with stopReason: cancelled and no error.
  • TestACPSetModeChangesThinking — modes are advertised in lifecycle responses; deep/fast/normal change the reasoning effort on the wire (high/none/low for a [low, high] model); unknown modes are rejected.
  • TestACPSessionListReturnsPersistedSessions — session/list returns persisted sessions and session/close accepts the listed id.

Verification

  • go build ./..., go vet ./..., gofmt, golangci-lint run (0 issues), go test ./... and racedetector test ./... all pass.

Deployment note

This changes brainless itself. The paseo image bakes a compiled brainless binary (pi-deploy PR #37), so after merge the binary must be rebuilt and the paseo image refreshed (docker compose build paseo && docker compose up -d paseo) to pick this up.

## Summary Fixes Paseo's ACP import listing and completes the session command surface. ### 1. Advertise `session/list`, `session/close`, `session/resume` (fixes import listing) `Initialize` previously advertised only `loadSession: true`. Paseo (and any spec-compliant ACP client) gates its `session/list`, `session/close`, and `session/resume` calls on the `sessionCapabilities` flags, so brainless's handlers for those commands were dead code in the Paseo flow: - **`session/list`** — Paseo returns `[]` without calling it (`acp-agent.ts:1161`), so the session-import listing showed nothing. - **`session/close`** — Paseo skips the close-cleanup call (`acp-agent.ts:1275`). - **`session/resume`** — Paseo prefers `session/load` when `loadSession` is advertised, but other clients gate on `sessionCapabilities.resume`; advertising it makes the implemented handler reachable. `Initialize` now advertises `sessionCapabilities: {list, close, resume}` alongside `loadSession: true`. The handlers were already correct — this is purely advertisement. ### 2. Implement `session/cancel` The acp-go-sdk transport already cancels the in-flight prompt's context when `session/cancel` arrives, then dispatches to `Agent.Cancel`. `Prompt` now observes the canceled context and settles the turn with `stopReason: "cancelled"` instead of returning a JSON-RPC error — Paseo renders that as "turn canceled" (Interrupted) rather than "turn failed". `Cancel` remains a no-op by design; the cancellation is transport-handled. Note: the ADK runner stops waiting on cancellation but does not abort the underlying in-flight model HTTP call (ADK v2.4.0 behavior). It is bounded by process lifetime — Paseo tree-kills the agent on close. Documented in `Prompt`. ### 3. Implement `session/set_mode` The harness now advertises three modes — `fast`, `normal`, `deep` — in the `modes` field of `session/new`, `session/load`, and `session/resume` responses (Paseo's `deriveModesFromACP` reads this and shows a mode switcher). A mode is a preset over the thinking selector, applied to the active model: - `fast` → reasoning off - `normal` → the model's default effort - `deep` → the model's maximum declared effort `SetSessionMode` validates the mode id (unknown modes are rejected), applies it, and persists it in the selection so it survives load/resume. Switching models falls back to `normal` mode when the new model cannot honor the current level, so the advertised `currentModeId` never lies. ## Tests - `TestACPInitializeAdvertisesSessionCapabilities` — initialize advertises `loadSession` + `list`/`close`/`resume`. - `TestACPCancelStopsInflightPrompt` — `session/cancel` settles an in-flight prompt (against a blocking model server) with `stopReason: cancelled` and no error. - `TestACPSetModeChangesThinking` — modes are advertised in lifecycle responses; `deep`/`fast`/`normal` change the reasoning effort on the wire (`high`/`none`/`low` for a `[low, high]` model); unknown modes are rejected. - `TestACPSessionListReturnsPersistedSessions` — `session/list` returns persisted sessions and `session/close` accepts the listed id. ## Verification - `go build ./...`, `go vet ./...`, `gofmt`, `golangci-lint run` (0 issues), `go test ./...` and `racedetector test ./...` all pass. ## Deployment note This changes brainless itself. The paseo image bakes a compiled brainless binary (pi-deploy PR #37), so after merge the binary must be rebuilt and the paseo image refreshed (`docker compose build paseo && docker compose up -d paseo`) to pick this up.
feat: advertise session capabilities, implement cancel and set_mode
All checks were successful
code-review / Agent review (pull_request) Successful in 8s
de543357df
Initialize now advertises sessionCapabilities.list/close/resume alongside
loadSession, so spec-compliant clients (Paseo) gate their session/list,
session/close, and session/resume calls on the flags instead of skipping
them: Paseo's import listing walks session/list, and close cleanup is
skipped without the close flag.

session/cancel settles an in-flight prompt with stopReason "cancelled"
instead of a JSON-RPC error. The SDK transport already cancels the
prompt's context before dispatching the notification; Prompt now observes
the canceled context and answers the turn, which Paseo renders as "turn
canceled" rather than "turn failed".

session/set_mode is implemented: the harness advertises three modes
(fast/normal/deep) as presets over the thinking selector and applies them
to the active model. Unknown modes are rejected, and switching models
falls back to normal mode when the new model cannot honor the current
level, so the advertised mode never lies.

Tests cover the advertised capabilities, session list + close, cancel of
an in-flight prompt against a blocking model server, and mode presets on
the wire.
pi-agent left a comment

High-signal review of the session-capabilities + cancel + set_mode PR. The advertisement fix (sessionCapabilities list/close/resume + loadSession), the cancel handling, and the test suite are solid — cancellation correctness is verified end-to-end against a blocking server, and the new mode tests cover the wire effect. Two IMPORTANT correctness gaps remain in the new mode state machine (the advertised currentModeId can diverge from the actual wire effort), plus one test-robustness suggestion. See inline comments.

High-signal review of the session-capabilities + cancel + set_mode PR. The advertisement fix (sessionCapabilities list/close/resume + loadSession), the cancel handling, and the test suite are solid — cancellation correctness is verified end-to-end against a blocking server, and the new mode tests cover the wire effect. Two IMPORTANT correctness gaps remain in the new mode state machine (the advertised currentModeId can diverge from the actual wire effort), plus one test-robustness suggestion. See inline comments.
@ -153,0 +174,4 @@
})
srv = httptest.NewServer(mux)
t.Cleanup(srv.Close)
Author
Collaborator

🟡 SUGGESTION — If any assertion in TestACPCancelStopsInflightPrompt fails before the trailing close(release) (e.g. the prompt does not settle within 10s), the handler stays blocked on releaseCh and t.Cleanup(srv.Close) (httptest.Server.Close blocks until outstanding requests finish) hangs the whole test run instead of reporting the failure — and since the ADK runner does not cancel the in-flight HTTP request context, req.Context().Done() will not unblock it. Fix: also register a cleanup that closes release, guarded by sync.Once so the trailing explicit close stays safe.

🟡 SUGGESTION — If any assertion in TestACPCancelStopsInflightPrompt fails before the trailing `close(release)` (e.g. the prompt does not settle within 10s), the handler stays blocked on `releaseCh` and `t.Cleanup(srv.Close)` (httptest.Server.Close blocks until outstanding requests finish) hangs the whole test run instead of reporting the failure — and since the ADK runner does not cancel the in-flight HTTP request context, `req.Context().Done()` will not unblock it. Fix: also register a cleanup that closes `release`, guarded by `sync.Once` so the trailing explicit close stays safe.
sam marked this conversation as resolved
@ -45,1 +118,4 @@
// Drop the thinking level when the new model does not declare it, and
// fall back to the normal mode so the advertised mode never lies about
// a level the model cannot honor.
if !h.reg.Reasoning(ref) || !slices.Contains(h.reg.ThinkingModes(ref), config.ReasoningEffort(thinking)) {
Author
Collaborator

🟠 IMPORTANT — When a mode is kept across a model switch, the code reuses the stale thinking from the old model instead of recomputing it for the new model. Concretely: with mode=deep and p/m1 (efforts [low, high]) the stored thinking becomes "high"; switching to a model whose declared max is higher (e.g. [low, high, max]) keeps thinking="high" (it is still in the new model's set, so the fallback does not trigger), so deep advertises "maximum declared effort" but sends "high" on the wire — the mode under-delivers relative to its contract. Condition: new model's max effort exceeds the previous model's max. Fix: when keeping the mode, recompute the level for the new model, e.g. in the else branch set thinking = modeThinking(mode, h.reg.ThinkingModes(ref)) before the set/setMode writes.

🟠 IMPORTANT — When a mode is kept across a model switch, the code reuses the stale `thinking` from the old model instead of recomputing it for the new model. Concretely: with mode=deep and p/m1 (efforts [low, high]) the stored thinking becomes "high"; switching to a model whose declared max is higher (e.g. [low, high, max]) keeps thinking="high" (it is still in the new model's set, so the fallback does not trigger), so `deep` advertises "maximum declared effort" but sends "high" on the wire — the mode under-delivers relative to its contract. Condition: new model's max effort exceeds the previous model's max. Fix: when keeping the mode, recompute the level for the new model, e.g. in the else branch set `thinking = modeThinking(mode, h.reg.ThinkingModes(ref))` before the `set`/`setMode` writes.
sam marked this conversation as resolved
Author
Collaborator

🟠 IMPORTANT — The configIDThinking branch writes the manual thinking level without reconciling mode, so the advertised currentModeId can lie (contradicting the PR's stated invariant). Example: set_mode deep on p/m2 sets mode=deep, thinking=high; the client then moves the thinking selector to "low" via this branch, which calls h.sel.set(ref, value) and leaves mode=deep untouched. The next NewSession/LoadSession/ResumeSession advertises currentModeId=deep while the wire sends effort=low, and a later model switch keeps the stale mode too. Fix: when a manual thinking override no longer equals the active mode's preset level, fall back to normal, e.g. after validation: mode := h.sel.modeSnap(); if modeThinking(mode, h.reg.ThinkingModes(ref)) != string(effort) { mode = modeNormal }; h.sel.set(ref, value); h.sel.setMode(mode, value).

🟠 IMPORTANT — The `configIDThinking` branch writes the manual thinking level without reconciling `mode`, so the advertised `currentModeId` can lie (contradicting the PR's stated invariant). Example: `set_mode deep` on p/m2 sets mode=deep, thinking=high; the client then moves the thinking selector to "low" via this branch, which calls `h.sel.set(ref, value)` and leaves mode=deep untouched. The next NewSession/LoadSession/ResumeSession advertises currentModeId=deep while the wire sends effort=low, and a later model switch keeps the stale mode too. Fix: when a manual thinking override no longer equals the active mode's preset level, fall back to normal, e.g. after validation: `mode := h.sel.modeSnap(); if modeThinking(mode, h.reg.ThinkingModes(ref)) != string(effort) { mode = modeNormal }; h.sel.set(ref, value); h.sel.setMode(mode, value)`.
sam marked this conversation as resolved
pi-agent left a comment

Reviewed. The session-capabilities advertisement, cancel handling, and test coverage are strong, but two IMPORTANT mode-state consistency issues should be fixed before merge: (1) a kept mode reuses the stale thinking level on model switch, so deep can under-deliver on a model with a higher max effort; (2) a manual thinking-selector override leaves mode untouched, so the advertised currentModeId can lie about the actual wire effort. Both are small reconciliations of the mode state. One SUGGESTION on test-hang robustness in the blocking-server helper. (Note: REQUEST_CHANGES was rejected by Forgejo because this review runs as the PR author pi-agent; posted as COMMENT with the same findings.)

Reviewed. The session-capabilities advertisement, cancel handling, and test coverage are strong, but two IMPORTANT mode-state consistency issues should be fixed before merge: (1) a kept mode reuses the stale thinking level on model switch, so `deep` can under-deliver on a model with a higher max effort; (2) a manual thinking-selector override leaves `mode` untouched, so the advertised `currentModeId` can lie about the actual wire effort. Both are small reconciliations of the mode state. One SUGGESTION on test-hang robustness in the blocking-server helper. (Note: REQUEST_CHANGES was rejected by Forgejo because this review runs as the PR author pi-agent; posted as COMMENT with the same findings.)
@ -153,0 +174,4 @@
})
srv = httptest.NewServer(mux)
t.Cleanup(srv.Close)
Author
Collaborator

🟡 SUGGESTION — If any assertion in TestACPCancelStopsInflightPrompt fails before the trailing close(release) (e.g. the prompt does not settle within 10s), the handler stays blocked on releaseCh and t.Cleanup(srv.Close) (httptest.Server.Close blocks until outstanding requests finish) hangs the whole test run instead of reporting the failure — and since the ADK runner does not cancel the in-flight HTTP request context, req.Context().Done() will not unblock it. Fix: also register a cleanup that closes release, guarded by sync.Once so the trailing explicit close stays safe.

🟡 SUGGESTION — If any assertion in TestACPCancelStopsInflightPrompt fails before the trailing `close(release)` (e.g. the prompt does not settle within 10s), the handler stays blocked on `releaseCh` and `t.Cleanup(srv.Close)` (httptest.Server.Close blocks until outstanding requests finish) hangs the whole test run instead of reporting the failure — and since the ADK runner does not cancel the in-flight HTTP request context, `req.Context().Done()` will not unblock it. Fix: also register a cleanup that closes `release`, guarded by `sync.Once` so the trailing explicit close stays safe.
sam marked this conversation as resolved
@ -45,1 +118,4 @@
// Drop the thinking level when the new model does not declare it, and
// fall back to the normal mode so the advertised mode never lies about
// a level the model cannot honor.
if !h.reg.Reasoning(ref) || !slices.Contains(h.reg.ThinkingModes(ref), config.ReasoningEffort(thinking)) {
Author
Collaborator

🟠 IMPORTANT — When a mode is kept across a model switch, the code reuses the stale thinking from the old model instead of recomputing it for the new model. Concretely: with mode=deep and p/m1 (efforts [low, high]) the stored thinking becomes "high"; switching to a model whose declared max is higher (e.g. [low, high, max]) keeps thinking="high" (it is still in the new model's set, so the fallback does not trigger), so deep advertises "maximum declared effort" but sends "high" on the wire — the mode under-delivers relative to its contract. Condition: new model's max effort exceeds the previous model's max. Fix: when keeping the mode, recompute the level for the new model, e.g. in the else branch set thinking = modeThinking(mode, h.reg.ThinkingModes(ref)) before the set/setMode writes.

🟠 IMPORTANT — When a mode is kept across a model switch, the code reuses the stale `thinking` from the old model instead of recomputing it for the new model. Concretely: with mode=deep and p/m1 (efforts [low, high]) the stored thinking becomes "high"; switching to a model whose declared max is higher (e.g. [low, high, max]) keeps thinking="high" (it is still in the new model's set, so the fallback does not trigger), so `deep` advertises "maximum declared effort" but sends "high" on the wire — the mode under-delivers relative to its contract. Condition: new model's max effort exceeds the previous model's max. Fix: when keeping the mode, recompute the level for the new model, e.g. in the else branch set `thinking = modeThinking(mode, h.reg.ThinkingModes(ref))` before the `set`/`setMode` writes.
sam marked this conversation as resolved
Author
Collaborator

🟠 IMPORTANT — The configIDThinking branch writes the manual thinking level without reconciling mode, so the advertised currentModeId can lie (contradicting the PR's stated invariant). Example: set_mode deep on p/m2 sets mode=deep, thinking=high; the client then moves the thinking selector to "low" via this branch, which calls h.sel.set(ref, value) and leaves mode=deep untouched. The next NewSession/LoadSession/ResumeSession advertises currentModeId=deep while the wire sends effort=low, and a later model switch keeps the stale mode too. Fix: when a manual thinking override no longer equals the active mode's preset level, fall back to normal, e.g. after validation: mode := h.sel.modeSnap(); if modeThinking(mode, h.reg.ThinkingModes(ref)) != string(effort) { mode = modeNormal }; h.sel.set(ref, value); h.sel.setMode(mode, value).

🟠 IMPORTANT — The `configIDThinking` branch writes the manual thinking level without reconciling `mode`, so the advertised `currentModeId` can lie (contradicting the PR's stated invariant). Example: `set_mode deep` on p/m2 sets mode=deep, thinking=high; the client then moves the thinking selector to "low" via this branch, which calls `h.sel.set(ref, value)` and leaves mode=deep untouched. The next NewSession/LoadSession/ResumeSession advertises currentModeId=deep while the wire sends effort=low, and a later model switch keeps the stale mode too. Fix: when a manual thinking override no longer equals the active mode's preset level, fall back to normal, e.g. after validation: `mode := h.sel.modeSnap(); if modeThinking(mode, h.reg.ThinkingModes(ref)) != string(effort) { mode = modeNormal }; h.sel.set(ref, value); h.sel.setMode(mode, value)`.
sam marked this conversation as resolved
Addresses the code-review findings on PR #11:

- Keeping a mode across a model switch now recomputes its thinking level
  for the new model, so deep means the new model's maximum effort rather
  than the old model's (previously deep on [low, high] left thinking pinned
  at high when switching to [low, high, max]).

- A manual thinking-selector override that diverges from the active mode's
  preset level now falls back to normal mode, so the advertised
  currentModeId never claims a mode whose effort is not sent on the wire.

- The blocking-server test helper returns a once-guarded release func and
  registers it as cleanup, so a test that fails before releasing cannot
  hang httptest.Server.Close on the still-blocked handler.

Tests cover both mode-reconciliation cases by inspecting the selection
directly (max and high clamp to the same genai level, so the wire cannot
tell them apart).
Author
Collaborator

All three review findings are addressed in commit 757345f (pushed to the branch):

  • 440 (IMPORTANT, mode kept across model switch): the model branch now recomputes the thinking level for the active mode on switch (if mode != modeNormal { thinking = modeThinking(mode, h.reg.ThinkingModes(ref)) }), so deep on a model with a higher declared max sends that max instead of the stale level from the old model.
  • 441 (IMPORTANT, manual thinking override vs mode): the thinking config-option branch now reconciles the mode — if the manual override diverges from the active mode's preset level, it falls back to normal, so the advertised currentModeId never claims an effort that isn't sent on the wire.
  • 442 (SUGGESTION, test-hang robustness): newBlockingResponsesServer now returns a sync.Once-guarded release func() and registers it as cleanup (LIFO, before srv.Close), so a test that fails before releasing can't hang httptest.Server.Close on the blocked handler.

Added TestModeReconcilesOnModelSwitchAndOverride, which inspects the selection directly — max and high clamp to the same genai thinking level, so the wire can't distinguish them. go test ./..., racedetector test ./..., and golangci-lint run (0 issues) all pass.

All three review findings are addressed in commit 757345f (pushed to the branch): - **440 (IMPORTANT, mode kept across model switch)**: the model branch now recomputes the thinking level for the active mode on switch (`if mode != modeNormal { thinking = modeThinking(mode, h.reg.ThinkingModes(ref)) }`), so `deep` on a model with a higher declared max sends that max instead of the stale level from the old model. - **441 (IMPORTANT, manual thinking override vs mode)**: the `thinking` config-option branch now reconciles the mode — if the manual override diverges from the active mode's preset level, it falls back to `normal`, so the advertised `currentModeId` never claims an effort that isn't sent on the wire. - **442 (SUGGESTION, test-hang robustness)**: `newBlockingResponsesServer` now returns a `sync.Once`-guarded `release func()` and registers it as cleanup (LIFO, before `srv.Close`), so a test that fails before releasing can't hang `httptest.Server.Close` on the blocked handler. Added `TestModeReconcilesOnModelSwitchAndOverride`, which inspects the selection directly — `max` and `high` clamp to the same genai thinking level, so the wire can't distinguish them. `go test ./...`, `racedetector test ./...`, and `golangci-lint run` (0 issues) all pass.
Declared reasoning efforts xhigh and max could not reach the wire: the
ADK openaimodel bridge maps genai thinking levels onto Responses
reasoning effort and its reasoningEfforts map tops out at "high"
(genai has no xhigh/max level, and the bridge errors on unknown ones).
So a model declaring [low, high, max] advertised a "max" option and a
deep mode that silently sent "high".

normalizeEfforts now collapses xhigh/max to high and dedupes at registry
load, so the thinking option and mode presets only ever offer levels the
bridge can send: a [low, high, max] model offers [low, high], and deep
resolves to its highest expressible effort. thinkingConfig keeps the
clamp as a safety net for hand-built entries.

The mode-reconcile test now uses expressible-different models
([low, medium] vs [low, medium, high]); a new normalization test asserts
xhigh/max collapse to high and deep resolves there.
Author
Collaborator

Additional fix in commit e836c80: the thinkingConfig clamping quirk I flagged is now resolved.

What changed: declared reasoning efforts xhigh/max couldn't reach the wire — the ADK openaimodel bridge maps genai thinking levels onto Responses reasoning.effort and its reasoningEfforts map tops out at high (genai has no xhigh/max level, and the bridge errors on unknown ones). So a model declaring [low, high, max] advertised a max option and a deep mode that silently sent high.

normalizeEfforts now collapses xhigh/max to high (deduped) at registry load, so the thinking option and mode presets only ever offer levels the bridge can send: a [low, high, max] model offers [low, high], and deep resolves to its highest expressible effort. thinkingConfig keeps the clamp as a safety net for hand-built entries. README updated.

Tests: the mode-reconcile test now uses expressible-different models ([low, medium] vs [low, medium, high]); a new TestReasoningEffortNormalization asserts xhigh/max collapse to high and deep resolves there. go test ./..., racedetector test ./..., and golangci-lint run (0 issues) all pass.

Note: if you ever want true xhigh/max on the wire, that requires bypassing or vendoring the ADK openaimodel bridge (its reasoningEfforts map), which is out of scope for this PR.

Additional fix in commit e836c80: the `thinkingConfig` clamping quirk I flagged is now resolved. **What changed:** declared reasoning efforts `xhigh`/`max` couldn't reach the wire — the ADK openaimodel bridge maps genai thinking levels onto Responses `reasoning.effort` and its `reasoningEfforts` map tops out at `high` (genai has no xhigh/max level, and the bridge errors on unknown ones). So a model declaring `[low, high, max]` advertised a `max` option and a `deep` mode that silently sent `high`. `normalizeEfforts` now collapses `xhigh`/`max` to `high` (deduped) at registry load, so the thinking option and mode presets only ever offer levels the bridge can send: a `[low, high, max]` model offers `[low, high]`, and `deep` resolves to its highest *expressible* effort. `thinkingConfig` keeps the clamp as a safety net for hand-built entries. README updated. **Tests:** the mode-reconcile test now uses expressible-different models (`[low, medium]` vs `[low, medium, high]`); a new `TestReasoningEffortNormalization` asserts `xhigh`/`max` collapse to `high` and `deep` resolves there. `go test ./...`, `racedetector test ./...`, and `golangci-lint run` (0 issues) all pass. Note: if you ever want true `xhigh`/`max` on the wire, that requires bypassing or vendoring the ADK openaimodel bridge (its `reasoningEfforts` map), which is out of scope for this PR.
sam merged commit 4ca19f31e6 into main 2026-09-24 21:30:20 +00:00
sam deleted branch feat/acp-session-capabilities 2026-09-24 21:30:20 +00:00
Sign in to join this conversation.
No reviewers
No labels
code-review
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
sam/brainless!11
No description provided.