Files
agent-radar 2ed3415fb7
Publish Claude Code Binaries / Stage and publish binaries (push) Canceled after 0s
Publish Tutti App Runtime / Build darwin-arm64 (push) Canceled after 0s
Publish Tutti App Runtime / Build darwin-amd64 (push) Canceled after 0s
Publish Tutti App Runtime / Build linux-amd64 (push) Canceled after 0s
Publish Tutti App Runtime / Build windows-amd64 (push) Canceled after 0s
Sync Tutti Agent Skills / sync (push) Canceled after 0s
Windows Agent Adapters / Test Windows agent adapters (push) Canceled after 0s
Windows Daemon Adapters / Test Windows daemon adapters (push) Canceled after 0s
Publish Tutti App Runtime / Publish runtime catalog (push) Canceled after 0s
源码快照 @ 2026-09-01 (source-only, 剔除非源码素材)
2026-09-01 20:17:27 +08:00

783 lines
30 KiB
Go

package agentruntime
import (
"context"
"errors"
"log/slog"
"strings"
activityshared "github.com/tutti-os/tutti/packages/agent/daemon/activity/events"
)
func (a *ClaudeCodeSDKAdapter) sidecarTurnEvents(adapterSession *claudeSDKAdapterSession, session Session, turnID string, event claudeSDKSidecarEvent) ([]activityshared.Event, bool, error) {
adapterSession.applySessionPayload(&session, event.Payload)
eventTurnID := firstNonEmptyString(payloadString(event.Payload, "turnId"), payloadString(event.Payload, "turnID"))
if eventTurnID != "" && strings.TrimSpace(turnID) != "" && eventTurnID != strings.TrimSpace(turnID) {
return nil, false, nil
}
explicitProviderTurnID := payloadString(event.Payload, "providerTurnId")
activeProviderTurnID := a.activeClaudeSDKRootProviderTurnID(adapterSession)
boundProviderTurnID := firstNonEmptyString(
explicitProviderTurnID,
activeProviderTurnID,
)
// dispatchClaudeSDKEvent may have already consume()'d the only known
// provider turn id before projection. Synthetic continuations often omit
// providerTurnId in the payload; fall back to the synthetic turn id so
// turn_completed can still mint root_provider_turn.completed.
if boundProviderTurnID == "" &&
strings.HasPrefix(eventTurnID, "synthetic-") {
boundProviderTurnID = eventTurnID
}
providerTurnID := firstNonEmptyString(
boundProviderTurnID,
strings.TrimSpace(turnID),
eventTurnID,
)
a.mu.Lock()
fenceState := adapterSession.fencedGoalTurns[providerTurnID]
if turnFenceState := adapterSession.fencedGoalTurns[eventTurnID]; turnFenceState > fenceState {
fenceState = turnFenceState
}
if fenceState != 0 && event.Type == "provider_turn_identity_resolved" && explicitProviderTurnID != "" {
binding, bound := adapterSession.goalTurnBindings[eventTurnID]
if bound && (binding.providerTurnID == "" || binding.providerTurnID == explicitProviderTurnID) {
binding.providerTurnID = explicitProviderTurnID
adapterSession.goalTurnBindings[eventTurnID] = binding
adapterSession.fencedGoalTurns[explicitProviderTurnID] = fenceState
if adapterSession.rootProviderTurns == nil {
adapterSession.rootProviderTurns = make(map[string]struct{})
}
adapterSession.rootProviderTurns[explicitProviderTurnID] = struct{}{}
}
}
terminalEvent := isClaudeSDKTerminalEvent(event.Type)
fencedPendingGoalUpdateType := ""
if fenceState != 0 && terminalEvent {
fencedPendingGoalUpdateType = finishClaudeSDKPendingGoalCommandLocked(
adapterSession,
firstNonEmptyString(eventTurnID, strings.TrimSpace(turnID)),
nil,
event.Type != "turn_completed",
true,
)
delete(adapterSession.fencedGoalTurns, providerTurnID)
delete(adapterSession.fencedGoalTurns, eventTurnID)
delete(adapterSession.goalTurnBindings, eventTurnID)
delete(adapterSession.rootProviderTurns, providerTurnID)
delete(adapterSession.rootProviderTurns, eventTurnID)
}
a.mu.Unlock()
if fenceState != 0 && (!terminalEvent || fenceState == claudeSDKGoalTurnFenceSuppress) {
if fencedPendingGoalUpdateType == "" {
return nil, terminalEvent, nil
}
return a.goalMirrorEvents(session, fencedPendingGoalUpdateType), terminalEvent, nil
}
if explicitProviderTurnID != "" &&
activeProviderTurnID != "" &&
explicitProviderTurnID != activeProviderTurnID &&
claudeSDKEventRequiresBoundProviderIdentity(event.Type) {
return nil, false, errors.New("claude SDK provider turn identity changed after binding")
}
goalClearControlTurn := a.isGoalClearControlTurn(adapterSession, providerTurnID) ||
a.isGoalClearControlTurn(adapterSession, eventTurnID)
if goalClearControlTurn && isClaudeSDKGoalClearHiddenEvent(event.Type) {
return nil, false, nil
}
if goalClearControlTurn &&
isClaudeSDKTerminalEvent(event.Type) &&
event.Type != "goal_command_canceled" {
events := a.finishClaudeSDKPendingGoalTurn(
adapterSession,
session,
eventTurnID,
event.Type != "turn_completed",
true,
)
a.forgetGoalClearControlTurn(adapterSession, providerTurnID)
a.forgetGoalClearControlTurn(adapterSession, eventTurnID)
return events, true, nil
}
rootTurnID := ""
if event.Type != "provider_turn_identity_resolved" &&
event.Type != "turn_started" &&
event.Type != "goal_command_canceled" {
rootTurnID = a.claudeSDKRootTurnID(adapterSession, providerTurnID)
}
if events, handled := claudeSDKSidecarBackgroundTaskEvents(adapterSession, session, event); handled {
return events, false, nil
}
switch event.Type {
case "ok":
return nil, false, nil
case "sdk_lifecycle_observed":
state, changed := adapterSession.applyRuntimeActivity(event.Payload)
if !changed {
return nil, false, nil
}
event := newSessionActivityEvent(
session,
EventSessionUpdated,
firstNonEmpty(session.Status, SessionStatusReady),
claudeSDKRuntimeContext(session, adapterSession),
)
event.Payload.RuntimeActivity = activityshared.RuntimeActivityState(state)
return []activityshared.Event{event}, false, nil
case "session_state":
return []activityshared.Event{newSessionActivityEvent(session, EventSessionUpdated, firstNonEmpty(session.Status, SessionStatusReady), claudeSDKRuntimeContext(session, adapterSession))}, false, nil
case "provider_turn_identity_resolved":
if eventTurnID == "" || explicitProviderTurnID == "" {
return nil, false, errors.New("claude SDK provider turn identity resolution omitted identity")
}
admission, err := a.admitClaudeSDKGoalTurn(adapterSession, eventTurnID, explicitProviderTurnID, event.Payload)
if err != nil {
return nil, false, err
}
if admission.denied() {
a.rejectClaudeSDKGoalTurn(adapterSession, session, eventTurnID, explicitProviderTurnID, admission)
return nil, false, nil
}
if admission.goalTurn && !a.publishClaudeSDKGoalTurn(adapterSession, eventTurnID) {
return nil, false, nil
}
a.beginClaudeSDKRootTurn(adapterSession, eventTurnID, explicitProviderTurnID)
metadata := map[string]any{"adapter": claudeSDKSidecarAdapterName}
for key, value := range admission.metadata {
metadata[key] = value
}
return []activityshared.Event{a.claudeSDKRootProviderTurnStartedEvent(
session,
eventTurnID,
explicitProviderTurnID,
metadata,
)}, false, nil
case "provider_turn_checkpoint":
checkpointMessageID := payloadString(
event.Payload,
"providerCheckpointMessageId",
)
if eventTurnID == "" || boundProviderTurnID == "" || checkpointMessageID == "" {
return nil, false, errors.New(
"claude SDK provider turn checkpoint omitted identity",
)
}
return []activityshared.Event{a.claudeSDKRootProviderTurnCheckpointEvent(
session,
eventTurnID,
boundProviderTurnID,
checkpointMessageID,
)}, false, nil
case "turn_started":
metadata := map[string]any{
"adapter": claudeSDKSidecarAdapterName,
}
admission, err := a.admitClaudeSDKGoalTurn(adapterSession, eventTurnID, explicitProviderTurnID, event.Payload)
if err != nil {
return nil, false, err
}
if admission.denied() {
a.rejectClaudeSDKGoalTurn(adapterSession, session, eventTurnID, providerTurnID, admission)
return nil, false, nil
}
if admission.goalTurn && explicitProviderTurnID == "" {
return nil, false, nil
}
if admission.goalTurn && !a.publishClaudeSDKGoalTurn(adapterSession, eventTurnID) {
return nil, false, nil
}
if !admission.goalTurn {
providerTurnID = firstNonEmptyString(explicitProviderTurnID, strings.TrimSpace(turnID), eventTurnID)
}
for key, value := range admission.metadata {
metadata[key] = value
}
if admission.goalTurn {
// Goal control does not pre-allocate a canonical Turn. The provider's
// first identity/start fact starts a fresh root mapping instead of
// inheriting the preceding user Turn from this long-lived SDK session.
rootTurnID = firstNonEmptyString(eventTurnID, strings.TrimSpace(turnID), providerTurnID)
a.beginClaudeSDKRootTurn(adapterSession, rootTurnID, providerTurnID)
} else {
rootTurnID = a.claudeSDKRootTurnID(adapterSession, providerTurnID)
a.rememberClaudeSDKRootProviderTurn(adapterSession, providerTurnID)
}
if payloadBoolValue(event.Payload, "synthetic") {
metadata["synthetic"] = true
}
return []activityshared.Event{a.claudeSDKRootProviderTurnStartedEvent(
session,
rootTurnID,
providerTurnID,
metadata,
)}, false, nil
case "goal_command_started":
a.markClaudeSDKPendingGoalCommandStarted(adapterSession, event)
metadata := map[string]any{
"operationId": payloadString(event.Payload, "operationId"),
"revision": payloadInt64(event.Payload, "revision"),
"repairEpoch": payloadInt64(event.Payload, "repairEpoch"),
"action": payloadString(event.Payload, "action"),
"providerTurnId": firstNonEmptyString(payloadString(event.Payload, "providerTurnId"), turnID),
"goal": a.localGoal(adapterSession),
"executionPending": payloadString(event.Payload, "action") == string(GoalControlSet),
}
events := make([]activityshared.Event, 0, 2)
if ctx, ok := activityEventContext(session, newID(), ""); ok {
events = append(events, activityshared.NewGoalControlApplied(ctx, metadata))
}
events = append(events, newSessionActivityEvent(session, EventSessionUpdated, firstNonEmpty(session.Status, SessionStatusReady), claudeSDKRuntimeContext(session, adapterSession)))
return events, false, nil
case "goal_command_superseded":
return a.finishClaudeSDKPendingGoalTurn(
adapterSession,
session,
eventTurnID,
true,
true,
), true, nil
case "goal_command_canceled":
events := a.finishClaudeSDKPendingGoalCommand(adapterSession, session, event)
a.forgetGoalClearControlTurn(adapterSession, eventTurnID)
a.forgetClaudeSDKGoalTurnBinding(adapterSession, eventTurnID)
return events, true, nil
case "commands_updated":
if adapterSession.applyCommandsUpdated(session.AgentSessionID, event.Payload) {
a.emitCommandSnapshot(claudeSDKCommandSnapshot(session.AgentSessionID, adapterSession.liveState))
}
return nil, false, nil
case "session_title_updated":
if titleEvent, ok := normalizedSessionTitleEvent(session, event.Payload); ok {
return []activityshared.Event{titleEvent}, false, nil
}
return nil, false, nil
case "error":
return nil, false, errors.New(payloadString(event.Payload, "error"))
case "approval_requested", "user_input_requested":
if boundProviderTurnID == "" {
return nil, false, errors.New(
"claude SDK interaction omitted bound provider turn identity",
)
}
events, err := a.claudeSDKInteractiveRequested(
adapterSession,
session,
rootTurnID,
boundProviderTurnID,
event.Payload,
)
return events, false, err
case "approval_resolved", "user_input_resolved":
return a.claudeSDKInteractiveResolved(adapterSession, session, rootTurnID, event.Payload), false, nil
case "compact_started":
compact, ok := a.compactMessageEvent(adapterSession, session, rootTurnID, messageStreamStateStreaming, "running", "")
if !ok {
return nil, false, nil
}
return []activityshared.Event{compact}, false, nil
case "compact_completed":
compact, ok := a.compactMessageEvent(adapterSession, session, rootTurnID, messageStreamStateCompleted, "completed", "")
if !ok {
return nil, false, nil
}
return []activityshared.Event{compact}, false, nil
case "compact_failed":
detail := payloadString(event.Payload, "reason")
if detail == "" {
detail = strings.TrimSpace(strings.TrimPrefix(payloadString(event.Payload, "content"), "Compacting failed:"))
}
compact, ok := a.compactMessageEvent(adapterSession, session, rootTurnID, messageStreamStateFailed, "failed", detail)
if !ok {
return nil, false, nil
}
markClaudeSDKContextHandoffRequired(&compact, event.Payload)
return []activityshared.Event{compact}, false, nil
case "assistant_delta":
messageID := firstNonEmptyString(payloadString(event.Payload, "messageId"), adapterSession.assistantMessageID(providerTurnID))
content := firstNonEmpty(payloadString(event.Payload, "snapshot"), payloadString(event.Payload, "content"))
return a.claudeSDKAssistantEvents(adapterSession, session, rootTurnID, messageID, content, false), false, nil
case "assistant_completed":
messageID := firstNonEmptyString(payloadString(event.Payload, "messageId"), adapterSession.assistantMessageID(providerTurnID))
return a.claudeSDKAssistantEvents(
adapterSession,
session,
rootTurnID,
messageID,
payloadString(event.Payload, "content"),
true,
), false, nil
case "assistant_failed":
messageID := firstNonEmptyString(payloadString(event.Payload, "messageId"), adapterSession.assistantMessageID(providerTurnID))
return a.claudeSDKAssistantFailedEvents(
adapterSession,
session,
rootTurnID,
messageID,
payloadString(event.Payload, "content"),
), false, nil
case "thinking_delta":
messageID := firstNonEmptyString(payloadString(event.Payload, "messageId"), adapterSession.thinkingMessageID(providerTurnID))
content := firstNonEmpty(payloadString(event.Payload, "snapshot"), payloadString(event.Payload, "content"))
return a.claudeSDKThinkingEvents(adapterSession, session, rootTurnID, messageID, content, false), false, nil
case "thinking_completed":
messageID := firstNonEmptyString(payloadString(event.Payload, "messageId"), adapterSession.thinkingMessageID(providerTurnID))
return a.claudeSDKThinkingEvents(
adapterSession,
session,
rootTurnID,
messageID,
payloadString(event.Payload, "content"),
true,
), false, nil
case "guidance_interrupted":
return a.finishClaudeSDKGuidanceResponse(adapterSession, session, rootTurnID, eventTurnID, strings.TrimSpace(turnID))
case "tool_started":
if a.claudeSDKToolEventTargetsClosedTurn(adapterSession, rootTurnID, event.Payload) {
return nil, false, nil
}
events := adapterSession.claudeSDKToolEvents(session, rootTurnID, event.Payload, EventCallStarted, messageStreamStateStreaming, event.Type)
events = a.projectClaudeSDKTurnCallEvents(adapterSession, events)
return events, false, nil
case "tool_updated":
if a.claudeSDKToolEventTargetsClosedTurn(adapterSession, rootTurnID, event.Payload) {
return nil, false, nil
}
events := adapterSession.claudeSDKToolEvents(session, rootTurnID, event.Payload, EventCallStarted, messageStreamStateStreaming, event.Type)
events = a.projectClaudeSDKTurnCallEvents(adapterSession, events)
for index := range events {
if events[index].Type != activityshared.EventCallStarted {
continue
}
markClaudeSDKToolProgressUpdate(&events[index])
}
return events, false, nil
case "tool_completed":
if a.claudeSDKToolEventTargetsClosedTurn(adapterSession, rootTurnID, event.Payload) {
return nil, false, nil
}
events := adapterSession.claudeSDKToolEvents(session, rootTurnID, event.Payload, EventCallCompleted, messageStreamStateCompleted, event.Type)
events = a.projectClaudeSDKTurnCallEvents(adapterSession, events)
return events, false, nil
case "tool_failed":
if a.claudeSDKToolEventTargetsClosedTurn(adapterSession, rootTurnID, event.Payload) {
return nil, false, nil
}
events := adapterSession.claudeSDKToolEvents(session, rootTurnID, event.Payload, EventCallFailed, messageStreamStateFailed, event.Type)
events = a.projectClaudeSDKTurnCallEvents(adapterSession, events)
return events, false, nil
case "task_result_updated":
return adapterSession.claudeSDKTaskResultUpdatedEvents(session, event.Payload), false, nil
case "task_started", "task_progress", "task_completed":
if child, ok := adapterSession.claudeSDKChildForPayload(event.Payload); ok &&
a.turnAlreadySettled(adapterSession, child.TurnID) {
return nil, false, nil
}
return adapterSession.claudeSDKTaskLifecycleEvents(session, rootTurnID, event.Type, event.Payload), false, nil
case "plan_updated":
return claudeSDKPlanEvents(session, rootTurnID, event.Payload), false, nil
case "usage_updated":
if adapterSession.applyUsageUpdated(event.Payload) {
if event, ok := normalizedUsageUpdatedEvent(
session,
claudeSDKRuntimeContext(session, adapterSession),
); ok {
return []activityshared.Event{event}, false, nil
}
}
return nil, false, nil
case "speed_updated":
if adapterSession.applySpeedUpdated(event.Payload) {
if event, ok := normalizedConfigOptionsUpdatedEvent(session, map[string]any{"key": "fast"}); ok {
return []activityshared.Event{event}, false, nil
}
}
return nil, false, nil
case "goal_observed":
updateType := a.applyClaudeSDKGoalObservation(adapterSession, event.Payload)
if updateType == "" {
return nil, false, nil
}
a.finishClaudeSDKPendingGoalTurn(
adapterSession,
session,
eventTurnID,
false,
false,
)
events := make([]activityshared.Event, 0, 2)
if goalEvent, ok := normalizedGoalUpdatedEvent(session, updateType); ok {
events = append(events, goalEvent)
}
events = append(events, newSessionActivityEvent(session, EventSessionUpdated, firstNonEmpty(session.Status, SessionStatusReady), claudeSDKRuntimeContext(session, adapterSession)))
return events, false, nil
case "turn_completed":
if boundProviderTurnID == "" {
return nil, false, errors.New("claude SDK provider turn completion omitted identity")
}
a.finishClaudeSDKPendingGoalTurn(adapterSession, session, eventTurnID, false, true)
events := a.finishClaudeSDKTurnLifecycle(adapterSession, session, rootTurnID, claudeSDKTurnFinishCompleted, "")
events = append(events, claudeSDKRootProviderTurnCompletedEvent(session, rootTurnID, boundProviderTurnID, activityshared.TurnOutcomeCompleted, map[string]any{
"adapter": claudeSDKSidecarAdapterName,
"stopReason": firstNonEmpty(payloadString(event.Payload, "stopReason"), "end_turn"),
}))
a.forgetClaudeSDKGoalTurnBinding(adapterSession, eventTurnID)
return events, true, nil
case "turn_canceled":
goalEvents := a.finishClaudeSDKPendingGoalTurn(adapterSession, session, eventTurnID, true, true)
if boundProviderTurnID == "" {
events := a.finishClaudeSDKTurnLifecycle(
adapterSession,
session,
rootTurnID,
claudeSDKTurnFinishInterrupted,
"interrupted_before_provider_acceptance",
)
return append(events, goalEvents...), true, nil
}
events := a.finishClaudeSDKTurnLifecycle(adapterSession, session, rootTurnID, claudeSDKTurnFinishInterrupted, "interrupted")
events = append(events, claudeSDKRootProviderTurnCompletedEvent(session, rootTurnID, boundProviderTurnID, activityshared.TurnOutcomeCanceled, map[string]any{
"adapter": claudeSDKSidecarAdapterName,
}))
if len(goalEvents) > 0 {
events = append(events, goalEvents...)
} else {
events = append(events, a.goalEventsOnArmTurnFailed(adapterSession, session, firstNonEmptyString(eventTurnID, strings.TrimSpace(turnID), providerTurnID))...)
}
a.forgetClaudeSDKGoalTurnBinding(adapterSession, eventTurnID)
return events, true, nil
case "turn_failed":
goalEvents := a.finishClaudeSDKPendingGoalTurn(adapterSession, session, eventTurnID, true, true)
if boundProviderTurnID == "" {
events := a.finishClaudeSDKTurnLifecycle(
adapterSession,
session,
rootTurnID,
claudeSDKTurnFinishFailed,
"failed_before_provider_acceptance",
)
rejected := strings.EqualFold(
strings.TrimSpace(payloadString(event.Payload, "dispatchDisposition")),
string(DispatchDispositionRejected),
)
events = ensureClaudeSDKPreAcceptanceFailureEvent(
events, session, rootTurnID, event.Payload, rejected,
)
events = append(events, goalEvents...)
if rejected {
return events, true, newClaudeSDKProviderRejectedError(session, event.Payload)
}
return events, true, nil
}
events := a.finishClaudeSDKTurnLifecycle(adapterSession, session, rootTurnID, claudeSDKTurnFinishFailed, "turn_failed")
failureMetadata := claudeProviderFailure(event.Payload).metadata()
failureMetadata["adapter"] = claudeSDKSidecarAdapterName
events = append(events, claudeSDKRootProviderTurnCompletedEvent(session, rootTurnID, boundProviderTurnID, activityshared.TurnOutcomeFailed, failureMetadata))
if len(goalEvents) > 0 {
events = append(events, goalEvents...)
} else {
events = append(events, a.goalEventsOnArmTurnFailed(adapterSession, session, firstNonEmptyString(eventTurnID, strings.TrimSpace(turnID), providerTurnID))...)
}
a.forgetClaudeSDKGoalTurnBinding(adapterSession, eventTurnID)
return events, true, nil
default:
return nil, false, nil
}
}
func (a *ClaudeCodeSDKAdapter) startClaudeSDKReader(agentSessionID string, adapterSession *claudeSDKAdapterSession) error {
if a == nil || adapterSession == nil || adapterSession.reader == nil {
return ErrSessionDisconnected
}
a.mu.Lock()
if adapterSession.readerStarted {
a.mu.Unlock()
return nil
}
adapterSession.readerStarted = true
a.mu.Unlock()
go a.runClaudeSDKReader(agentSessionID, adapterSession)
return nil
}
func (a *ClaudeCodeSDKAdapter) runClaudeSDKReader(agentSessionID string, adapterSession *claudeSDKAdapterSession) {
for {
event, err := adapterSession.reader.next(context.Background())
if err != nil {
a.failClaudeSDKReader(agentSessionID, adapterSession, err)
return
}
if err := a.dispatchClaudeSDKEvent(
agentSessionID,
adapterSession,
event,
); err != nil {
a.failClaudeSDKReader(agentSessionID, adapterSession, err)
return
}
}
}
// nextTurnLifecycleSeq allocates the next per-session lifecycle snapshot
// sequence number.
func (a *ClaudeCodeSDKAdapter) nextTurnLifecycleSeq(adapterSession *claudeSDKAdapterSession) uint64 {
a.mu.Lock()
defer a.mu.Unlock()
adapterSession.lifecycleSeq++
return adapterSession.lifecycleSeq
}
// stampTurnLifecycleSnapshots stamps an adapter-origin TurnLifecycle snapshot
// onto every turn.* event in the batch (ADR 0008); see
// stampAdapterTurnLifecycleEvents for the contract. It also records terminal
// transitions so Cancel can tell an already-settled turn apart from a live
// one.
func (a *ClaudeCodeSDKAdapter) stampTurnLifecycleSnapshots(adapterSession *claudeSDKAdapterSession, events []activityshared.Event) []activityshared.Event {
if a == nil || adapterSession == nil || len(events) == 0 {
return events
}
events = stampAdapterTurnLifecycleEvents(events, func() uint64 {
return a.nextTurnLifecycleSeq(adapterSession)
})
a.mu.Lock()
for _, event := range events {
switch event.Type {
// turn.canceled folds into turn.completed with an interrupted
// outcome at construction (newTurnActivityEventWithID), so these two
// cover every terminal transition.
case activityshared.EventTurnCompleted, activityshared.EventTurnFailed:
turnID := strings.TrimSpace(event.Payload.TurnID)
if turnID == "" {
continue
}
if adapterSession.settledTurns == nil {
adapterSession.settledTurns = make(map[string]string)
}
// Sessions are long-lived; keep the guard bounded rather than
// growing one entry per turn forever.
if len(adapterSession.settledTurns) > 64 {
adapterSession.settledTurns = make(map[string]string)
}
outcome := strings.TrimSpace(event.Payload.TurnOutcome)
if outcome == "" {
if snapshot, ok := activityshared.TurnLifecycleSnapshotFromEvent(event); ok {
outcome = snapshot.Outcome
}
}
adapterSession.settledTurns[turnID] = outcome
}
}
a.mu.Unlock()
return events
}
func (a *ClaudeCodeSDKAdapter) logClaudeSDKLifecycleEvent(agentSessionID string, adapterSession *claudeSDKAdapterSession, event claudeSDKSidecarEvent) {
if !claudeSDKLifecycleEventDiagnostic(event) {
return
}
a.mu.Lock()
adapterSession.diagnosticEventSeq++
sequence := adapterSession.diagnosticEventSeq
providerSessionID := strings.TrimSpace(adapterSession.providerSessionID)
rootTurnID := strings.TrimSpace(adapterSession.rootTurnID)
a.mu.Unlock()
payload := event.Payload
args := []any{
"event", "agent_session.claude_sdk.lifecycle_event",
"sequence", sequence,
"agent_session_id", strings.TrimSpace(agentSessionID),
"provider_session_id", providerSessionID,
"root_turn_id", rootTurnID,
"sidecar_event_type", strings.TrimSpace(event.Type),
}
args = append(args, claudeSDKLifecycleLogArgs(payload)...)
slog.Log(
context.Background(),
claudeSDKLifecycleEventLogLevel(event.Type),
"agent session Claude SDK lifecycle event",
args...,
)
}
func claudeSDKLifecycleEventDiagnostic(event claudeSDKSidecarEvent) bool {
switch strings.TrimSpace(event.Type) {
case "sdk_lifecycle_observed",
"provider_turn_identity_resolved", "provider_turn_checkpoint",
"goal_observed", "goal_command_canceled",
"approval_requested", "user_input_requested",
"turn_started", "turn_completed", "turn_canceled", "turn_failed",
"continuation_delayed",
"background_tasks_changed", "background_tasks_quiesced",
"task_started", "task_progress", "task_completed":
return true
case "tool_started", "tool_completed", "tool_failed":
return strings.EqualFold(strings.TrimSpace(payloadString(event.Payload, "toolName")), "Agent") ||
strings.EqualFold(strings.TrimSpace(payloadString(event.Payload, "toolName")), "Task")
default:
return false
}
}
func (a *ClaudeCodeSDKAdapter) registerClaudeSDKTurn(adapterSession *claudeSDKAdapterSession, turnID string, emit EventSink) *claudeSDKTurnWaiter {
waiter := &claudeSDKTurnWaiter{
turnID: strings.TrimSpace(turnID),
emit: emit,
done: make(chan claudeSDKTurnResult, 1),
}
a.mu.Lock()
if adapterSession.turns == nil {
adapterSession.turns = make(map[string]*claudeSDKTurnWaiter)
}
adapterSession.turns[waiter.turnID] = waiter
a.mu.Unlock()
return waiter
}
func (a *ClaudeCodeSDKAdapter) unregisterClaudeSDKTurn(adapterSession *claudeSDKAdapterSession, turnID string, waiter *claudeSDKTurnWaiter) {
if a == nil || adapterSession == nil || waiter == nil {
return
}
a.mu.Lock()
if current := adapterSession.turns[strings.TrimSpace(turnID)]; current == waiter {
delete(adapterSession.turns, strings.TrimSpace(turnID))
}
a.mu.Unlock()
}
func (a *ClaudeCodeSDKAdapter) claudeSDKTurnWaiter(adapterSession *claudeSDKAdapterSession, turnID string) *claudeSDKTurnWaiter {
if a == nil || adapterSession == nil || strings.TrimSpace(turnID) == "" {
return nil
}
a.mu.Lock()
defer a.mu.Unlock()
return adapterSession.turns[strings.TrimSpace(turnID)]
}
func (a *ClaudeCodeSDKAdapter) completeClaudeSDKWaiterEvent(
adapterSession *claudeSDKAdapterSession,
waiter *claudeSDKTurnWaiter,
turnID string,
events []activityshared.Event,
terminal bool,
err error,
) {
if waiter == nil {
return
}
waiter.mu.Lock()
if waiter.completed {
waiter.mu.Unlock()
return
}
if len(events) > 0 {
waiter.events = append(waiter.events, events...)
}
completed := err != nil || terminal
var resultEvents []activityshared.Event
if completed {
waiter.completed = true
resultEvents = append([]activityshared.Event(nil), waiter.events...)
}
emit := waiter.emit
waiter.mu.Unlock()
if len(events) > 0 && emit != nil {
emit(events)
}
if !completed {
return
}
a.unregisterClaudeSDKTurn(adapterSession, turnID, waiter)
waiter.done <- claudeSDKTurnResult{
events: resultEvents,
err: err,
}
}
func (a *ClaudeCodeSDKAdapter) failClaudeSDKReader(agentSessionID string, adapterSession *claudeSDKAdapterSession, err error) {
a.failClaudeSDKReaderWithOwnership(agentSessionID, adapterSession, err, false)
}
func (a *ClaudeCodeSDKAdapter) failClaudeSDKReaderWithOwnership(
agentSessionID string,
adapterSession *claudeSDKAdapterSession,
err error,
retainSession bool,
) {
if a == nil || adapterSession == nil {
return
}
// Reader failure and replacement share the exact-session commit axis.
// Whichever owns dispatchMu first fully commits; the other observes that
// generation boundary instead of publishing a mixed old/new timeline.
adapterSession.dispatchMu.Lock()
defer adapterSession.dispatchMu.Unlock()
a.mu.Lock()
ownsCurrentSession := a.sessions[agentSessionID] == adapterSession
adapterSession.invalid = true
turns := make([]*claudeSDKTurnWaiter, 0, len(adapterSession.turns))
for turnID, waiter := range adapterSession.turns {
turns = append(turns, waiter)
delete(adapterSession.turns, turnID)
}
responses := make([]chan claudeSDKSidecarEvent, 0, len(adapterSession.pendingResponses))
for id, response := range adapterSession.pendingResponses {
responses = append(responses, response)
delete(adapterSession.pendingResponses, id)
}
a.mu.Unlock()
// Converge every provider-owned lifecycle through the session sink before
// releasing Exec/round-trip waiters. Those waiters can return stale local
// lifecycle snapshots; if they win this race, the controller can reject
// their whole batch and lose the only provider terminal event.
//
// Any interactive/permission request still awaiting a human decision must
// also be resolved explicitly. Otherwise the pending approval bookkeeping
// is discarded silently with the session and the GUI is left without a
// terminal explanation.
var pendingFailureEvents []activityshared.Event
if ownsCurrentSession {
session := a.claudeSDKSessionSnapshot(adapterSession)
if strings.TrimSpace(session.AgentSessionID) == "" {
session.AgentSessionID = agentSessionID
}
pendingFailureEvents = a.claudeSDKPendingRequestFailureEvents(adapterSession, session, "", err)
pendingFailureEvents = append(pendingFailureEvents, a.finishAllClaudeSDKTurnLifecycles(
adapterSession,
session,
claudeSDKTurnFinishFailed,
err.Error(),
)...)
pendingFailureEvents = append(
pendingFailureEvents,
a.failAllClaudeSDKRootProviderTurns(adapterSession, session, err)...,
)
}
if !retainSession {
a.mu.Lock()
if a.sessions[agentSessionID] == adapterSession {
delete(a.sessions, agentSessionID)
}
a.mu.Unlock()
}
if ownsCurrentSession {
a.emitClaudeSDKSessionEvents(agentSessionID, pendingFailureEvents)
}
for _, waiter := range turns {
waiter.mu.Lock()
if waiter.completed {
waiter.mu.Unlock()
continue
}
waiter.completed = true
events := append([]activityshared.Event(nil), waiter.events...)
waiter.mu.Unlock()
waiter.done <- claudeSDKTurnResult{
events: events,
err: err,
}
}
for _, response := range responses {
response <- claudeSDKSidecarEvent{Type: "error", Payload: map[string]any{"error": err.Error(), "transport": true}}
}
}