Archie runs its own agent loop only. Removes Kit resolution and launch, the harness runner and adapters, the setup terminal and sandbox view, harness secrets and OAuth capture (table dropped in migration 0075), the task-tools contract that only Kit containers reached, and the sandbox-kit-spec dependency. Agent profiles carry image and tools only. The egress proxy keeps the model-session path; the sandbox relay code stays for #1867.
242 lines
8.7 KiB
Go
242 lines
8.7 KiB
Go
package archiegateway
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/samcharles93/ai-sdk/provider/minimax"
|
|
|
|
"github.com/samcharles93/archie-core/internal/agentexec/modelloop"
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/domain/access"
|
|
"github.com/samcharles93/archie-core/internal/domain/binding"
|
|
"github.com/samcharles93/archie-core/internal/domain/eventtype"
|
|
"github.com/samcharles93/archie-core/internal/gateway"
|
|
infraaccess "github.com/samcharles93/archie-core/internal/infrastructure/access"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanerpc"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/issuerpc"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/taskmcp"
|
|
"github.com/samcharles93/archie-core/internal/plugin"
|
|
"github.com/samcharles93/archie-core/internal/tools/mcp"
|
|
minimaxtool "github.com/samcharles93/archie-core/internal/tools/minimax"
|
|
toolprovider "github.com/samcharles93/archie-core/internal/tools/provider"
|
|
builtintoolprovider "github.com/samcharles93/archie-core/internal/tools/provider/builtin"
|
|
"github.com/samcharles93/archie-core/internal/tools/sendfile"
|
|
"github.com/samcharles93/archie-core/internal/tools/webfetch"
|
|
)
|
|
|
|
func (b *server) registerTools() error {
|
|
cfg, log := b.cfgHolder.Get(), b.log
|
|
b.providerRegistry = toolprovider.NewRegistry(b.toolReg)
|
|
b.mcpMu.Lock()
|
|
b.mcpApplied = make(map[string]appliedMCPServer, len(cfg.Tools.MCPServers))
|
|
b.mcpMu.Unlock()
|
|
if workspace := cfg.Chat.Workspace; workspace != "" {
|
|
unrestricted := cfg.Chat.UnrestrictedFilesystem
|
|
// A workspace chosen in the dashboard names a directory nobody has
|
|
// created yet; every file tool would fail on it.
|
|
if err := os.MkdirAll(workspace, 0o700); err != nil {
|
|
log.Error("create chat workspace", "workspace", workspace, "err", err)
|
|
}
|
|
if err := b.providerRegistry.Register(builtintoolprovider.New(workspace, unrestricted)); err != nil {
|
|
log.Error("workspace tool provider registration failed", "err", err)
|
|
return err
|
|
}
|
|
|
|
log.Info("workspace tools enabled",
|
|
"workspace", workspace, "unrestricted_filesystem", unrestricted)
|
|
} else {
|
|
log.Info("workspace tools disabled (chat.workspace is unset)")
|
|
}
|
|
for _, srv := range cfg.Tools.MCPServers {
|
|
provider, err := b.buildMCPProvider(srv)
|
|
if err != nil {
|
|
log.Warn("mcp tool provider skipped", "name", srv.Name, "err", err)
|
|
continue
|
|
}
|
|
|
|
if err := b.providerRegistry.RegisterOptional(provider); err != nil {
|
|
log.Warn("mcp tool provider skipped", "name", srv.Name, "err", err)
|
|
continue
|
|
}
|
|
b.mcpMu.Lock()
|
|
b.mcpApplied[strings.TrimSpace(srv.Name)] = appliedMCPServer{server: srv, id: provider.Manifest().ID}
|
|
b.mcpMu.Unlock()
|
|
}
|
|
if err := b.capabilityHost.Register(b.providerRegistry); err != nil {
|
|
log.Error("tool-provider capability registration failed", "err", err)
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (b *server) registerStandaloneTools(ctx context.Context) {
|
|
cfg, log := b.cfg, b.log
|
|
|
|
if spillDir := cfg.Tools.Policy.SpillDir; spillDir != "" {
|
|
if err := toolLimits(cfg).EnsureSpillDir(); err != nil {
|
|
log.WarnContext(ctx, "tool spill directory unavailable; large results will be truncated instead", "err", err)
|
|
} else if ws := cfg.Chat.Workspace; ws != "" && !cfg.Chat.UnrestrictedFilesystem && !isWithin(ws, spillDir) {
|
|
log.WarnContext(ctx, "tool spill directory is outside chat.workspace; the model cannot read back what is spilled there",
|
|
"spill_dir", spillDir, "workspace", ws)
|
|
}
|
|
}
|
|
|
|
b.registerWebFetchTool(cfg)
|
|
|
|
if entry := sendfile.Tool(cfg.Chat.Workspace); entry != nil {
|
|
if err := b.toolReg.Register(*entry); err != nil {
|
|
log.WarnContext(ctx, "send_file registration failed", "err", err)
|
|
} else {
|
|
log.InfoContext(ctx, "file sending enabled", "workspace", cfg.Chat.Workspace)
|
|
}
|
|
} else {
|
|
log.InfoContext(ctx, "file sending disabled (chat.workspace is unset)")
|
|
}
|
|
|
|
b.registerMinimaxTool(cfg, log)
|
|
b.registerWorkflowTools(ctx)
|
|
}
|
|
|
|
// registerWorkflowTools puts the workflow and integration tools in the shared
|
|
// registry, so chat turns reach them, each in its caller's org.
|
|
func (b *server) registerWorkflowTools(ctx context.Context) {
|
|
authz := infraaccess.StartLive(ctx, b.stateStore.ListPolicies, b.stateStore.PoliciesVersion, b.log)
|
|
workflows := controlplanerpc.NewWorkflows(b.stateStore.ControlPlane())
|
|
entries := append(gateway.WorkflowTools(workflows, authz), gateway.IntegrationTools(integrationSource{Workflows: workflows, store: b.stateStore}, authz)...)
|
|
// Run-inspection tools back long-running curators (self-intake first);
|
|
// the State Store client satisfies the source directly.
|
|
entries = append(entries, gateway.RunTools(b.stateStore, authz)...)
|
|
// Issue tools reach the forge through the daemon, which alone holds its
|
|
// credentials; without the broker connection they are not registered.
|
|
if b.taskActionsConn != nil {
|
|
entries = append(entries, gateway.IssueTools(issuerpc.Client{Conn: b.taskActionsConn, Timeout: 30 * time.Second}, authz)...)
|
|
}
|
|
for _, entry := range entries {
|
|
if err := b.toolReg.Register(entry); err != nil {
|
|
b.log.WarnContext(ctx, "workflow tool registration failed", "tool", entry.Name, "err", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// integrationSource reads settings through the control plane and event types,
|
|
// bindings and access policies through the State Store.
|
|
type integrationSource struct {
|
|
controlplanerpc.Workflows
|
|
store *staterpc.Client
|
|
}
|
|
|
|
func (s integrationSource) EventTypes(ctx context.Context) ([]eventtype.EventType, error) {
|
|
return s.store.ListEventTypes(ctx)
|
|
}
|
|
|
|
func (s integrationSource) Bindings(ctx context.Context) ([]binding.Binding, error) {
|
|
return s.store.ListBindings(ctx)
|
|
}
|
|
|
|
func (s integrationSource) Policies(ctx context.Context) ([]access.Policy, error) {
|
|
return s.store.ListPolicies(ctx)
|
|
}
|
|
|
|
func (b *server) registerWebFetchTool(cfg config.Config) {
|
|
log := b.log
|
|
entry := webfetch.Tool(webfetch.Config{
|
|
Enabled: cfg.Tools.WebFetch.IsEnabled(),
|
|
Timeout: cfg.Tools.WebFetch.Timeout.Std(),
|
|
MaxBytes: cfg.Tools.WebFetch.MaxBytes,
|
|
AllowPrivateNetworks: cfg.Tools.WebFetch.AllowPrivateNetworks,
|
|
})
|
|
if entry == nil {
|
|
log.Info("web fetch disabled")
|
|
return
|
|
}
|
|
if err := b.toolReg.Register(*entry); err != nil {
|
|
log.Warn("web_fetch registration failed", "err", err)
|
|
return
|
|
}
|
|
log.Info("web fetch enabled",
|
|
"allow_private_networks", cfg.Tools.WebFetch.AllowPrivateNetworks)
|
|
}
|
|
|
|
func (b *server) registerMinimaxTool(cfg config.Config, log *slog.Logger) {
|
|
if !cfg.Tools.Minimax.IsEnabled() {
|
|
log.Info("minimax video generation disabled")
|
|
return
|
|
}
|
|
|
|
apiKey, err := b.secrets.Resolve(cfg.Tools.Minimax.APIKey)
|
|
if err != nil {
|
|
log.Warn("minimax video generation enabled but the API key failed to resolve; tool not registered", "err", err)
|
|
return
|
|
}
|
|
if apiKey == "" {
|
|
log.Warn("minimax video generation enabled but no API key is configured; tool not registered")
|
|
return
|
|
}
|
|
|
|
provider, err := minimax.New(minimax.Config{APIKey: apiKey, BaseURL: cfg.Tools.Minimax.BaseURL})
|
|
if err != nil {
|
|
log.Warn("minimax video generation enabled but the provider could not be built; tool not registered", "err", err)
|
|
return
|
|
}
|
|
|
|
entry := minimaxtool.Tool(provider)
|
|
if entry == nil {
|
|
return
|
|
}
|
|
if err := b.toolReg.Register(*entry); err != nil {
|
|
log.Warn("generate_video registration failed", "err", err)
|
|
return
|
|
}
|
|
log.Info("minimax video generation enabled")
|
|
}
|
|
|
|
// toolLimits reads the configured per-turn result limits.
|
|
func toolLimits(cfg config.Config) modelloop.ToolLimits {
|
|
return modelloop.ToolLimits{
|
|
MaxResultChars: cfg.Tools.Policy.MaxResultChars,
|
|
SpillDir: cfg.Tools.Policy.SpillDir,
|
|
}
|
|
}
|
|
|
|
// isWithin reports whether target sits inside base.
|
|
func isWithin(base, target string) bool {
|
|
absBase, err := filepath.Abs(base)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
absTarget, err := filepath.Abs(target)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
rel, err := filepath.Rel(absBase, absTarget)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator))
|
|
}
|
|
|
|
func configuredMCPProvider(server config.MCPServer, workDir string, sampling mcp.SamplingHandler) (toolprovider.Engine, error) {
|
|
cacheDir := ""
|
|
if workDir != "" {
|
|
cacheDir = filepath.Join(workDir, "mcp-npm-cache")
|
|
}
|
|
provider, _, err := taskmcp.NewProvider(server, sampling, cacheDir)
|
|
return provider, err
|
|
}
|
|
|
|
func shutdownCapabilityHost(ctx context.Context, capabilityHost *plugin.Host, log *slog.Logger) func() {
|
|
return func() {
|
|
stopCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 10*time.Second)
|
|
defer cancel()
|
|
if err := capabilityHost.Stop(stopCtx); err != nil {
|
|
log.ErrorContext(ctx, "capability host shutdown", "err", err)
|
|
}
|
|
}
|
|
}
|