tutti/packages/agent/daemon/runtime/standard_acp_settings.go

package agentruntime

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"log/slog"
	"sort"
	"strings"
	"time"

	"github.com/tutti-os/tutti/packages/agent/daemon/providerregistry"
	"github.com/tutti-os/tutti/packages/agent/store-sqlite/canonical"
)

func (a *standardACPAdapter) applyACPMode(ctx context.Context, client *acpClient, session Session, modeID string) error {
	modeID = strings.TrimSpace(modeID)
	if modeID == "" {
		a.logStandardACPStartupDiagnostics("session_mode.skipped", map[string]any{
			"room_id":             session.RoomID,
			"agent_session_id":    session.AgentSessionID,
			"provider_session_id": session.ProviderSessionID,
			"permission_mode_id":  session.PermissionModeID,
			"reason":              "no_target_mode",
		})
		return nil
	}
	if currentModeID := a.sessionCurrentMode(session.AgentSessionID); currentModeID == modeID {
		a.logStandardACPStartupDiagnostics("session_mode.skipped", map[string]any{
			"room_id":             session.RoomID,
			"agent_session_id":    session.AgentSessionID,
			"provider_session_id": session.ProviderSessionID,
			"permission_mode_id":  session.PermissionModeID,
			"mode_id":             modeID,
			"reason":              "already_current",
		})
		return nil
	}
	params := map[string]any{
		"sessionId": session.ProviderSessionID,
		"modeId":    modeID,
	}
	if merge := a.config.setModeParams; merge != nil {
		for k, v := range merge(session) {
			params[k] = v
		}
	}
	setModeStartedAt := time.Now()
	slog.Info("agent session ACP mode update started",
		"event", "agent_session.acp.session_mode.start",
		"provider", a.config.provider,
		"agent_session_id", session.AgentSessionID,
		"provider_session_id", session.ProviderSessionID,
		"permission_mode_id", session.PermissionModeID,
		"mode_id", modeID,
		"timeout_ms", acpPermissionModeTimeout.Milliseconds(),
	)
	a.logStandardACPStartupDiagnostics("session_mode.start", map[string]any{
		"room_id":             session.RoomID,
		"agent_session_id":    session.AgentSessionID,
		"provider_session_id": session.ProviderSessionID,
		"permission_mode_id":  session.PermissionModeID,
		"mode_id":             modeID,
		"timeout_ms":          acpPermissionModeTimeout.Milliseconds(),
	})
	_, err := client.CallWithTimeout(ctx, acpPermissionModeTimeout, acpMethodSetMode, params, func(ctx context.Context, message acpMessage) error {
		_, err := a.handleACPMessage(ctx, client, session, "", message, nil, nil, nil)
		return err
	})
	if err != nil {
		a.logStandardACPStartupDiagnostics("session_mode.unconfirmed", map[string]any{
			"room_id":             session.RoomID,
			"agent_session_id":    session.AgentSessionID,
			"provider_session_id": session.ProviderSessionID,
			"permission_mode_id":  session.PermissionModeID,
			"mode_id":             modeID,
			"elapsed_ms":          time.Since(setModeStartedAt).Milliseconds(),
			"error":               err.Error(),
		})
		if a.config.failOnSetModeError {
			return fmt.Errorf("agent session ACP mode confirmation failed: %w", err)
		}
		slog.Warn("agent session ACP mode was not confirmed; continuing",
			"event", "agent_session.acp.session_mode.unconfirmed",
			"provider", a.config.provider,
			"agent_session_id", session.AgentSessionID,
			"provider_session_id", session.ProviderSessionID,
			"mode_id", modeID,
			"elapsed_ms", time.Since(setModeStartedAt).Milliseconds(),
			"error", err.Error(),
		)
		return nil
	}
	a.setSessionCurrentMode(session.AgentSessionID, modeID)
	slog.Info("agent session ACP mode update succeeded",
		"event", "agent_session.acp.session_mode.succeeded",
		"provider", a.config.provider,
		"agent_session_id", session.AgentSessionID,
		"provider_session_id", session.ProviderSessionID,
		"permission_mode_id", session.PermissionModeID,
		"mode_id", modeID,
		"elapsed_ms", time.Since(setModeStartedAt).Milliseconds(),
	)
	a.logStandardACPStartupDiagnostics("session_mode.succeeded", map[string]any{
		"room_id":             session.RoomID,
		"agent_session_id":    session.AgentSessionID,
		"provider_session_id": session.ProviderSessionID,
		"permission_mode_id":  session.PermissionModeID,
		"mode_id":             modeID,
		"elapsed_ms":          time.Since(setModeStartedAt).Milliseconds(),
	})
	return nil
}

