Files
archie/internal/app/archiegateway/chat_runtime.go
T

154 lines
5.0 KiB
Go

package archiegateway
import (
"context"
"fmt"
"log/slog"
"time"
"github.com/samcharles93/ai-sdk/chat"
"github.com/samcharles93/ai-sdk/core"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/agentexec/modelloop"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/agentrun"
"github.com/samcharles93/archie-core/internal/gateway"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres"
"github.com/samcharles93/archie-core/internal/infrastructure/transcription"
"github.com/samcharles93/archie-core/internal/ratelimit"
"github.com/samcharles93/archie-core/internal/tools"
)
func (b *server) openChatSessions(ctx context.Context) error {
pool, err := postgres.OpenMigrated(ctx, b.cfg.DatabaseURL, "the conversation store")
if err != nil {
return fmt.Errorf("open conversation store: %w", err)
}
chatSessionStore := gateway.NewPostgresSessionStore(pool)
b.chatPool = pool
b.chatSessionStore = chatSessionStore
b.addCleanup(func() {
if err := chatSessionStore.Close(); err != nil {
b.log.ErrorContext(ctx, "close conversation store", "err", err)
}
})
return nil
}
func (b *server) claimGatewayOwnership(ctx context.Context) error {
ownership, err := postgres.AcquireOwnership(ctx, b.chatPool, postgres.OwnerGateway)
if err != nil {
return fmt.Errorf("claim gateway ownership: %w", err)
}
releaseCtx := context.WithoutCancel(ctx)
b.addCleanup(func() {
if err := ownership.Release(releaseCtx); err != nil {
b.log.ErrorContext(ctx, "release gateway ownership", "err", err)
}
})
return nil
}
func (b *server) setupTranscriber(cfg config.Config, log *slog.Logger) {
client, ok := transcription.New(cfg.Models, cfg.Providers, transcription.Options{
ResolveSecret: b.secrets.Resolve,
})
if ok {
b.transcriber = client
log.Info("voice transcription enabled")
} else if _, err := config.ResolveModel(cfg.Models, "", config.PurposeTranscription); err == nil {
log.Warn("voice transcription configured but unavailable; capability disabled")
}
}
func (b *server) startRateLimiter(ctx context.Context, cfg config.RateLimitConfig) {
if !cfg.Enabled() {
return
}
b.rateLimiter = ratelimit.New(cfg.Window, cfg.MaxRequests)
limiter := b.rateLimiter
go func() {
ticker := time.NewTicker(rateLimiterEvictInterval)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
limiter.EvictStale()
}
}
}()
}
// rebuildChatModelRuntime re-derives the gateway chat runtime's provider set
// after a live change to provider-settings or model-aliases. The
// turn runner reads the runtime through server.chatLLM, so the swap reaches its
// next turn without rebuilding the runner, and the model manager re-derives
// the aliases it offers.
func (b *server) rebuildChatModelRuntime(cfg config.Config) {
if b.chatModels == nil {
return // this process serves no chat turns
}
b.setLLM(modelloop.NewRuntime(executionProviders(cfg), cfg.ModelLimits))
b.chatModels.SetConfigured(cfg.Models)
catalog := b.catalogState()
b.chatModels.SetModelCatalog(catalog)
b.log.Info("chat model runtime rebuilt", "providers", len(cfg.Providers), "models", len(cfg.Models))
}
// sessionKey builds a deterministic session identifier from a gateway
// message's routing fields. Platform + channel + thread uniquely identify
// a conversation for session persistence and history retrieval.
func executionProviders(cfg config.Config) map[string]agentrun.Provider {
return agentexec.ProvidersFromConfig(cfg.Providers)
}
// chatGenerateOptions builds one chat turn's request.
func chatGenerateOptions(
ctx context.Context,
messages []chat.Message,
registry *tools.Registry,
maxSteps int,
limits modelloop.ToolLimits,
extra []tools.ToolEntry,
contextWindow int,
) (core.GenerateOptions, error) {
toolOpts := limits.Options()
if approval := gateway.ApprovalFromContext(ctx); approval != nil {
toolOpts.Approval = approval
}
// Progressive tool disclosure: compose the base registry with the per-turn
// extras into a turn-local registry (extras are identity-bound and cannot
// live in the process-wide registry), then let the ContextPressureGate
// decide whether to serve the full arsenal directly or fall back to the
// bridge tools. The bridge tools are never registered process-wide, so they
// stay inside this composed, per-turn registry.
composed, err := tools.ComposeForTurn(registry, extra)
if err != nil {
return core.GenerateOptions{}, err
}
gate := tools.NewContextPressureGate(contextWindow)
gate.Evaluate(composed.All())
toolSet, err := modelloop.BuildToolSetFrom(gate.FilterTools(composed), toolOpts)
if err != nil {
return core.GenerateOptions{}, err
}
if maxSteps <= 0 {
maxSteps = defaultChatMaxSteps
}
return core.GenerateOptions{
Messages: messages,
Tools: toolSet,
MaxParallelToolCalls: modelloop.MaxParallelToolCalls,
MaxSteps: maxSteps,
}, nil
}
const defaultChatMaxSteps = 100
const rateLimiterEvictInterval = time.Minute