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

398 lines
16 KiB
Go

package agent
import (
"context"
"fmt"
"strings"
"time"
agenthost "github.com/tutti-os/tutti/packages/agent/host"
agentactivitybiz "github.com/tutti-os/tutti/packages/agent/store-sqlite"
"github.com/tutti-os/tutti/packages/agent/store-sqlite/canonical"
preferencesbiz "github.com/tutti-os/tutti/services/tuttid/biz/preferences"
)
func runtimeResumeInputFromRuntimeSession(session ProviderRuntimeSession) RuntimeResumeInput {
return RuntimeResumeInput{
WorkspaceID: strings.TrimSpace(session.WorkspaceID),
AgentSessionID: strings.TrimSpace(session.ID),
AgentTargetID: strings.TrimSpace(session.AgentTargetID),
Provider: strings.TrimSpace(session.Provider),
ProviderSessionID: strings.TrimSpace(session.ProviderSessionID),
Resumable: session.Resumable,
Cwd: strings.TrimSpace(session.Cwd),
Env: append([]string(nil), session.Env...),
Title: strings.TrimSpace(session.Title),
Status: strings.TrimSpace(session.Status),
Settings: normalizeObservedComposerSettingsForProvider(session.Provider, cloneComposerSettingsPointerValue(session.Settings)),
CreatedAtUnixMS: session.CreatedAtUnixMS,
UpdatedAtUnixMS: session.UpdatedAtUnixMS,
Visible: boolPointer(session.Visible),
RuntimeContext: clonePayload(session.RuntimeContext),
}
}
func persistedRuntimeResumeStatus(activeTurnID string) string {
if strings.TrimSpace(activeTurnID) != "" {
return "working"
}
return "ready"
}
func persistedSessionRuntimeContext(session PersistedSession) map[string]any {
return agentactivitybiz.JoinSessionRuntimeContext(session.Metadata, session.InternalRuntimeContext)
}
func runtimeResumeInputFromPersistedSession(session PersistedSession) RuntimeResumeInput {
runtimeContext := agentactivitybiz.JoinSessionRuntimeContext(session.Metadata, session.InternalRuntimeContext)
return RuntimeResumeInput{
WorkspaceID: strings.TrimSpace(session.WorkspaceID),
AgentSessionID: strings.TrimSpace(session.ID),
AgentTargetID: strings.TrimSpace(session.AgentTargetID),
Provider: strings.TrimSpace(session.Provider),
ProviderSessionID: strings.TrimSpace(session.ProviderSessionID),
Cwd: strings.TrimSpace(session.Cwd),
Env: nil,
Title: strings.TrimSpace(session.Title),
Status: persistedRuntimeResumeStatus(session.ActiveTurnID),
Settings: normalizeObservedComposerSettingsForProvider(session.Provider, cloneComposerSettings(session.Settings)),
CreatedAtUnixMS: session.CreatedAtUnixMS,
UpdatedAtUnixMS: session.UpdatedAtUnixMS,
Visible: boolPointer(session.Metadata.Visible),
RuntimeContext: runtimeContext,
Metadata: session.Metadata,
InternalRuntimeContext: clonePayload(session.InternalRuntimeContext),
}
}
const WorkspaceAgentSessionOriginImported = agenthost.WorkspaceAgentSessionOriginImported
func (s *Service) persistedSessionCanResume(ctx context.Context, session PersistedSession) bool {
controller := s.controller()
if controller == nil {
return false
}
if strings.TrimSpace(session.Kind) == agentactivitybiz.SessionKindChild {
return false
}
if strings.TrimSpace(session.Origin) == WorkspaceAgentSessionOriginImported &&
!externalImportResumeSupported(session.InternalRuntimeContext) {
return false
}
input := runtimeResumeInputFromPersistedSession(session)
if input.AgentTargetID != "" {
launchInput := CreateSessionInput{
AgentTargetID: input.AgentTargetID,
Provider: input.Provider,
}
launch, err := s.resolveCreateSessionLaunch(ctx, session.WorkspaceID, &launchInput)
if err != nil {
return false
}
input.Provider = launch.Provider
input.ProviderTargetRef = launch.ProviderTargetRef
}
return controller.CanResume(input)
}
func externalImportResumeSupported(runtimeContext map[string]any) bool {
return agenthost.ExternalImportResumeSupported(runtimeContext)
}
func serviceSession(session ProviderRuntimeSession, resumable bool) Session {
createdAt := timeFromUnixMS(session.CreatedAtUnixMS)
updatedAt := timeFromUnixMSPointer(session.UpdatedAtUnixMS)
title := stringPointer(strings.TrimSpace(session.Title))
normalizedProvider := strings.TrimSpace(session.Provider)
normalizedSettings := normalizeObservedComposerSettingsForProvider(
normalizedProvider,
cloneComposerSettingsPointerValue(session.Settings),
)
normalizedSettings = composerSettingsWithRuntimeSnapshot(
normalizedSettings,
session.RuntimeContext,
)
metadata, internalRuntimeContext, err := agentactivitybiz.SplitSessionRuntimeContext(session.RuntimeContext)
if err != nil {
metadata = agentactivitybiz.SessionMetadata{Visible: session.Visible}
}
metadata.Visible = session.Visible
return Session{
ID: strings.TrimSpace(session.ID),
Kind: agentactivitybiz.SessionKindRoot,
UserID: strings.TrimSpace(session.UserID),
AgentTargetID: strings.TrimSpace(session.AgentTargetID),
Provider: normalizedProvider,
ProviderSessionID: strings.TrimSpace(session.ProviderSessionID),
Cwd: strings.TrimSpace(session.Cwd),
Resumable: resumable,
Visible: session.Visible,
Settings: cloneComposerSettingsPointer(&normalizedSettings),
Capabilities: canonical.CloneCapabilitySnapshot(session.Capabilities),
PermissionConfig: composerPermissionConfig(normalizedProvider, permissionModeIDFromSettings(&normalizedSettings), preferencesbiz.DefaultDesktopLocale),
Title: title,
PinnedAtUnixMS: session.PinnedAtUnixMS,
CreatedAt: createdAt,
UpdatedAt: updatedAt,
Metadata: metadata,
Isolation: sessionIsolationFromRuntimeContext(internalRuntimeContext),
}
}
func (s *Service) initializeRuntimeSession(
ctx context.Context,
session ProviderRuntimeSession,
railPlacement *agenthost.RailPlacement,
) (PersistedSession, error) {
return s.initializeRuntimeSessionWithRailAuthority(ctx, session, railPlacement, false)
}
func (s *Service) initializeRuntimeSessionWithRailAuthority(
ctx context.Context,
session ProviderRuntimeSession,
railPlacement *agenthost.RailPlacement,
railPlacementAuthoritative bool,
) (PersistedSession, error) {
if s == nil || s.SessionInitializer == nil {
return PersistedSession{}, fmt.Errorf("initialize workspace agent session: session initializer is unavailable")
}
var (
persisted PersistedSession
err error
)
if initializer, ok := s.SessionInitializer.(sessionInitializerWithRailAuthority); ok {
persisted, err = initializer.InitializeRuntimeSessionWithRailAuthority(
ctx, session, railPlacement, railPlacementAuthoritative,
)
} else if railPlacementAuthoritative {
return PersistedSession{}, fmt.Errorf("initialize workspace agent session: session initializer does not support authoritative rail placement")
} else {
persisted, err = s.SessionInitializer.InitializeRuntimeSession(ctx, session, railPlacement)
}
if err != nil {
return PersistedSession{}, fmt.Errorf("initialize workspace agent session: %w", err)
}
if strings.TrimSpace(persisted.ID) != strings.TrimSpace(session.ID) ||
strings.TrimSpace(persisted.WorkspaceID) != strings.TrimSpace(session.WorkspaceID) {
return PersistedSession{}, fmt.Errorf("initialize workspace agent session: persisted session identity mismatch")
}
if strings.TrimSpace(persisted.RailSectionKey) == "" {
return PersistedSession{}, fmt.Errorf("initialize workspace agent session: persisted rail section key is empty")
}
return persisted, nil
}
func validatePersistedRailSectionKey(session PersistedSession) error {
if strings.TrimSpace(session.RailSectionKey) == "" {
return fmt.Errorf("workspace agent session %q has no persisted rail section key", strings.TrimSpace(session.ID))
}
return nil
}
func sessionFromPersisted(session PersistedSession, resumable bool) Session {
createdAtUnixMS := session.CreatedAtUnixMS
updatedAtUnixMS := session.UpdatedAtUnixMS
if strings.TrimSpace(session.Origin) == WorkspaceAgentSessionOriginImported {
createdAtUnixMS = firstNonZeroInt64(session.StartedAtUnixMS, session.CreatedAtUnixMS)
updatedAtUnixMS = importedSessionDisplayUpdatedAtUnixMS(session)
}
result := serviceSession(ProviderRuntimeSession{
ID: strings.TrimSpace(session.ID),
WorkspaceID: strings.TrimSpace(session.WorkspaceID),
UserID: strings.TrimSpace(session.UserID),
AgentTargetID: strings.TrimSpace(session.AgentTargetID),
Provider: strings.TrimSpace(session.Provider),
ProviderSessionID: strings.TrimSpace(session.ProviderSessionID),
Cwd: strings.TrimSpace(session.Cwd),
Settings: normalizeComposerSettingsPointerForProvider(session.Provider, &session.Settings),
Status: persistedRuntimeResumeStatus(session.ActiveTurnID),
Title: strings.TrimSpace(session.Title),
PinnedAtUnixMS: session.PinnedAtUnixMS,
CreatedAtUnixMS: createdAtUnixMS,
UpdatedAtUnixMS: updatedAtUnixMS,
Visible: session.Metadata.Visible,
RuntimeContext: persistedSessionRuntimeContext(session),
Capabilities: canonical.CloneCapabilitySnapshot(session.Capabilities),
}, resumable)
result.ActiveTurnID = strings.TrimSpace(session.ActiveTurnID)
result.RailSectionKind = strings.TrimSpace(session.RailSectionKind)
result.RailProjectPath = strings.TrimSpace(session.RailProjectPath)
result.RailSectionKey = strings.TrimSpace(session.RailSectionKey)
result.Kind = strings.TrimSpace(session.Kind)
if result.Kind == "" {
result.Kind = agentactivitybiz.SessionKindRoot
}
result.RootAgentSessionID = strings.TrimSpace(session.RootAgentSessionID)
result.RootTurnID = strings.TrimSpace(session.RootTurnID)
result.ParentAgentSessionID = strings.TrimSpace(session.ParentAgentSessionID)
result.ParentTurnID = strings.TrimSpace(session.ParentTurnID)
result.ParentToolCallID = strings.TrimSpace(session.ParentToolCallID)
result.MessageVersion = session.MessageVersion
result.Metadata = session.Metadata
result.Capabilities = canonical.CloneCapabilitySnapshot(session.Capabilities)
result.Isolation = sessionIsolationFromRuntimeContext(session.InternalRuntimeContext)
return result
}
func importedSessionDisplayUpdatedAtUnixMS(session PersistedSession) int64 {
if session.EndedAtUnixMS > 0 {
return session.EndedAtUnixMS
}
if session.LastEventUnixMS > 0 && session.LastEventUnixMS != session.UpdatedAtUnixMS {
return session.LastEventUnixMS
}
if session.StartedAtUnixMS > 0 {
return session.StartedAtUnixMS
}
return firstNonZeroInt64(session.LastEventUnixMS, session.UpdatedAtUnixMS)
}
func mergePersistedSessionState(session Session, persisted PersistedSession) Session {
session.Kind = strings.TrimSpace(persisted.Kind)
if session.Kind == "" {
session.Kind = agentactivitybiz.SessionKindRoot
}
session.RootAgentSessionID = strings.TrimSpace(persisted.RootAgentSessionID)
session.RootTurnID = strings.TrimSpace(persisted.RootTurnID)
session.ParentAgentSessionID = strings.TrimSpace(persisted.ParentAgentSessionID)
session.ParentTurnID = strings.TrimSpace(persisted.ParentTurnID)
session.ParentToolCallID = strings.TrimSpace(persisted.ParentToolCallID)
session.RailSectionKind = strings.TrimSpace(persisted.RailSectionKind)
session.RailProjectPath = strings.TrimSpace(persisted.RailProjectPath)
session.RailSectionKey = strings.TrimSpace(persisted.RailSectionKey)
if strings.TrimSpace(session.UserID) == "" {
session.UserID = strings.TrimSpace(persisted.UserID)
}
if strings.TrimSpace(session.AgentTargetID) == "" {
session.AgentTargetID = strings.TrimSpace(persisted.AgentTargetID)
}
if session.Settings == nil {
session.Settings = normalizeComposerSettingsPointerForProvider(session.Provider, &persisted.Settings)
}
if session.Settings != nil {
settings := composerSettingsWithRuntimeSnapshot(
*session.Settings,
persistedSessionRuntimeContext(persisted),
)
session.Settings = &settings
}
session.PermissionConfig = composerPermissionConfig(session.Provider, permissionModeIDFromSettings(session.Settings), preferencesbiz.DefaultDesktopLocale)
session.MessageVersion = persisted.MessageVersion
session.PinnedAtUnixMS = persisted.PinnedAtUnixMS
if persisted.UpdatedAtUnixMS > 0 &&
(session.UpdatedAt == nil || persisted.UpdatedAtUnixMS > session.UpdatedAt.UnixMilli()) {
session.UpdatedAt = timeFromUnixMSPointer(persisted.UpdatedAtUnixMS)
}
session.Metadata = persisted.Metadata
if session.Capabilities == nil {
session.Capabilities = canonical.CloneCapabilitySnapshot(persisted.Capabilities)
}
if isolation := sessionIsolationFromRuntimeContext(persisted.InternalRuntimeContext); isolation != nil {
session.Isolation = isolation
}
return session
}
func serviceSessionWithPersistedFreshness(session ProviderRuntimeSession, persisted PersistedSession, resumable bool) Session {
if !persistedSessionIsNewerThanRuntime(persisted, session) {
return mergePersistedSessionState(serviceSession(session, resumable), persisted)
}
service := sessionFromPersisted(persisted, resumable)
if strings.TrimSpace(service.ProviderSessionID) == "" {
service.ProviderSessionID = strings.TrimSpace(session.ProviderSessionID)
}
if liveSettings := normalizeComposerSettingsPointerForProvider(session.Provider, session.Settings); liveSettings != nil {
settings := composerSettingsWithRuntimeSnapshot(
*liveSettings,
persistedSessionRuntimeContext(persisted),
)
service.Settings = &settings
} else if service.Settings == nil {
service.Settings = normalizeComposerSettingsPointerForProvider(session.Provider, session.Settings)
}
service.PermissionConfig = composerPermissionConfig(service.Provider, permissionModeIDFromSettings(service.Settings), preferencesbiz.DefaultDesktopLocale)
if session.Capabilities != nil {
service.Capabilities = canonical.CloneCapabilitySnapshot(session.Capabilities)
}
return service
}
func (s *Service) projectHostSessionResult(
ctx context.Context,
canonical agentactivitybiz.Session,
runtime ProviderRuntimeSession,
live bool,
requireRailSection bool,
resolveProviderCapabilities bool,
) (Session, error) {
persisted := persistedSessionFromHost(canonical)
if requireRailSection && s.SessionReader != nil {
if err := validatePersistedRailSectionKey(persisted); err != nil {
return Session{}, err
}
}
var result Session
if live {
resumable := s.controller().CanResume(runtimeResumeInputFromRuntimeSession(runtime))
result = serviceSession(runtime, resumable)
if s.SessionReader != nil {
result = serviceSessionWithPersistedFreshness(runtime, persisted, resumable)
}
} else {
result = sessionFromPersisted(persisted, s.persistedSessionCanResume(ctx, persisted))
}
return s.withProtocolV2TurnStateProjectionOptions(
ctx,
canonical.WorkspaceID,
result,
resolveProviderCapabilities,
)
}
func persistedSessionIsNewerThanRuntime(persisted PersistedSession, session ProviderRuntimeSession) bool {
persistedUpdatedAtUnixMS := firstNonZeroInt64(persisted.LastEventUnixMS, persisted.UpdatedAtUnixMS)
return persistedUpdatedAtUnixMS > 0 &&
session.UpdatedAtUnixMS > 0 &&
persistedUpdatedAtUnixMS > session.UpdatedAtUnixMS
}
func permissionModeIDFromSettings(settings *ComposerSettings) string {
if settings == nil {
return ""
}
return strings.TrimSpace(settings.PermissionModeID)
}
func composerSettingsWithRuntimeSnapshot(
settings ComposerSettings,
runtimeContext map[string]any,
) ComposerSettings {
snapshot, exists, err := sessionRuntimeSnapshotFromContext(runtimeContext)
if err == nil && exists {
settings.ModelPlanID = strings.TrimSpace(snapshot.ModelPlanID)
if enabled, ok := snapshot.EffectiveConfig["codexSaverMode"].(bool); ok {
settings.CodexSaverMode = enabled
}
if enabled, ok := snapshot.EffectiveConfig["rtkSaverMode"].(bool); ok {
settings.RTKSaverMode = enabled
}
}
return settings
}
func boolPointer(value bool) *bool {
return &value
}
func timeFromUnixMS(value int64) time.Time {
if value <= 0 {
return time.Now().UTC()
}
return time.Unix(0, value*int64(time.Millisecond)).UTC()
}
func timeFromUnixMSPointer(value int64) *time.Time {
t := timeFromUnixMS(value)
return &t
}