Cyrene_v2/internal/runtime/loop/request.go

package loop

import (
	"context"

	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/agent"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/capacity"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/model"
)

// buildRequest assembles a model.Request from the agent's public surface,
// mirroring agent.buildRequest so the streaming path behaves identically to
// RunStep (leading instruction message, tool schemas, model routing).
func (l *Loop) buildRequest(ctx context.Context, messages []model.Message) model.Request {
	req := model.Request{
		Model:           l.agent.Model(),
		Messages:        l.assembleMessages(messages),
		Temperature:     l.temperature(),
		MaxTokens:       l.agent.MaxTokens(),
		Purpose:         l.agent.Purpose(),
		Tools:           l.toolSchemas(ctx, messages),
		Thinking:        l.thinking,
		ReasoningEffort: l.reasoningEffort,
	}
	if l.agent.Router() != nil {
		if m, _ := l.agent.Router().RouteRequest(req); m != "" {
			req.Model = m
		}
	}
	return req
}

// assembleMessages prepends the agent's instructions as a leading system message
// when they are non-empty, otherwise returns the input slice unchanged.
func (l *Loop) assembleMessages(messages []model.Message) []model.Message {
	instr := l.agent.Instructions()
	if instr == "" {
		return messages
	}
	out := make([]model.Message, 0, len(messages)+1)
	out = append(out, model.TextMessage(model.RoleSystem, instr))
	out = append(out, messages...)
	return out
}

// temperature returns a pointer to the configured temperature, mapping zero to
// nil so the provider default applies (matching the agent package).
func (l *Loop) temperature() *float64 {
	t := l.agent.Temperature()
	if t == 0 {
		return nil
	}
	return &t
}

// toolSchemas advertises the registered tool schemas to the model, or nil when no
// dispatcher is configured. When a capacity decider is wired and enabled, it
// classifies the current round and returns only the allowed set for that state
// (a view over the dispatcher, per design/14 §4): the model sees/invokes only
// the allowed tools, while Invoke itself stays unblocked. A nil or disabled
// decider keeps the pre-existing behavior (every tool advertised).
//
// The design/11 §3 security gate runs last over whatever the capacity view left:
// in a group/stranger environment only tools whose editable marker allows that
// environment are advertised (default closed), and the owner environment keeps
// the full set. Security is a hard red line, not a convenience hint, so it can
// only shrink the surface — it never re-admits a tool capacity excluded.
func (l *Loop) toolSchemas(ctx context.Context, messages []model.Message) []model.ToolSpec {
	d := l.dispatcher()
	if d == nil {
		return nil
	}
	schemas := d.ToolSchemas()
	if l.capacity == nil || !l.capacity.Enabled() {
		return l.restrictSchemas(ctx, d, schemas)
	}

	names := make([]string, 0, len(schemas))
	for _, s := range schemas {
		names = append(names, s.Name)
	}
	acc := capState(ctx)
	dec := l.capacity.Decide(ctx, capacity.Input{
		Messages:     capacityTexts(messages),
		CurrentState: acc.state,
		AllToolNames: names,
		Recall:       l.capacityRecall(ctx, messages),
	})
	acc.state = dec.State
	if l.onCapacity != nil && !isMutedBroadcast(ctx) {
		sessionID := loopSession(ctx)
		for _, ev := range dec.Events {
			ev.SessionID = sessionID
			l.onCapacity(ev)
		}
	}

	allowed := make(map[string]bool, len(dec.AllowedTools))
	for _, n := range dec.AllowedTools {
		allowed[n] = true
	}
	out := make([]model.ToolSpec, 0, len(dec.AllowedTools))
	for _, s := range schemas {
		if allowed[s.Name] {
			out = append(out, s)
		}
	}
	return l.restrictSchemas(ctx, d, out)
}

// capacityTexts extracts the recent conversation text for the capacity decider:
// the last few non-system/non-tool turns, in chronological order (oldest first),
// so the decider's current-turn window sees the latest user message last.
func capacityTexts(messages []model.Message) []string {
	texts := make([]string, 0, 6)
	for i := len(messages) - 1; i >= 0 && len(texts) < 6; i-- {
		m := messages[i]
		if m.Role == model.RoleSystem || m.Role == model.RoleTool {
			continue
		}
		if t := messageText(m); t != "" {
			texts = append(texts, t)
		}
	}
	for i, j := 0, len(texts)-1; i < j; i, j = i+1, j-1 {
		texts[i], texts[j] = texts[j], texts[i]
	}
	return texts
}

// capacityRecallTopK bounds how many recalled habit memories the capacity L4 layer
// considers per round.
const capacityRecallTopK = 5

// capacityRecall retrieves the owner's relevant long-term memories for the capacity
// L4 habit-alignment layer (design §2.2 L4), the memory feed that lets the decider
// learn the user's task-expression habits. It returns nil (keeping L4 silent) when
// no retriever/persona is configured — backward compatible — or in a restricted
// (group chat / stranger) context, per the isolation red line: L4 learns the owner's
// habits and must never read owner-sensitive memory into a group or stranger intent
// decision (design §2.2 红线: 不读陌生人敏感).
func (l *Loop) capacityRecall(ctx context.Context, messages []model.Message) []capacity.RecallItem {
	if l.retriever == nil || l.personaID == "" {
		return nil
	}
	env := sessionEnvFrom(ctx)
	if env.Restricted() {
		return nil
	}
	results, err := l.retriever.Retrieve(ctx, l.personaID, queryFromMessages(messages), capacityRecallTopK)
	if err != nil {
		l.log.Warn("capacity recall", "error", err, "env", env.ActorEnv)
		return nil
	}
	items := make([]capacity.RecallItem, 0, len(results))
	for _, r := range results {
		items = append(items, capacity.RecallItem{
			Content: r.Item.Content,
			Scope:   string(r.Item.Scope),
			Kind:    string(r.Item.Kind),
			Tags:    r.Item.Tags,
			Score:   r.Score,
		})
	}
	return items
}

// decodeToolCalls decodes tool calls from a model.Response via the agent's shared
// decoder, so the streaming and non-streaming paths agree on the provider-native
// tool calls the adapters emit (Anthropic tool_use / OpenAI tool_calls) as well
// as the legacy JSON-envelope convention. It reports ok=true (with a non-empty
// slice) when a call is decoded.
func decodeToolCalls(resp model.Response) ([]agent.ToolCall, bool) {
	return agent.ExtractToolCalls(resp)
}