func (a *standardACPAdapter) sessionCurrentMode(agentSessionID string) string {
	if a == nil {
		return ""
	}
	a.mu.Lock()
	defer a.mu.Unlock()
	session := a.sessions[strings.TrimSpace(agentSessionID)]
	if session == nil {
		return ""
	}
	return strings.TrimSpace(session.currentMode)
}

func (a *standardACPAdapter) setSessionCurrentMode(agentSessionID string, modeID string) {
	if a == nil {
		return
	}
	a.mu.Lock()
	defer a.mu.Unlock()
	if session := a.sessions[strings.TrimSpace(agentSessionID)]; session != nil {
		session.currentMode = strings.TrimSpace(modeID)
	}
}

func (a *standardACPAdapter) applySessionConfigOptions(
	ctx context.Context,
	client *acpClient,
	session Session,
	startResult json.RawMessage,
) error {
	settings := session.SettingsValue()
	if validate := a.config.validateSettings; validate != nil {
		if err := validate(session, SessionSettingsPatch{}); err != nil {
			return fmt.Errorf("agent session ACP startup settings are invalid: %w", err)
		}
	}
	supported := acpConfigOptionIDs(startResult)
	modelsAPI := acpModelsResultPresent(startResult)
	if len(supported) == 0 && !modelsAPI {
		a.logStandardACPStartupDiagnostics("config_options.skipped", map[string]any{
			"room_id":             session.RoomID,
			"agent_session_id":    session.AgentSessionID,
			"provider_session_id": session.ProviderSessionID,
			"reason":              "none_supported",
		})
		return nil
	}
	a.logStandardACPStartupDiagnostics("config_options.start", map[string]any{
		"room_id":              session.RoomID,
		"agent_session_id":     session.AgentSessionID,
		"provider_session_id":  session.ProviderSessionID,
		"supported_option_ids": acpConfigOptionIDList(startResult),
		"model_requested":      strings.TrimSpace(settings.Model) != "",
		"effort_requested":     strings.TrimSpace(settings.ReasoningEffort) != "",
	})
	// A requested model is identity-bearing launch intent. If the agent rejects
	// it, continuing on its default would make the visible selection disagree
	// with the provider request. Other non-identity settings remain best-effort.
	modelConfigID := a.effectiveModelConfigOptionID()
	modelSet := false
	if model := strings.TrimSpace(settings.Model); model != "" && modelConfigID != "" &&
		(supported[modelConfigID] || (modelConfigID == "model" && modelsAPI)) {
		modelAlreadySelected := a.sessionConfigOptionMatches(session.AgentSessionID, modelConfigID, model)
		if !modelAlreadySelected {
			var err error
			if modelsAPI && modelConfigID == "model" {
				err = a.setSessionModel(ctx, client, session, model)
			} else {
				err = a.setSessionConfigOption(ctx, client, session, modelConfigID, model)
			}
			if err != nil {
				return fmt.Errorf("agent session ACP model configuration failed: %w", err)
			}
			modelSet = modelsAPI && modelConfigID == "model"
		}
		a.updateSessionConfigOption(session.AgentSessionID, modelConfigID, model)
	}
	if reasoning := strings.TrimSpace(settings.ReasoningEffort); reasoning != "" {
		if a.config.setModelReasoningEffortMeta {
			model := strings.TrimSpace(settings.Model)
			if model == "" {
				model = a.sessionCurrentModelID(session.AgentSessionID)
			}
			effort, advertised := a.sessionModelReasoningEffort(session.AgentSessionID, model, reasoning)
			if !modelSet && advertised && effort != "" {
				if err := a.setSessionModel(ctx, client, session, model); err != nil {
					a.logStartupConfigOptionRejected(session, "model._meta.reasoningEffort", reasoning, err)
				}
			}
		} else if reasoningConfigID := a.effectiveReasoningConfigOptionID(supported); reasoningConfigID == "" {
			a.logStandardACPStartupDiagnostics("config_options.reasoning.skipped", map[string]any{
				"room_id":              session.RoomID,
				"agent_session_id":     session.AgentSessionID,
				"provider_session_id":  session.ProviderSessionID,
				"supported_option_ids": acpConfigOptionIDList(startResult),
			})
		} else if a.sessionConfigOptionMatches(session.AgentSessionID, reasoningConfigID, reasoning) {
			a.updateSessionConfigOption(session.AgentSessionID, reasoningConfigID, reasoning)
		} else if err := a.setSessionConfigOption(ctx, client, session, reasoningConfigID, reasoning); err != nil {
			a.logStartupConfigOptionRejected(session, reasoningConfigID, reasoning, err)
		} else {
			a.updateSessionConfigOption(session.AgentSessionID, reasoningConfigID, reasoning)
		}
	}
	if speed := strings.TrimSpace(settings.Speed); speed != "" && supported["fast"] {
		if a.sessionConfigOptionMatches(session.AgentSessionID, "fast", speed) {
			a.updateSessionConfigOption(session.AgentSessionID, "fast", speed)
		} else if err := a.setSessionConfigOption(ctx, client, session, "fast", speed); err != nil {
			return fmt.Errorf("agent session ACP fast configuration failed: %w", err)
		} else {
			a.updateSessionConfigOption(session.AgentSessionID, "fast", speed)
		}
	}
	a.logStandardACPStartupDiagnostics("config_options.succeeded", map[string]any{
		"room_id":             session.RoomID,
		"agent_session_id":    session.AgentSessionID,
		"provider_session_id": session.ProviderSessionID,
	})
	return nil
}

