Files
archie/internal/app/archiegateway/gateway_runtime.go
T
sam 8bcd89e050 fix(gateway): name a plan wait's workflow from its run, not the next one
workflow.approve pre-writes the task's workflow column with the workflow
that runs once approved, so task_list named a workflow that had not
started while the task's own log named the one that produced the plan.
Chat now names the compiled workflow through the pinned definition for a
plan wait, matching the log.
2026-10-26 18:32:25 +11:00

229 lines
9.5 KiB
Go

package archiegateway
import (
"context"
"fmt"
"log/slog"
"github.com/samcharles93/archie-core/internal/agentexec/modelloop"
"github.com/samcharles93/archie-core/internal/app/chattask"
"github.com/samcharles93/archie-core/internal/app/servicekit"
"github.com/samcharles93/archie-core/internal/buildinfo"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/agent"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/domain/taskactions"
"github.com/samcharles93/archie-core/internal/gateway"
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanestore"
"github.com/samcharles93/archie-core/internal/taskstate"
"github.com/samcharles93/archie-core/internal/tools"
)
// setupChatRuntime wires the model runtime, tool registry, SOUL,
// chat task creator/controller, default chat identity and the release-update
// service. The daemon and the standalone Gateway build through this one
// constructor so the two processes cannot diverge.
func (b *server) setupChatRuntime(ctx context.Context, cfg config.Config, actor gateway.ChatTaskActor) error {
// ── LLM runtime ──────────────────────────────────────────────────
// Created before the router so the LLMResponder can be wired in for
// non-command message processing.
providers := executionProviders(cfg)
b.setLLM(modelloop.NewRuntime(providers, cfg.ModelLimits))
// Transcription is a model-alias capability, like the chat models it sits
// beside: it is built here, on the model-owning side, from this process's
// own [models]/[providers]. The Messaging Service carries a voice note's
// bytes to the Gateway and never holds the credential.
b.setupTranscriber(cfg, b.log)
b.toolReg = tools.NewRegistry()
chatModels := newChatModelManager(cfg.Models)
catalog := b.catalogState()
chatModels.SetModelCatalog(catalog)
b.chatModels = chatModels
// ── SOUL ─────────────────────────────────────────────────────────
if b.soul == nil {
soul, version, err := b.controlPlane.Soul(ctx)
if err != nil {
return fmt.Errorf("load soul: %w", err)
}
b.soul = newSoulSource(b.cfgPath, b.log)
b.applySoul(soul, version)
b.applyStatus.Report(ctx, controlplanestore.SoulKind, version, nil)
if err := b.watchSoul(ctx, version); err != nil {
return fmt.Errorf("watch soul: %w", err)
}
}
// ── Operator health surface ──────────────────────────────────────
// Built before the gateways because every turn runner and router built
// later carries both: the recorder is written by sendChatTurn, the source
// is read by /status.
b.providerOutcomes = newProviderOutcomeRecorder()
b.usage = &usageSink{models: b.chatModels, log: b.log}
if b.stateStore != nil {
b.usage.store = b.stateStore
b.chatModels.orgAliases = func(ctx context.Context) (map[string]string, error) {
_, aliases, err := b.stateStore.CallerModels(ctx)
return aliases, err
}
}
b.statusHealth = newStatusHealth(b)
b.setupChatTasks(cfg)
b.chatController = gateway.NewStoreTaskController(chatTaskControllerAdapter{
taskByID: b.stateStore.TaskByID,
// Chat's /approve reaches the daemon's one task-action service rather
// than its own requeue, so a chat approval and a dashboard approval
// cannot record different decisions for one operator intent
approve: func(ctx context.Context, scope *string, by taskactions.Actor, taskID int64, res taskactions.ActionPayload) error {
_, err := actor.ApplyChatTaskAction(ctx, scope, by, taskID, taskstate.ActionApprove, res)
return err
},
cancelExecution: b.stateStore.CancelExecution,
})
b.updateService = makeUpdateService(b.controlPlane, cfg)
return nil
}
// setupChatTasks wires the task creator chat commands and scheduled workflows
// enqueue through.
func (b *server) setupChatTasks(cfg config.Config) {
profiles, defaultChatIdentity := chattask.Profiles(cfg)
if len(profiles) > 0 {
b.chatTasks = gateway.NewStoreTaskCreatorForProfiles(
chattask.Writer{Enqueue: b.stateStore.EnqueueChatTask},
profiles,
)
}
b.defaultChatIdentity = defaultChatIdentity
}
// watchStatus is KeepWatch carrying the outage bookkeeping: an applied
// refusal becomes the record's error, a stream failure and a stream end
// report the gap, and a re-established watch clears it, so a record never
// reads the boot version as current while no live updates can arrive.
func watchStatus[T any](
ctx context.Context,
report func(ctx context.Context, kind string, version int64, err error),
log *slog.Logger,
kind, label string, version int64, updates <-chan T,
open func(ctx context.Context, after int64) (<-chan T, error),
versionOf func(T) int64,
errOf func(T) error,
deliver func(T) error,
) {
var lastApplyErr, streamErr error
watchOpen := func(ctx context.Context, after int64) (<-chan T, error) {
next, err := open(ctx, after)
if err == nil {
report(ctx, kind, after, lastApplyErr)
}
return next, err
}
go servicekit.KeepWatch(ctx, log, kind, version, updates,
watchOpen,
servicekit.WaitFor,
versionOf,
func(update T) {
if err := errOf(update); err != nil {
if v := versionOf(update); v > 0 {
lastApplyErr = err
report(ctx, kind, v, err)
} else {
streamErr = err
}
log.ErrorContext(ctx, "control-plane watch failed", "kind", kind, "err", err)
return
}
lastApplyErr = deliver(update)
report(ctx, kind, versionOf(update), lastApplyErr)
},
func() {
// A refusal already on the record outranks the outage; it is the
// state the settings are actually in.
if lastApplyErr != nil {
return
}
if streamErr == nil {
streamErr = fmt.Errorf("control-plane watch stream ended")
}
report(ctx, kind, 0, fmt.Errorf("%s watch unavailable: %w", label, streamErr))
streamErr = nil
})
}
// watchSoul keeps the soul stream established for the life of the process, so
// a dashboard edit reaches the next turn without a restart. The stream rides
// the same outage bookkeeping as curators (watchStatus).
func (b *server) watchSoul(ctx context.Context, version int64) error {
updates, err := b.controlPlane.WatchSoul(ctx, version)
if err != nil {
return err
}
watchStatus(ctx, b.applyStatus.Report, b.log,
controlplanestore.SoulKind, "soul", version, updates,
b.controlPlane.WatchSoul,
func(update controlplanestore.AppliedSoul) int64 { return update.Version },
func(update controlplanestore.AppliedSoul) error { return update.Err },
func(update controlplanestore.AppliedSoul) error {
b.applySoul(update.Soul, update.Version)
return nil
})
return nil
}
func (b *server) applySoul(soul agent.Soul, version int64) {
b.soul.apply(soul.Text)
b.log.Info("soul applied", "version", version)
}
// setupGatewayChat is the sole production constructor of the local contract.
// Frontends use its gRPC representation; only this service owns the router.
func (b *server) setupGatewayChat(ctx context.Context, actor gateway.ChatTaskActor) (gateway.ChatContract, error) {
if err := b.setupChatRuntime(ctx, b.cfg, actor); err != nil {
return nil, err
}
cfg := b.cfg
router := gateway.NewRouter(b.stateStore, nil, "web")
router.Settings = messaging.NewSettingsCommand(controlplanerpc.NewSettingsClient(b.stateStore.ControlPlane())).WithIdentities(b.stateStore)
router.Limiter = b.rateLimiter
router.Version = fmt.Sprintf("Archie\nGateway: %s\nRuntime: %s", buildinfo.Version, buildinfo.Runtime)
router.Models = b.chatModels
router.Updates = b.updateService
router.InitSessions(b.chatSessionStore)
configureTaskCommands(router, b.chatTasks, b.chatController, chatTaskListerAdapter{tasks: b.stateStore.Tasks, task: b.stateStore.TaskByID}, b.defaultChatIdentity)
router.Health = b.statusHealth
// ToolLimits reads the live holder, not cfg: the runtime-resource
// watch republishes a tool-settings change through it, so a policy edit
// applies to the next turn in the process that serves this runner.
setup := chatSetup{
Cfg: config.NewHolder(cfg),
ToolLimits: func() modelloop.ToolLimits { return toolLimits(b.cfgHolder.Get()) },
LLM: b.chatLLM, ChatModels: b.chatModels, ToolReg: b.toolReg,
Soul: b.soul, ChatTasks: b.chatTasks,
ChatTaskLister: chatTaskListerAdapter{tasks: b.stateStore.Tasks, task: b.stateStore.TaskByID},
ChatTaskLogs: chatTaskLogReaderAdapter{tasks: b.stateStore.TaskByID, taskLogs: b.stateStore},
ChatTaskActor: actor,
DefaultChatIdentity: b.defaultChatIdentity,
Bus: b.bus, Log: b.log,
MemoryEngine: b.memoryStore(),
MemoryWriter: b.memoryWriter(),
// The transcription capability is built beside the chat runtime, from
// the model-role configuration only this process reads.
Transcriber: b.transcriber,
// The Gateway executes the web chat's turns, so it is the process
// that must record their outcomes for /status.
ProviderOutcomes: b.providerOutcomes,
Usage: b.usage,
}
router.LLM, router.LLMStream = makeChatLLMResponder(ctx, "web", setup, b.chatSessionStore, router)
router.Titles = newChatTitleGenerator(setup)
router.Log = b.log
return &gateway.LocalChatAdapter{
Router: router, Sessions: b.chatSessionStore, Turns: gateway.NewTurns(b.log),
Models: b.chatModels, TaskActor: actor, Tasks: b.stateStore,
VoiceAvailable: b.transcriber != nil,
}, nil
}