tutti/services/tuttid/model_plan_native_subscription_probe.go

package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/tutti-os/tutti/packages/agent/daemon/providerregistry"
	modelplanbiz "github.com/tutti-os/tutti/services/tuttid/biz/modelplan"
	agentservice "github.com/tutti-os/tutti/services/tuttid/service/agent"
	modelplanservice "github.com/tutti-os/tutti/services/tuttid/service/modelplan"
)

type modelPlanNativeSubscriptionProbe struct {
	Agents *agentservice.Service
}

func (p modelPlanNativeSubscriptionProbe) ProbeNativeSubscription(
	ctx context.Context,
	input modelplanservice.NativeSubscriptionProbeInput,
) (modelplanservice.NativeSubscriptionProbeResult, error) {
	if p.Agents == nil {
		return modelplanservice.NativeSubscriptionProbeResult{}, fmt.Errorf("agent service is unavailable")
	}
	provider, targetID, ok := nativeSubscriptionAgentTarget(input.Protocol)
	if !ok {
		return modelplanservice.NativeSubscriptionProbeResult{}, fmt.Errorf("unsupported native subscription protocol %q", input.Protocol)
	}
	fallbackModels := make([]string, 0, len(input.Models))
	for _, model := range input.Models {
		fallbackModels = append(fallbackModels, model.ID)
	}
	probe, err := p.Agents.ProbeNativeProvider(ctx, agentservice.NativeProviderProbeInput{
		WorkspaceID:    input.WorkspaceID,
		AgentTargetID:  targetID,
		Provider:       provider,
		Model:          input.Model,
		FallbackModels: fallbackModels,
	})
	if err != nil {
		return modelplanservice.NativeSubscriptionProbeResult{}, err
	}

	result := modelplanservice.NativeSubscriptionProbeResult{
		RuntimeLatencyMs:   probe.AvailabilityLatencyMs,
		DiscoveryDetail:    probe.DiscoveryError,
		DiscoveryLatencyMs: probe.DiscoveryLatencyMs,
		InferenceAttempted: probe.InferenceAttempted,
		InferencePassed:    probe.InferencePassed,
		InferenceModel:     probe.InferenceModel,
		InferenceDetail:    probe.InferenceDetail,
		InferenceLatencyMs: probe.InferenceLatencyMs,
	}
	if probe.Availability == nil {
		result.RuntimeDetail = probe.AvailabilityError
		return result, nil
	}
	result.RuntimeAvailable, result.RuntimeDetail = nativeSubscriptionRuntimeStatus(*probe.Availability)
	result.Authenticated, result.AuthDetail = nativeSubscriptionAuthStatus(*probe.Availability)
	for _, option := range probe.Models {
		modelID := strings.TrimSpace(option.Value)
		if modelID == "" {
			continue
		}
		name := strings.TrimSpace(option.Label)
		if name == "" {
			name = modelID
		}
		result.DiscoveredModels = append(result.DiscoveredModels, modelplanbiz.Model{
			ID:   modelID,
			Name: name,
		})
	}
	return result, nil
}

func nativeSubscriptionAgentTarget(protocol modelplanbiz.Protocol) (string, string, bool) {
	target, ok := providerregistry.ResolveNativeSubscriptionTarget(providerregistry.ModelPlanProtocol(protocol))
	if !ok {
		return "", "", false
	}
	return target.ProviderID, target.AgentTargetID, true
}

func nativeSubscriptionRuntimeStatus(availability agentservice.ProviderAvailability) (bool, string) {
	details := make([]string, 0, 2)
	passed := true
	seen := 0
	for _, check := range availability.Checks {
		name := strings.TrimSpace(check.Name)
		if name != "cli" && name != "adapter" {
			continue
		}
		seen++
		if check.Passed {
			continue
		}
		passed = false
		if detail := strings.TrimSpace(check.Detail); detail != "" {
			details = append(details, detail)
		}
	}
	if seen != 2 {
		passed = false
	}
	return passed, strings.Join(details, "; ")
}

func nativeSubscriptionAuthStatus(availability agentservice.ProviderAvailability) (bool, string) {
	for _, check := range availability.Checks {
		if strings.TrimSpace(check.Name) == "auth" {
			return check.Passed, strings.TrimSpace(check.Detail)
		}
	}
	return false, "authentication status is unavailable"
}