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
435 lines
14 KiB
Go
435 lines
14 KiB
Go
package agentcontext
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"sync"
|
|
|
|
agentproviderbiz "github.com/tutti-os/tutti/services/tuttid/biz/agentprovider"
|
|
agenttargetbiz "github.com/tutti-os/tutti/services/tuttid/biz/agenttarget"
|
|
preferencesbiz "github.com/tutti-os/tutti/services/tuttid/biz/preferences"
|
|
agentservice "github.com/tutti-os/tutti/services/tuttid/service/agent"
|
|
agentextensionservice "github.com/tutti-os/tutti/services/tuttid/service/agentextension"
|
|
cliservice "github.com/tutti-os/tutti/services/tuttid/service/cli"
|
|
"github.com/tutti-os/tutti/services/tuttid/service/cli/framework"
|
|
)
|
|
|
|
const agentCatalogSchemaVersion = 1
|
|
|
|
var agentColumns = []cliservice.TableColumn{
|
|
{Key: "id", Label: "Agent ID"},
|
|
{Key: "name", Label: "Name"},
|
|
{Key: "provider", Label: "Provider"},
|
|
{Key: "status", Label: "Status"},
|
|
{Key: "detail", Label: "Detail"},
|
|
}
|
|
|
|
type agentsInput struct {
|
|
AgentID string `cli:"agent-id"`
|
|
Refresh bool `cli:"refresh"`
|
|
}
|
|
|
|
type agentCatalogItem struct {
|
|
Target agenttargetbiz.Target
|
|
Availability agentservice.ProviderAvailability
|
|
}
|
|
|
|
type agentsResult struct {
|
|
DefaultAgentTargetID string
|
|
Items []agentCatalogItem
|
|
}
|
|
|
|
func (p Provider) newAgentsCommand() cliservice.Command {
|
|
return framework.Register(framework.CommandSpec[agentsInput]{
|
|
ID: appID + ".agent.list",
|
|
Path: []string{"agent", "list"},
|
|
Summary: "List available agents",
|
|
Description: "List every enabled agent and whether tuttid can start its runtime. Multiple agents may share one provider.",
|
|
Kind: framework.KindList,
|
|
Workspace: framework.WorkspaceOptional,
|
|
Inputs: framework.FromStruct[agentsInput](),
|
|
Output: framework.OutputSpec{
|
|
DefaultMode: cliservice.OutputModeTable,
|
|
DefaultView: framework.ViewSummary,
|
|
JSON: true,
|
|
Table: &framework.TableOutputSpec{
|
|
Columns: agentColumns,
|
|
Rows: func(result any) []map[string]any {
|
|
return agentCatalogRows(result.(agentsResult).Items)
|
|
},
|
|
},
|
|
JSONViews: map[framework.OutputView]func(any) map[string]any{
|
|
framework.ViewSummary: func(result any) map[string]any {
|
|
agents := result.(agentsResult)
|
|
return map[string]any{
|
|
"schemaVersion": agentCatalogSchemaVersion,
|
|
"defaultAgentTargetId": agents.DefaultAgentTargetID,
|
|
"agents": agentCatalogValues(agents.Items),
|
|
}
|
|
},
|
|
},
|
|
ListCompact: true,
|
|
},
|
|
Run: p.runAgents,
|
|
})
|
|
}
|
|
|
|
func (p Provider) runAgents(ctx context.Context, invoke framework.InvokeContext, input agentsInput) (any, error) {
|
|
if err := p.requireSessions(); err != nil {
|
|
return nil, err
|
|
}
|
|
targets, err := p.enabledAgentTargets(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
requestedAgentID := strings.TrimSpace(input.AgentID)
|
|
var requestedTarget *agenttargetbiz.Target
|
|
if requestedAgentID != "" {
|
|
for index := range targets {
|
|
target := &targets[index]
|
|
if target.ID == requestedAgentID {
|
|
requestedTarget = target
|
|
break
|
|
}
|
|
}
|
|
if requestedTarget == nil {
|
|
return nil, fmt.Errorf("%w: enabled agent %q was not found; run agent list --json", cliservice.ErrInvalidInput, requestedAgentID)
|
|
}
|
|
}
|
|
preferredProvider := p.preferredAgentProvider(ctx)
|
|
defaultAgentTargetID := preferredAgentTargetID(targets, preferredProvider)
|
|
|
|
extensionTargets := extensionAgentTargets(targets)
|
|
if requestedTarget != nil {
|
|
if isExtensionAgentTarget(*requestedTarget) {
|
|
extensionTargets = []agenttargetbiz.Target{*requestedTarget}
|
|
} else {
|
|
extensionTargets = nil
|
|
}
|
|
}
|
|
extensionItems := agentCatalogItems(extensionTargets, nil)
|
|
probeCtx, cancelProbes := context.WithCancel(ctx)
|
|
defer cancelProbes()
|
|
extensionAvailabilityDone := make(chan struct{})
|
|
if len(extensionItems) == 0 {
|
|
close(extensionAvailabilityDone)
|
|
} else {
|
|
go func() {
|
|
defer close(extensionAvailabilityDone)
|
|
p.applyExtensionSetupAvailability(probeCtx, invoke.WorkspaceID, extensionItems, input.Refresh)
|
|
}()
|
|
}
|
|
|
|
availability := []agentservice.ProviderAvailability{}
|
|
builtinTargets := builtinAgentTargets(targets)
|
|
needsAvailability := len(builtinTargets) > 0
|
|
if requestedTarget != nil {
|
|
needsAvailability = !isExtensionAgentTarget(*requestedTarget)
|
|
}
|
|
if needsAvailability {
|
|
availabilityInput := agentservice.ProviderAvailabilityInput{}
|
|
if requestedTarget != nil && !isExtensionAgentTarget(*requestedTarget) {
|
|
availabilityInput.Provider = requestedTarget.Provider
|
|
}
|
|
availability, err = p.sessions.ListProviderAvailability(ctx, availabilityInput)
|
|
if err != nil {
|
|
cancelProbes()
|
|
<-extensionAvailabilityDone
|
|
return nil, err
|
|
}
|
|
}
|
|
<-extensionAvailabilityDone
|
|
items := agentCatalogItems(targets, availability)
|
|
extensionAvailabilityByTargetID := make(map[string]agentservice.ProviderAvailability, len(extensionItems))
|
|
for _, item := range extensionItems {
|
|
extensionAvailabilityByTargetID[item.Target.ID] = item.Availability
|
|
}
|
|
for index := range items {
|
|
if extensionAvailability, ok := extensionAvailabilityByTargetID[items[index].Target.ID]; ok {
|
|
items[index].Availability = extensionAvailability
|
|
}
|
|
}
|
|
if defaultAgentTargetID == "" {
|
|
defaultAgentTargetID = fallbackDefaultAgentTargetID(items, preferredProvider)
|
|
}
|
|
if requestedAgentID != "" {
|
|
filtered := make([]agentCatalogItem, 0, 1)
|
|
for _, item := range items {
|
|
if item.Target.ID == requestedAgentID {
|
|
filtered = append(filtered, item)
|
|
break
|
|
}
|
|
}
|
|
items = filtered
|
|
}
|
|
return agentsResult{DefaultAgentTargetID: defaultAgentTargetID, Items: items}, nil
|
|
}
|
|
|
|
func (p Provider) applyExtensionSetupAvailability(
|
|
ctx context.Context,
|
|
requestedWorkspaceID string,
|
|
items []agentCatalogItem,
|
|
refresh bool,
|
|
) {
|
|
if p.extensionAvailabilityCache == nil {
|
|
return
|
|
}
|
|
workspaceID, err := cliservice.ResolveWorkspaceID(ctx, p.workspaces, requestedWorkspaceID)
|
|
if err != nil {
|
|
for index := range items {
|
|
if isExtensionAgentTarget(items[index].Target) {
|
|
items[index].Availability = unknownExtensionSetupAvailability(items[index].Target.Provider, err)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
var probes sync.WaitGroup
|
|
for index := range items {
|
|
if !isExtensionAgentTarget(items[index].Target) || items[index].Availability.Status != agentservice.ProviderAvailabilityAvailable {
|
|
continue
|
|
}
|
|
probes.Add(1)
|
|
go func(index int) {
|
|
defer probes.Done()
|
|
target := items[index].Target
|
|
executablePath := items[index].Availability.ExecutablePath
|
|
snapshot, setupErr := p.extensionAvailabilityCache.load(ctx, agentextensionservice.InstallPlanInput{
|
|
WorkspaceID: workspaceID, AgentTargetID: target.ID,
|
|
}, refresh)
|
|
if setupErr != nil {
|
|
items[index].Availability = unknownExtensionSetupAvailability(target.Provider, setupErr)
|
|
items[index].Availability.ExecutablePath = executablePath
|
|
return
|
|
}
|
|
items[index].Availability = extensionSetupAvailability(target.Provider, snapshot)
|
|
items[index].Availability.ExecutablePath = executablePath
|
|
}(index)
|
|
}
|
|
probes.Wait()
|
|
}
|
|
|
|
func extensionSetupAvailability(provider string, snapshot agentextensionservice.SetupSnapshot) agentservice.ProviderAvailability {
|
|
status := agentservice.ProviderAvailabilityUnknown
|
|
reasonCode := strings.TrimSpace(snapshot.Reason)
|
|
detail := reasonCode
|
|
switch snapshot.Status {
|
|
case agentextensionservice.SetupReady:
|
|
status = agentservice.ProviderAvailabilityAvailable
|
|
reasonCode = ""
|
|
detail = ""
|
|
case agentextensionservice.SetupAuthRequired:
|
|
status = agentservice.ProviderAvailabilityUnavailable
|
|
reasonCode = string(agentextensionservice.SetupAuthRequired)
|
|
if detail == "" {
|
|
detail = "authentication required"
|
|
}
|
|
case agentextensionservice.SetupNotInstalled, agentextensionservice.SetupFailed:
|
|
status = agentservice.ProviderAvailabilityUnavailable
|
|
if reasonCode == "" {
|
|
reasonCode = string(snapshot.Status)
|
|
detail = reasonCode
|
|
}
|
|
case agentextensionservice.SetupInstalling, agentextensionservice.SetupAuthenticating:
|
|
if reasonCode == "" {
|
|
reasonCode = string(snapshot.Status)
|
|
detail = reasonCode
|
|
}
|
|
default:
|
|
if reasonCode == "" {
|
|
reasonCode = "agent_target_setup_status_unknown"
|
|
detail = reasonCode
|
|
}
|
|
}
|
|
result := agentservice.ProviderAvailability{Provider: provider, Status: status}
|
|
if reasonCode != "" {
|
|
result.LastError = &agentservice.ProviderAvailabilityError{Code: reasonCode, Message: detail}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func unknownExtensionSetupAvailability(provider string, _ error) agentservice.ProviderAvailability {
|
|
return agentservice.ProviderAvailability{
|
|
Provider: provider,
|
|
Status: agentservice.ProviderAvailabilityUnknown,
|
|
LastError: &agentservice.ProviderAvailabilityError{
|
|
Code: "agent_target_setup_status_unknown", Message: "agent target setup status is unavailable",
|
|
},
|
|
}
|
|
}
|
|
|
|
func (p Provider) preferredAgentProvider(ctx context.Context) string {
|
|
preferredProvider := preferencesbiz.DefaultDesktopPreferences().DefaultAgentProvider
|
|
if p.preferences != nil {
|
|
preferences, err := p.preferences.Get(ctx)
|
|
if err == nil {
|
|
if normalized := agentproviderbiz.Normalize(preferences.DefaultAgentProvider); normalized != "" {
|
|
preferredProvider = normalized
|
|
}
|
|
}
|
|
}
|
|
return preferredProvider
|
|
}
|
|
|
|
func preferredAgentTargetID(targets []agenttargetbiz.Target, preferredProvider string) string {
|
|
preferredTargetID := preferencesbiz.LocalAgentTargetIDForProvider(preferredProvider)
|
|
for _, target := range targets {
|
|
if target.ID == preferredTargetID {
|
|
return target.ID
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func fallbackDefaultAgentTargetID(items []agentCatalogItem, preferredProvider string) string {
|
|
for _, item := range items {
|
|
if item.Target.Provider == preferredProvider && item.Availability.Status == agentservice.ProviderAvailabilityAvailable {
|
|
return item.Target.ID
|
|
}
|
|
}
|
|
for _, item := range items {
|
|
if item.Target.Provider == preferredProvider {
|
|
return item.Target.ID
|
|
}
|
|
}
|
|
for _, item := range items {
|
|
if item.Availability.Status == agentservice.ProviderAvailabilityAvailable {
|
|
return item.Target.ID
|
|
}
|
|
}
|
|
if len(items) > 0 {
|
|
return items[0].Target.ID
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func agentCatalogItems(targets []agenttargetbiz.Target, availability []agentservice.ProviderAvailability) []agentCatalogItem {
|
|
byProvider := make(map[string]agentservice.ProviderAvailability, len(availability))
|
|
for _, item := range availability {
|
|
provider := agentproviderbiz.Normalize(item.Provider)
|
|
if provider != "" {
|
|
item.Provider = provider
|
|
byProvider[provider] = item
|
|
}
|
|
}
|
|
items := make([]agentCatalogItem, 0, len(targets))
|
|
for _, target := range targets {
|
|
if isExtensionAgentTarget(target) {
|
|
items = append(items, agentCatalogItem{Target: target, Availability: extensionTargetAvailability(target)})
|
|
continue
|
|
}
|
|
item, ok := byProvider[target.Provider]
|
|
if !ok {
|
|
item = agentservice.ProviderAvailability{
|
|
Provider: target.Provider,
|
|
Status: agentservice.ProviderAvailabilityUnknown,
|
|
LastError: &agentservice.ProviderAvailabilityError{
|
|
Code: "agent_provider_status_unknown",
|
|
Message: "provider runtime status is unavailable",
|
|
},
|
|
}
|
|
}
|
|
items = append(items, agentCatalogItem{Target: target, Availability: item})
|
|
}
|
|
return items
|
|
}
|
|
|
|
func builtinAgentTargets(targets []agenttargetbiz.Target) []agenttargetbiz.Target {
|
|
result := make([]agenttargetbiz.Target, 0, len(targets))
|
|
for _, target := range targets {
|
|
if !isExtensionAgentTarget(target) {
|
|
result = append(result, target)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func extensionAgentTargets(targets []agenttargetbiz.Target) []agenttargetbiz.Target {
|
|
result := make([]agenttargetbiz.Target, 0, len(targets))
|
|
for _, target := range targets {
|
|
if isExtensionAgentTarget(target) {
|
|
result = append(result, target)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func isExtensionAgentTarget(target agenttargetbiz.Target) bool {
|
|
ref, err := agenttargetbiz.RuntimeProviderTargetRef(target)
|
|
return err == nil && ref["kind"] == agenttargetbiz.LaunchRefTypeAgentExtension
|
|
}
|
|
|
|
func extensionTargetAvailability(target agenttargetbiz.Target) agentservice.ProviderAvailability {
|
|
status := agentservice.ProviderAvailabilityUnknown
|
|
switch strings.TrimSpace(target.AvailabilityStatus) {
|
|
case "ready":
|
|
status = agentservice.ProviderAvailabilityAvailable
|
|
case "not_installed", "auth_required", "unsupported":
|
|
status = agentservice.ProviderAvailabilityUnavailable
|
|
}
|
|
result := agentservice.ProviderAvailability{
|
|
Provider: target.Provider,
|
|
Status: status,
|
|
ExecutablePath: strings.TrimSpace(target.ExecutablePath),
|
|
}
|
|
if reason := strings.TrimSpace(target.AvailabilityReason); reason != "" {
|
|
result.LastError = &agentservice.ProviderAvailabilityError{Code: reason, Message: reason}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func agentCatalogRows(items []agentCatalogItem) []map[string]any {
|
|
rows := make([]map[string]any, 0, len(items))
|
|
for _, item := range items {
|
|
rows = append(rows, map[string]any{
|
|
"id": item.Target.ID,
|
|
"name": item.Target.Name,
|
|
"provider": item.Target.Provider,
|
|
"status": item.Availability.Status,
|
|
"detail": providerAvailabilityDetail(item.Availability),
|
|
})
|
|
}
|
|
return rows
|
|
}
|
|
|
|
func agentCatalogValues(items []agentCatalogItem) []any {
|
|
values := make([]any, 0, len(items))
|
|
for _, item := range items {
|
|
value := map[string]any{
|
|
"id": item.Target.ID,
|
|
"name": item.Target.Name,
|
|
"provider": item.Target.Provider,
|
|
"availability": map[string]any{
|
|
"status": item.Availability.Status,
|
|
"reasonCode": providerAvailabilityReasonCode(item.Availability),
|
|
"detail": providerAvailabilityDetail(item.Availability),
|
|
},
|
|
}
|
|
if executablePath := strings.TrimSpace(item.Availability.ExecutablePath); executablePath != "" {
|
|
value["executablePath"] = executablePath
|
|
}
|
|
values = append(values, value)
|
|
}
|
|
return values
|
|
}
|
|
|
|
func providerAvailabilityReasonCode(item agentservice.ProviderAvailability) string {
|
|
if item.LastError != nil {
|
|
return strings.TrimSpace(item.LastError.Code)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func providerAvailabilityDetail(item agentservice.ProviderAvailability) string {
|
|
if item.LastError != nil && item.LastError.Message != "" {
|
|
return item.LastError.Message
|
|
}
|
|
for _, check := range item.Checks {
|
|
if check.Detail != "" {
|
|
return check.Detail
|
|
}
|
|
}
|
|
return ""
|
|
}
|