func (a *standardACPAdapter) logStartupConfigOptionRejected(
	session Session,
	configID string,
	value string,
	err error,
) {
	slog.Warn("agent session ACP startup config option rejected; continuing on agent default",
		"event", "agent_session.acp.config_option.rejected",
		"provider", a.config.provider,
		"adapter", a.config.adapterName,
		"room_id", session.RoomID,
		"agent_session_id", session.AgentSessionID,
		"provider_session_id", session.ProviderSessionID,
		"config_id", configID,
		"value", value,
		"error", err.Error(),
	)
}

func acpModelsResultPresent(raw json.RawMessage) bool {
	var payload struct {
		Models json.RawMessage `json:"models"`
	}
	return json.Unmarshal(raw, &payload) == nil && len(payload.Models) > 0 && string(payload.Models) != "null"
}

func (a *standardACPAdapter) setSessionModel(
	ctx context.Context,
	client *acpClient,
	session Session,
	modelID string,
) error {
	params := map[string]any{
		"sessionId": session.ProviderSessionID,
		"modelId":   strings.TrimSpace(modelID),
	}
	if a.config.setModelReasoningEffortMeta {
		requested := strings.TrimSpace(session.SettingsValue().ReasoningEffort)
		if effort, advertised := a.sessionModelReasoningEffort(session.AgentSessionID, modelID, requested); advertised && effort != "" {
			params["_meta"] = map[string]any{"reasoningEffort": effort}
		}
	}
	result, err := client.CallWithTimeout(ctx, acpStartCallTimeout, acpMethodSetModel, params, func(ctx context.Context, message acpMessage) error {
		_, err := a.handleACPMessage(ctx, client, session, "", message, nil, nil, nil)
		return err
	})
	if err != nil {
		return err
	}
	a.updateSessionConfigOptionsResult(session.AgentSessionID, result)
	return nil
}

