Skip to content

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

3.5 KB
Raw Blame
package gateway

import (
	"context"
	"net/http"

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

// SubagentPick is a subagent's request put on the model the user set for
// its agent's subagents, in place of the one its lead asked for: Codex's
// (provider.CodexSubagentModel, willz on Discord) or Claude Desktop's
// (provider.DesktopSubagentModel). Kept says why it went on the model
// asked for instead, "" when it was put on To.
type SubagentPick struct {
	Asked string `json:"asked"`
	To    string `json:"to"`
	Kept  string `json:"kept,omitempty"`
}

// Moved says the request went on To.
func (p *SubagentPick) Moved() bool { return p != nil && p.Kept == "" }

type subagentPickKey struct{}

func withSubagentPick(r *http.Request, p *SubagentPick) *http.Request {
	if p == nil {
		return r
	}
	return r.WithContext(context.WithValue(r.Context(), subagentPickKey{}, p))
}

func subagentPickOf(r *http.Request) *SubagentPick {
	p, _ := r.Context().Value(subagentPickKey{}).(*SubagentPick)
	return p
}

// codexSubagentPick is what is done with the model of a request: nil when
// it isn't a Codex subagent's or no model is set for them, so the request
// goes on as asked. The model set must still be served, be able to open
// the subagent's task, and be one the gateway key may use; when it isn't,
// the request goes on the model asked for and the pick says why. Any
// model opens a task handed as text (a lead on a chat provider, #1633, or
// Codex's multi-agent V1). One the ChatGPT backend sealed, its lead having
// run there, is put only on a ChatGPT account's model, as it was before
// any other could be set; on any other the subagent stays where its lead
// put it, which serve's sealed gate (sealedReader) handles as it did with
// no model set, so setting one is never worse than leaving it unset. A
// relay that sealed the lead's task (#1109) is reached that way too: the
// lead names it.
func codexSubagentPick(r *http.Request, agent, kind, asked string, body []byte) *SubagentPick {
	// Codex by its token or by its User-Agent (fromCodex: its CLI, exec,
	// the IDE extension, the desktop app)
	if agent != "codex" && !fromCodex(r.Header) || usage.PurposeOf(kind) != "kind:collab_spawn" {
		return nil
	}
	to := provider.CodexSubagentModel()
	if to == "" || to == asked {
		return nil
	}
	pick := &SubagentPick{Asked: asked, To: to}
	if _, off := idOff(to); off {
		// the user disabled it (#1867): the subagent stays on its lead's
		// model, itself refused when it is disabled too
		pick.Kept = "it is disabled in magpie"
		return pick
	}
	if why := provider.CodexSubagentUnserved(to); why != "" {
		pick.Kept = why
		return pick
	}
	if !provider.CodexAccountModel(to) && sealedTaskIn(body) {
		pick.Kept = sealedKept
		return pick
	}
	if who, held := keyHolds(r); held {
		if p, model, ok := provider.Resolve(to); !ok || !modelAllowed(who, p, model) {
			pick.Kept = "the gateway key may not use it"
		}
	}
	return pick
}

// sealedKept is why a Codex subagent stayed on the model its lead asked
// for when the one set for its subagents can't open its task.
const sealedKept = "its task was sealed by the ChatGPT backend that answered its lead, and only a ChatGPT account can open it"

// sealedTaskIn says a request carries a sealed agent task, not only sealed
// messages: serve leaves those out with a note (withoutSealedMessages).
func sealedTaskIn(body []byte) bool {
	if !hasSealedAgentMessage(body) {
		return false
	}
	b, _ := withoutSealedMessages(body)
	return hasSealedAgentMessage(b)
}