Adaptive reasoning and direct Cursor mode

cmd/antares/main.go

@@ -20,6 +20,8 @@ import (
 	"github.com/enowdev/antares/internal/commands"
 	"github.com/enowdev/antares/internal/config"
 	"github.com/enowdev/antares/internal/cron"
+	"github.com/enowdev/antares/internal/cursor"
+	"github.com/enowdev/antares/internal/cursorrun"
 	"github.com/enowdev/antares/internal/gateway"
 	"github.com/enowdev/antares/internal/httpshim"
 	"github.com/enowdev/antares/internal/hub"
@@ -196,16 +198,50 @@ func cmdTUI() error {
 // runtimeServices bundles everything a running server needs, so a config reload
 // can rebuild the pieces that depend on configuration.
 type runtimeServices struct {
-	mu      sync.Mutex
-	cfg     *config.Config
-	db      store.Store
-	shell   *tools.ShellManager
-	agent   *agent.Agent
-	skills  *skills.Manager
-	cron    *cron.Runner
-	gateway *gateway.Manager
-	mcp     *mcp.Manager
-	social  *socialbrowser.Manager
+	mu           sync.Mutex
+	cfg          *config.Config
+	db           store.Store
+	shell        *tools.ShellManager
+	agent        *agent.Agent
+	skills       *skills.Manager
+	cron         *cron.Runner
+	gateway      *gateway.Manager
+	mcp          *mcp.Manager
+	social       *socialbrowser.Manager
+	cursorRunner cursorrun.Runner
+}
+
+func newRuntimeCursorRunner(ag *agent.Agent) cursorrun.Runner {
+	return cursorrun.New(cursorrun.Options{
+		ResolveClient: func() (cursor.Options, error) {
+			if ag == nil {
+				return cursor.Options{}, errors.New("Cursor is unavailable in this runtime")
+			}
+			cfg := ag.Config()
+			if cfg == nil {
+				return cursor.Options{}, errors.New("Cursor is unavailable in this runtime")
+			}
+			_, provider := cfg.ResolveProvider("cursor")
+			provider.APIKey = strings.TrimSpace(provider.APIKey)
+			options := cursor.Options{
+				BaseURL: provider.BaseURL,
+				APIKey:  provider.APIKey,
+			}
+			if !provider.Enabled || provider.APIKey == "" {
+				return options, cursorrun.ErrNotConfigured
+			}
+			return options, nil
+		},
+		Now:        time.Now,
+		CatalogTTL: 5 * time.Minute,
+	})
+}
+
+func (rt *runtimeServices) setCursorRunner(runner cursorrun.Runner) {
+	rt.cursorRunner = runner
+	if rt.agent != nil {
+		rt.agent.SetCursorRunner(runner)
+	}
 }
 
 func bootstrap(ctx context.Context) (*runtimeServices, error) {
@@ -294,6 +330,7 @@ func bootstrap(ctx context.Context) (*runtimeServices, error) {
 	ag.SetRoles(roleReg)
 
 	rt := &runtimeServices{cfg: cfg, db: db, shell: shell, agent: ag, skills: skillMgr}
+	rt.setCursorRunner(newRuntimeCursorRunner(ag))
 	rt.social = socialbrowser.New()
 	ag.SetSocialBrowser(rt.social)
 
@@ -422,14 +459,18 @@ func (rt *runtimeServices) messageIsRelevant(ctx context.Context, b *config.Bind
 		"\n\nMessage:\n" + strings.TrimSpace(text) +
 		"\n\nDoes this message fit the criteria and deserve a reply? Answer with exactly one word: YES or NO."
 
+	reasoningEffort := ""
+	if err := rt.agent.ValidateReasoningEffort(ctx, b.Model, "low"); err == nil {
+		reasoningEffort = "low"
+	}
 	var out strings.Builder
 	_, err := rt.agent.Run(ctx, agent.Request{
 		Message:         prompt,
 		Model:           b.Model, // use the binding's model (or default) for the gate
 		Toolset:         "minimal",
 		Quiet:           true,
 		MaxTurns:        1,
-		ReasoningEffort: "low",
+		ReasoningEffort: reasoningEffort,
 	}, func(e agent.Event) error {
 		if e.Type == agent.EventText {
 			out.WriteString(e.Delta)
@@ -606,6 +647,7 @@ func cmdServeForeground() error {
 		Gateway: rt.gateway,
 		MCP:     rt.mcp,
 		Social:  rt.social,
+		Cursor:  rt.cursorRunner,
 	})
 
 	if rt.cfg.Cron.Enabled {

cmd/antares/provider_test.go

@@ -1,12 +1,20 @@
 package main
 
 import (
+	"context"
+	"encoding/json"
 	"io"
+	"net/http"
+	"net/http/httptest"
 	"os"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"testing"
 
+	"github.com/enowdev/antares/internal/agent"
 	"github.com/enowdev/antares/internal/config"
+	"github.com/enowdev/antares/internal/tools"
 )
 
 func TestProviderAddAndUseCursorPreserveActiveModel(t *testing.T) {
@@ -49,6 +57,94 @@ func TestProviderAddAndUseCursorPreserveActiveModel(t *testing.T) {
 	}
 }
 
+func TestRuntimeCursorRunnerUsesAtomicConfigAndInvalidatesOnReload(t *testing.T) {
+	var calls atomic.Int32
+	var version atomic.Int32
+	version.Store(1)
+	var authMu sync.Mutex
+	var authorizations []string
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet || r.URL.Path != "/v1/models" {
+			t.Errorf("request = %s %s, want GET /v1/models", r.Method, r.URL.Path)
+			http.NotFound(w, r)
+			return
+		}
+		calls.Add(1)
+		authMu.Lock()
+		authorizations = append(authorizations, r.Header.Get("Authorization"))
+		authMu.Unlock()
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"items": []any{map[string]any{
+				"id": "model-" + string(rune('0'+version.Load())),
+			}},
+		})
+	}))
+	defer upstream.Close()
+
+	cfg := config.Default()
+	provider := cfg.Providers["cursor"]
+	provider.Enabled = true
+	provider.APIKey = "runtime-key-one"
+	provider.BaseURL = upstream.URL
+	cfg.Providers["cursor"] = provider
+	ag := agent.New(cfg, nil, tools.NewRegistry(), nil, nil)
+	rt := &runtimeServices{cfg: cfg, agent: ag}
+	runner := newRuntimeCursorRunner(ag)
+	rt.setCursorRunner(runner)
+	if rt.cursorRunner != runner {
+		t.Fatal("runtimeServices did not retain the installed Cursor runner")
+	}
+
+	first, err := runner.Catalog(context.Background(), false)
+	if err != nil || len(first.Items) != 1 || first.Items[0].ID != "model-1" {
+		t.Fatalf("first catalogue = %+v, %v", first, err)
+	}
+	if _, err := runner.Catalog(context.Background(), false); err != nil {
+		t.Fatal(err)
+	}
+	if got := calls.Load(); got != 1 {
+		t.Fatalf("cached catalogue requests = %d, want 1", got)
+	}
+
+	version.Store(2)
+	reloaded := *cfg
+	reloaded.Providers = make(map[string]config.Provider, len(cfg.Providers))
+	for id, configured := range cfg.Providers {
+		reloaded.Providers[id] = configured
+	}
+	ag.SetConfig(&reloaded)
+	second, err := runner.Catalog(context.Background(), false)
+	if err != nil || len(second.Items) != 1 || second.Items[0].ID != "model-2" {
+		t.Fatalf("reloaded catalogue = %+v, %v", second, err)
+	}
+	if got := calls.Load(); got != 2 {
+		t.Fatalf("catalogue requests after same-key reload = %d, want 2", got)
+	}
+
+	changedKey := reloaded
+	changedKey.Providers = make(map[string]config.Provider, len(reloaded.Providers))
+	for id, configured := range reloaded.Providers {
+		changedKey.Providers[id] = configured
+	}
+	provider = changedKey.Providers["cursor"]
+	provider.APIKey = "runtime-key-two"
+	changedKey.Providers["cursor"] = provider
+	ag.SetConfig(&changedKey)
+	if _, err := runner.Catalog(context.Background(), false); err != nil {
+		t.Fatal(err)
+	}
+
+	authMu.Lock()
+	gotAuthorizations := append([]string(nil), authorizations...)
+	authMu.Unlock()
+	if len(gotAuthorizations) != 3 ||
+		gotAuthorizations[0] != "Bearer runtime-key-one" ||
+		gotAuthorizations[1] != "Bearer runtime-key-one" ||
+		gotAuthorizations[2] != "Bearer runtime-key-two" {
+		t.Fatalf("resolved authorizations = %v", gotAuthorizations)
+	}
+}
+
 func captureProviderStdout(t *testing.T, f func()) string {
 	t.Helper()
 	old := os.Stdout

cmd/antares/reasoning_test.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"github.com/enowdev/antares/internal/agent"
+	"github.com/enowdev/antares/internal/config"
+	"github.com/enowdev/antares/internal/store"
+	"github.com/enowdev/antares/internal/tools"
+)
+
+func TestMessageIsRelevantUsesAutoWhenLowUnsupported(t *testing.T) {
+	var chatCalls atomic.Int32
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		switch {
+		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/models"):
+			_, _ = w.Write([]byte(`{"data":[{"id":"plain-model","name":"Plain"}]}`))
+		case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/chat/completions"):
+			chatCalls.Add(1)
+			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"NO"}}]}`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+
+	cfg := config.Default()
+	cfg.Model.Provider = "router"
+	cfg.Model.Default = "plain-model"
+	cfg.Model.MaxRetries = -1
+	cfg.Model.ReasoningEffort = ""
+	cfg.Agent.ReasoningEffort = ""
+	cfg.Streaming.Enabled = false
+	cfg.Providers = map[string]config.Provider{
+		"router": {
+			Kind:    "openai-compatible",
+			BaseURL: srv.URL,
+			Enabled: true,
+		},
+	}
+	db, err := store.Open(context.Background(), "memory", "", 1, 5000, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { _ = db.Close() })
+	rt := &runtimeServices{
+		cfg:   cfg,
+		db:    db,
+		agent: agent.New(cfg, db, tools.NewRegistry(), nil, nil),
+	}
+
+	if got := rt.messageIsRelevant(context.Background(), &config.Binding{
+		Model:           "plain-model",
+		RelevanceFilter: "Only answer release announcements.",
+	}, "How is everyone?"); got {
+		t.Fatal("messageIsRelevant = true, want classifier's NO response")
+	}
+	if got := chatCalls.Load(); got != 1 {
+		t.Fatalf("classifier chat calls = %d, want one", got)
+	}
+}

cmd/antares/setup.go

@@ -109,6 +109,7 @@ func runWebSetup(ctx context.Context, rt *runtimeServices) error {
 		Config: rt.cfg, Agent: rt.agent, Store: rt.db,
 		Dist: server.EmbeddedDist(), Reload: rt.reload,
 		Skills: rt.skills, Cron: rt.cron, Gateway: rt.gateway, MCP: rt.mcp,
+		Cursor: rt.cursorRunner,
 	})
 
 	urls := setupURLs(port)