func (a *standardACPAdapter) setSessionConfigOption(
	ctx context.Context,
	client *acpClient,
	session Session,
	configID string,
	value string,
) error {
	startedAt := time.Now()
	a.logStandardACPStartupDiagnostics("config_option.start", map[string]any{
		"room_id":             session.RoomID,
		"agent_session_id":    session.AgentSessionID,
		"provider_session_id": session.ProviderSessionID,
		"config_id":           configID,
		"value":               value,
		"timeout_ms":          acpStartCallTimeout.Milliseconds(),
	})
	result, err := client.CallWithTimeout(ctx, acpStartCallTimeout, acpMethodSetConfigOption, map[string]any{
		"sessionId": session.ProviderSessionID,
		"configId":  configID,
		"value":     value,
	}, func(ctx context.Context, message acpMessage) error {
		_, err := a.handleACPMessage(ctx, client, session, "", message, nil, nil, nil)
		return err
	})
	if err != nil {
		a.logStandardACPStartupDiagnostics("config_option.failed", map[string]any{
			"room_id":             session.RoomID,
			"agent_session_id":    session.AgentSessionID,
			"provider_session_id": session.ProviderSessionID,
			"config_id":           configID,
			"elapsed_ms":          time.Since(startedAt).Milliseconds(),
			"error":               err.Error(),
		})
		return err
	}
	a.updateSessionConfigOptionsResult(session.AgentSessionID, result)
	a.logStandardACPStartupDiagnostics("config_option.succeeded", map[string]any{
		"room_id":              session.RoomID,
		"agent_session_id":     session.AgentSessionID,
		"provider_session_id":  session.ProviderSessionID,
		"config_id":            configID,
		"elapsed_ms":           time.Since(startedAt).Milliseconds(),
		"supported_option_ids": acpConfigOptionIDList(result),
	})
	return nil
}

func (a *standardACPAdapter) updateSessionConfigOptionsResult(agentSessionID string, raw json.RawMessage) {
	if a == nil || len(raw) == 0 {
		return
	}
	a.mu.Lock()
	defer a.mu.Unlock()
	session := a.sessions[strings.TrimSpace(agentSessionID)]
	if session == nil {
		return
	}
	applyACPConfigOptionsResult(
		&session.acpLiveState,
		raw,
		a.config.modelConfigOptionID,
		a.config.modelDescriptionFormat,
	)
	applyACPModelsResult(&session.acpLiveState, raw, a.config.modelDescriptionFormat)
	applyACPModesResult(&session.acpLiveState, raw)
}

func (a *standardACPAdapter) updateSessionConfigOption(
	agentSessionID string,
	configID string,
	value string,
) {
	if a == nil {
		return
	}
	a.mu.Lock()
	defer a.mu.Unlock()
	session := a.sessions[strings.TrimSpace(agentSessionID)]
	if session == nil {
		return
	}
	session.ensureInitialized()
	if strings.TrimSpace(value) == "" {
		delete(session.configOptions, configID)
		return
	}
	session.configOptions[configID] = value
	updateConfigOptionDescriptorValue(session.configOptionDescriptors, configID, value)
}

func (a *standardACPAdapter) sessionReasoningConfigOptionID(agentSessionID string) string {
	if a == nil {
		return ""
	}
	a.mu.Lock()
	defer a.mu.Unlock()
	session := a.sessions[strings.TrimSpace(agentSessionID)]
	if session == nil {
		return ""
	}
	if configured := strings.TrimSpace(a.config.reasoningConfigOptionID); configured != "" {
		return configured
	}
	if a.config.restrictConfigOptions {
		return ""
	}
	return acpLiveStateReasoningConfigOptionID(snapshotACPLiveState(session.acpLiveState))
}

func (a *standardACPAdapter) effectiveModelConfigOptionID() string {
	if configured := strings.TrimSpace(a.config.modelConfigOptionID); configured != "" {
		return configured
	}
	if a.config.restrictConfigOptions {
		return ""
	}
	return "model"
}

func (a *standardACPAdapter) effectivePermissionConfigOptionID() string {
	if configured := strings.TrimSpace(a.config.permissionConfigOptionID); configured != "" {
		return configured
	}
	if a.config.restrictConfigOptions {
		return ""
	}
	return "mode"
}

func (a *standardACPAdapter) effectiveReasoningConfigOptionID(supported map[string]bool) string {
	if configured := strings.TrimSpace(a.config.reasoningConfigOptionID); configured != "" {
		if supported[configured] {
			return configured
		}
		return ""
	}
	if a.config.restrictConfigOptions {
		return ""
	}
	return acpReasoningConfigOptionID(supported)
}

