Method execute

pkg/runtime/fallback.go:226–378

execute attempts to create a stream and get a response using the primary model, falling back to configured fallback models if the primary fails. Retry behavior: - Retryable errors (5xx, timeouts): retry the same model with exponential backoff - Non-retryable errors (429, 4xx): skip to the next mode

(
	ctx context.Context,
	a *agent.Agent,
	primaryModel provider.Provider,
	messages []chat.Message,
	agentTools []tools.Tool,
	sess *session.Session,
	m *modelsdev.Model,
	events EventSink,
)

//
// Returns the stream result, the model that was used, and any error.
func (e *fallbackExecutor) execute(
	ctx context.Context,
	a *agent.Agent,
	primaryModel provider.Provider,
	messages []chat.Message,
	agentTools []tools.Tool,
	sess *session.Session,
	m *modelsdev.Model,
	events EventSink,
) (streamResult, provider.Provider, error) {
	fallbackModels := a.FallbackModels()
	fallbackRetries := getEffectiveRetries(a)
	modelChain := buildModelChain(primaryModel, fallbackModels)
	startIndex := e.chainStartIndex(a, len(fallbackModels))

	// One runtime.fallback span wraps the whole chain. Each per-model
	// CreateChatCompletionStream call below opens its own `chat {model}`
	// CLIENT child span via the provider decorator, so the fallback span
	// is a useful aggregate boundary (total attempts, final model,
	// terminal outcome) without duplicating per-model timing data.
	ctx, fbSpan := genai.StartFallback(ctx, a.Name(), primaryModel.ID().Model, startIndex > 0)
	defer fbSpan.End()

	var lastErr error
	primaryFailedWithNonRetryable := false
	hasFallbacks := len(fallbackModels) > 0

	for chainIdx := startIndex; chainIdx < len(modelChain); chainIdx++ {
		modelEntry := modelChain[chainIdx]

		// Each model in the chain gets (1 + retries) attempts for retryable errors.
		// Non-retryable errors (429 with fallbacks, 4xx) skip immediately to the next model.
		// 429 without fallbacks is retried directly on the same model.
		maxAttempts := 1 + fallbackRetries

		for attempt := range maxAttempts {
			// Check context before each attempt
			if ctx.Err() != nil {
				fbSpan.SetOutcome(genai.FallbackOutcomeContextCanceled)
				return streamResult{}, nil, ctx.Err()
			}
			fbSpan.IncrementAttempt()

			// Apply backoff before retry (not on first attempt of each model)
			if attempt > 0 {
				backoffDelay := backoff.Calculate(attempt - 1)
				logRetryBackoff(a.Name(), modelEntry.provider.ID(), attempt, backoffDelay)
				if !backoff.SleepWithContext(ctx, backoffDelay) {
					fbSpan.SetOutcome(genai.FallbackOutcomeContextCanceled)
					return streamResult{}, nil, ctx.Err()
				}
			}

			// Emit fallback event when transitioning to a new model (but not when starting in cooldown)
			if chainIdx > startIndex && attempt == 0 {
				logFallbackAttempt(a.Name(), modelEntry, attempt, fallbackRetries, lastErr)
				prevModelID := modelChain[chainIdx-1].provider.ID()
				reason := ""