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.
229 lines
9.5 KiB
Go
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
|
|
}
|