// RequiresNewSessionForSettings implements NewSessionSettingsAdapter for
// providers whose config declares spawn-time-only settings (currently Nexight).
func (a *standardACPAdapter) RequiresNewSessionForSettings(session Session, patch SessionSettingsPatch) bool {
	if a != nil && a.config.launchPermission != nil && patch.PermissionModeID != nil &&
		strings.TrimSpace(*patch.PermissionModeID) != strings.TrimSpace(session.PermissionModeID) {
		return true
	}
	if a == nil || a.config.requiresNewSessionForSettings == nil {
		return false
	}
	return a.config.requiresNewSessionForSettings(session, patch)
}

func (a *standardACPAdapter) ValidateSessionSettings(session Session, patch SessionSettingsPatch) error {
	if a == nil {
		return nil
	}
	if validate := a.config.validateSettings; validate != nil {
		if err := validate(session, patch); err != nil {
			return fmt.Errorf("agent session ACP settings are invalid: %w", err)
		}
	}
	_, builtInProvider := providerregistry.Find(a.config.provider)
	if builtInProvider {
		return nil
	}
	if patch.Model != nil {
		model := strings.TrimSpace(*patch.Model)
		modelConfigID := a.effectiveModelConfigOptionID()
		if model == "" || modelConfigID == "" || !a.sessionConfigOptionAdvertisesValue(session.AgentSessionID, modelConfigID, model) {
			return fmt.Errorf("agent session ACP model %q is not advertised", model)
		}
	}
	if patch.PermissionModeID != nil {
		semanticID := strings.TrimSpace(*patch.PermissionModeID)
		runtimeID := ""
		if a.config.permissionModeID != nil {
			runtimeID = strings.TrimSpace(a.config.permissionModeID(semanticID))
		}
		if a.config.launchPermission != nil {
			if runtimeID == "" {
				return fmt.Errorf("agent session ACP permission mode %q is not declared", semanticID)
			}
		} else {
			permissionConfigID := a.effectivePermissionConfigOptionID()
			if runtimeID == "" || permissionConfigID == "" || !a.sessionConfigOptionAdvertisesValue(session.AgentSessionID, permissionConfigID, runtimeID) {
				return fmt.Errorf("agent session ACP permission mode %q is not advertised", semanticID)
			}
		}
	}
	if patch.ReasoningEffort != nil {
		reasoning := strings.TrimSpace(*patch.ReasoningEffort)
		if a.config.setModelReasoningEffortMeta {
			model := strings.TrimSpace(session.SettingsValue().Model)
			if patch.Model != nil {
				model = strings.TrimSpace(*patch.Model)
			}
			selected, advertised := a.sessionModelReasoningEffort(session.AgentSessionID, model, reasoning)
			if reasoning == "" || !advertised || selected != reasoning {
				return fmt.Errorf("agent session ACP reasoning value %q is not advertised for model %q", reasoning, model)
			}
		} else {
			runtimeID := a.sessionReasoningConfigOptionID(session.AgentSessionID)
			if reasoning == "" || runtimeID == "" || !a.sessionConfigOptionAdvertisesValue(session.AgentSessionID, runtimeID, reasoning) {
				return fmt.Errorf("agent session ACP reasoning value %q is not advertised", reasoning)
			}
		}
	}
	if patch.PlanMode != nil {
		candidate := session
		settings := candidate.SettingsValue()
		settings.PlanMode = *patch.PlanMode
		candidate.Settings = &settings
		runtimeID := a.effectiveModeID(candidate)
		permissionConfigID := a.effectiveWorkflowModeConfigOptionID()
		advertised := permissionConfigID != "" && a.sessionConfigOptionAdvertisesValue(session.AgentSessionID, permissionConfigID, runtimeID)
		declaredWorkflowMode := runtimeID != "" &&
			(runtimeID == strings.TrimSpace(a.config.planModeRuntimeID) ||
				runtimeID == strings.TrimSpace(a.config.planModeDisabledRuntimeID))
		if runtimeID == "" || (!advertised && !declaredWorkflowMode) {
			return fmt.Errorf("agent session ACP plan mode target %q is not advertised", runtimeID)
		}
	}
	return nil
}

