Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

2.8 KB
Raw Blame
package gateway

import (
	"context"

	"github.com/yetone/magpie/internal/provider"
)

// claudeFastBeta is the beta Claude's fast mode (speed "fast") is asked
// under.
const claudeFastBeta = "fast-mode-2026-02-01"

// withFast asks for the vendor's fast mode in the agent's own protocol, as
// a group's member sent fast is (provider.Group.Fast): priority processing
// in OpenAI's words, speed "fast" in Anthropic's. A request carried on in
// another protocol keeps it (Request.Fast), and goes out with it only
// where the vendor and model have one (buildResponses, buildChat, build,
// cursorModelID). A client's own ask for Ultrafast, faster than priority,
// is kept: sent fast, it isn't sent slower than it asked (#1784,
// zhenghaowen0967: OMP with fastPicks asked Ultrafast and went as
// priority). An account that doesn't offer it is asked for priority in
// its place, as any is (tierMate).
func withFast(proto provider.Protocol, body []byte) []byte {
	switch proto {
	case provider.Chat, provider.Responses:
		if askedTier(body) == "ultrafast" {
			return body
		}
		return withFields(body, map[string]any{"service_tier": "priority"})
	case provider.Anthropic:
		return withFields(body, map[string]any{"speed": "fast"})
	}
	return body
}

// fastPick sends the model an agent picked to be sent fast (#954) so:
// every account and key of it, not a fallback to another. Ultra sends it
// as Ultrafast where the account offers that (#1954).
func fastPick(cands []candidate, pl planned, providerID, model string, ultra bool) {
	for i, c := range cands {
		if c.p.ID == providerID && c.model == model {
			cands[i].fast, cands[i].ultra = true, ultra
		}
	}
	for _, ws := range [][]Weighed{pl.order, pl.left} {
		for i, w := range ws {
			if w.Provider == providerID && w.Model == model {
				ws[i].Fast = true
			}
		}
	}
}

// ownFastKey marks a try of a member or pick the user sent fast on a
// provider they added by its address (provider.OwnFast, #1615): it is asked for service_tier
// "priority" on its OpenAI API (forwardTranslated) whatever API the agent
// spoke. An agent on Chat or Responses says it in its own body as well
// (withFast), which a relayed request carries as it is.
type ownFastKey struct{}

func withOwnFast(ctx context.Context) context.Context {
	return context.WithValue(ctx, ownFastKey{}, true)
}

func isOwnFast(ctx context.Context) bool {
	v, _ := ctx.Value(ownFastKey{}).(bool)
	return v
}

// ultraKey marks a try of a pick sent Ultrafast (#1954) from an agent on
// Claude's API: its speed "fast" goes to the ChatGPT backend as Ultrafast
// (forwardTranslated), on an account that offers it.
type ultraKey struct{}

func withUltra(ctx context.Context) context.Context {
	return context.WithValue(ctx, ultraKey{}, true)
}

func isUltra(ctx context.Context) bool {
	v, _ := ctx.Value(ultraKey{}).(bool)
	return v
}