func (a *standardACPAdapter) ApplySessionSettings(
	ctx context.Context,
	session Session,
	patch SessionSettingsPatch,
) error {
	if validate := a.config.validateSettings; validate != nil {
		if err := validate(session, patch); err != nil {
			return fmt.Errorf("agent session ACP settings are invalid: %w", err)
		}
	}
	if a.RequiresNewSessionForSettings(session, patch) {
		return ErrSessionSettingsRequireNewSession
	}
	if patch.PlanMode != nil && a.config.planModeUsesLaunchPermission {
		unlockLifecycle := a.lockSessionLifecycle(session.AgentSessionID)
		defer unlockLifecycle()
		live := a.getUsableSession(session.AgentSessionID)
		if live == nil || live.client == nil {
			// The Host persists the setting. Starting a replacement process is
			// deferred until the next user operation reconnects this session.
			return nil
		}
		if strings.TrimSpace(session.ProviderSessionID) == "" {
			session.ProviderSessionID = live.providerSessionID
		}
		if strings.TrimSpace(session.ProviderSessionID) == "" {
			return errors.New("agent session ACP Plan restart requires a provider session id")
		}
		if err := a.admitReplacementLocked(session.AgentSessionID); err != nil {
			return err
		}
		if err := a.resumeLocked(ctx, session); err != nil {
			return fmt.Errorf("agent session ACP Plan restart failed: %w", err)
		}
		return nil
	}

	// Serialize every live-client settings RPC with start, resume, close, and
	// idle release. In particular, the reaper must not close the process while
	// an in-place config request is awaiting its provider response.
	unlockLifecycle := a.lockSessionLifecycle(session.AgentSessionID)
	defer unlockLifecycle()
	acpSession := a.getUsableSession(session.AgentSessionID)
	if acpSession == nil || acpSession.client == nil {
		return nil
	}
	if strings.TrimSpace(session.ProviderSessionID) == "" {
		session.ProviderSessionID = acpSession.providerSessionID
	}

	if patch.PlanMode != nil {
		if err := a.applyACPMode(ctx, acpSession.client, session, a.effectiveModeID(session)); err != nil {
			return err
		}
		a.setSessionPlanMode(session.AgentSessionID, *patch.PlanMode)
	}

	modelSet := false
	if patch.Model != nil {
		model := strings.TrimSpace(*patch.Model)
		// A model the live agent advertises as a selectable option can be
		// switched in place via set_config_option, even if it is a concrete id
		// (e.g. Opus 4.6) rather than one of the static aliases. Only models the
		// running agent has not advertised still require a fresh session.
		modelConfigID := a.effectiveModelConfigOptionID()
		advertised := modelConfigID != "" && a.sessionConfigOptionAdvertisesValue(session.AgentSessionID, modelConfigID, model)
		if advertised {
			if !a.sessionConfigOptionMatches(session.AgentSessionID, modelConfigID, model) {
				var err error
				if modelConfigID == "model" && a.sessionUsesACPModelsAPI(session.AgentSessionID) {
					err = a.setSessionModel(ctx, acpSession.client, session, model)
					modelSet = err == nil
				} else {
					err = a.setSessionConfigOption(ctx, acpSession.client, session, modelConfigID, model)
				}
				if err != nil {
					return fmt.Errorf("agent session ACP model configuration failed: %w", err)
				}
				a.updateSessionConfigOption(session.AgentSessionID, modelConfigID, model)
			}
		}
	}

	if patch.ReasoningEffort != nil {
		reasoning := strings.TrimSpace(*patch.ReasoningEffort)
		if reasoning != "" {
			if a.config.setModelReasoningEffortMeta {
				if !modelSet {
					model := strings.TrimSpace(session.SettingsValue().Model)
					if err := a.setSessionModel(ctx, acpSession.client, session, model); err != nil {
						return fmt.Errorf("agent session ACP reasoning model metadata update failed: %w", err)
					}
				}
			} else {
				reasoningConfigID := a.sessionReasoningConfigOptionID(session.AgentSessionID)
				if reasoningConfigID == "" {
					reasoningConfigID = "effort"
				}
				if !a.sessionConfigOptionAdvertisesValue(session.AgentSessionID, reasoningConfigID, reasoning) {
					return fmt.Errorf("agent session ACP %s %q is not advertised for the current model", reasoningConfigID, reasoning)
				}
				if !a.sessionConfigOptionMatches(session.AgentSessionID, reasoningConfigID, reasoning) {
					if err := a.setSessionConfigOption(ctx, acpSession.client, session, reasoningConfigID, reasoning); err != nil {
						return fmt.Errorf("agent session ACP %s configuration failed: %w", reasoningConfigID, err)
					}
					a.updateSessionConfigOption(session.AgentSessionID, reasoningConfigID, reasoning)
				}
			}
		}
	}

	if patch.Speed != nil {
		speed := strings.TrimSpace(*patch.Speed)
		if speed != "" {
			if !a.sessionConfigOptionMatches(session.AgentSessionID, "fast", speed) {
				if err := a.setSessionConfigOption(ctx, acpSession.client, session, "fast", speed); err != nil {
					return fmt.Errorf("agent session ACP fast configuration failed: %w", err)
				}
				a.updateSessionConfigOption(session.AgentSessionID, "fast", speed)
			}
		}
	}

	return nil
}

func (a *standardACPAdapter) sessionUsesACPModelsAPI(agentSessionID string) bool {
	if a == nil {
		return false
	}
	a.mu.Lock()
	defer a.mu.Unlock()
	session := a.sessions[strings.TrimSpace(agentSessionID)]
	return session != nil && session.modelsAPI
}

func (a *standardACPAdapter) SessionState(session Session) SessionStateSnapshot {
	snapshot := SessionStateSnapshot{
		RoomID:            session.RoomID,
		AgentSessionID:    session.AgentSessionID,
		Provider:          session.Provider,
		ProviderSessionID: session.ProviderSessionID,
		Status:            session.Status,
		PermissionModeID:  session.PermissionModeID,
		RuntimeContext: map[string]any{
			"cwd":              session.CWD,
			"title":            session.Title,
			"permissionModeId": session.PermissionModeID,
		},
		UpdatedAtUnixMS: session.UpdatedAtUnixMS,
	}
	if a == nil {
		return snapshot
	}
	a.mu.Lock()
	acpSession := a.sessions[strings.TrimSpace(session.AgentSessionID)]
	if acpSession == nil {
		a.mu.Unlock()
		return snapshot
	}
	state := snapshotACPLiveState(acpSession.acpLiveState)
	resumeRuntimeContext := clonePayload(acpSession.resumeRuntimeContext)
	agentInfo := clonePayload(acpSession.agentInfo)
	promptImage := acpSession.promptImage
	var prompt *SessionInteractivePrompt
	for _, pending := range acpSession.pendingApprovals {
		// SessionState is another canonical publication path. Do not expose a
		// split-frame AskUserQuestion here before the matching tool update has
		// completed and validated the immutable Interaction input.
		if pending == nil || !pending.interactionRequested {
			continue
		}
		if candidate := pending.snapshotPrompt(); candidate != nil {
			prompt = candidate
			break
		}
	}
	a.mu.Unlock()

	for key, value := range resumeRuntimeContext {
		snapshot.RuntimeContext[key] = value
	}
	snapshot.RuntimeContext["cwd"] = session.CWD
	snapshot.RuntimeContext["title"] = session.Title
	snapshot.RuntimeContext["permissionModeId"] = session.PermissionModeID
	if len(agentInfo) > 0 {
		snapshot.RuntimeContext["agent"] = agentInfo
	}
	if state.currentMode != "" {
		snapshot.RuntimeContext["mode"] = state.currentMode
	}
	if len(state.availableCommands) > 0 {
		snapshot.RuntimeContext["commands"] = agentSessionCommandNames(state.availableCommands)
		snapshot.RuntimeContext["availableCommands"] = agentSessionCommandsRuntimeContext(state.availableCommands)
	}
	config := canonicalACPConfigForRuntimeContext(state.configOptions)
	if filter := a.config.filterRuntimeConfigOptionValues; filter != nil {
		config = filter(session, config)
	}
	if len(config) > 0 {
		snapshot.RuntimeContext["config"] = config
	}
	configOptionDescriptors := canonicalACPConfigOptionDescriptorsForRuntimeContext(state.configOptionDescriptors)
	if filter := a.config.filterRuntimeConfigOptionDescriptors; filter != nil {
		configOptionDescriptors = filter(session, configOptionDescriptors)
	}
	if len(configOptionDescriptors) > 0 {
		snapshot.RuntimeContext["configOptions"] = configOptionDescriptors
	}
	if providerConfig := providerRuntimeConfig(session, session.Provider); len(providerConfig) > 0 {
		snapshot.RuntimeContext["providerConfig"] = providerConfig
	}
	if usage := acpUsageRuntimeContext(state.usage); len(usage) > 0 {
		snapshot.RuntimeContext["usage"] = usage
	}
	if len(state.goal) > 0 {
		snapshot.RuntimeContext["goal"] = state.goal
	}
	capabilities := standardACPCapabilitiesWithDeclared(
		a.config.provider,
		promptImage,
		state,
		a.config.capabilities,
		a.config.planModeRuntimeID != "" && a.config.planModeDisabledRuntimeID != "",
	)
	capabilities = appendBrowserUseCapability(capabilities, session.Env)
	capabilities = appendComputerUseCapability(capabilities, session.Env)
	if _, builtInProvider := providerregistry.Find(a.config.provider); !builtInProvider {
		capabilities = filterDeclaredCapabilities(capabilities, a.config.capabilities)
	}
	snapshot.Capabilities = canonical.NewCapabilitySnapshot(capabilities)
	if a.config.restrictConfigOptions {
		snapshot.Settings = sessionSettingsWithDeclaredACPConfig(
			session.Settings,
			session.Provider,
			session.PermissionModeID,
			config,
			a.effectiveModelConfigOptionID(),
			strings.TrimSpace(a.config.reasoningConfigOptionID),
		)
	} else {
		snapshot.Settings = sessionSettingsWithACPConfig(
			session.Settings,
			session.Provider,
			session.PermissionModeID,
			config,
			true,
		)
	}
	if snapshot.Settings != nil {
		snapshot.RuntimeContext["model"] = snapshot.Settings.Model
		snapshot.RuntimeContext["reasoningEffort"] = snapshot.Settings.ReasoningEffort
		snapshot.RuntimeContext["speed"] = snapshot.Settings.Speed
		snapshot.RuntimeContext["planMode"] = snapshot.Settings.PlanMode
	}
	if prompt != nil {
		snapshot.PendingInteractive = prompt
	}
	return snapshot
}

func sessionSettingsWithDeclaredACPConfig(
	base *SessionSettings,
	provider string,
	defaultPermissionModeID string,
	config map[string]any,
	modelConfigOptionID string,
	reasoningConfigOptionID string,
) *SessionSettings {
	settings := normalizeSessionSettings(base, provider, defaultPermissionModeID)
	hasSettings := base != nil
	if model := asString(config[strings.TrimSpace(modelConfigOptionID)]); model != "" {
		settings.Model = model
		hasSettings = true
	}
	if reasoning := asString(config[strings.TrimSpace(reasoningConfigOptionID)]); reasoning != "" {
		settings.ReasoningEffort = reasoning
		hasSettings = true
	}
	if !hasSettings {
		return nil
	}
	return &settings
}

func acpConfigOptionIDs(raw json.RawMessage) map[string]bool {
	if len(raw) == 0 {
		return nil
	}
	var payload struct {
		ConfigOptions []map[string]any `json:"configOptions"`
	}
	if err := json.Unmarshal(raw, &payload); err != nil || len(payload.ConfigOptions) == 0 {
		return nil
	}
	ids := make(map[string]bool, len(payload.ConfigOptions))
	for _, option := range payload.ConfigOptions {
		id := strings.TrimSpace(asString(option["id"]))
		if id != "" {
			ids[id] = true
		}
	}
	return ids
}

func acpReasoningConfigOptionID(supported map[string]bool) string {
	for _, id := range []string{"reasoning_effort", "model_reasoning_effort", "effort", "thought_level"} {
		if supported[id] {
			return id
		}
	}
	return ""
}

func acpConfigOptionIDList(raw json.RawMessage) []string {
	ids := acpConfigOptionIDs(raw)
	if len(ids) == 0 {
		return nil
	}
	out := make([]string, 0, len(ids))
	for id := range ids {
		out = append(out, id)
	}
	sort.Strings(out)
	return out
}