Merge remote-tracking branch 'upstream/develop' into develop

Author: skyguan92

cmd/aima/infra.go

@@ -105,6 +105,13 @@ func buildAgentStatusPayload(ctx context.Context, llmClient *agent.OpenAIClient,
 	return json.Marshal(payload)
 }
 
+func buildFreshAgentStatusPayload(ctx context.Context, db *state.DB, llmClient *agent.OpenAIClient, localAPIKey, toolMode string, activeRuns int) (json.RawMessage, error) {
+	if db != nil && llmClient != nil {
+		reloadLLMSettings(ctx, db, llmClient, localAPIKey)
+	}
+	return buildAgentStatusPayload(ctx, llmClient, toolMode, activeRuns)
+}
+
 func loadLLMSettings(ctx context.Context, db *state.DB) llmSettings {
 	settings := llmSettings{
 		Endpoint: defaultLLMEndpoint(),

cmd/aima/main.go

@@ -183,6 +183,7 @@ func run() error {
 		if skipPerms {
 			ctx = context.WithValue(ctx, ctxKeySkipPerms, true)
 		}
+		reloadLLMSettings(ctx, db, llmClient, proxyServer.APIKey())
 		result, sid, toolCalls, err := dispatcher.Ask(ctx, query, agent.DispatchOption{SessionID: sessionID})
 		if err != nil {
 			return nil, "", err
@@ -198,7 +199,7 @@ func run() error {
 		if explorationMgr != nil {
 			activeRuns = explorationMgr.ActiveCount()
 		}
-		return buildAgentStatusPayload(ctx, llmClient, goAgent.ToolMode(), activeRuns)
+		return buildFreshAgentStatusPayload(ctx, db, llmClient, proxyServer.APIKey(), goAgent.ToolMode(), activeRuns)
 	}
 	// 9c. Wire rollback tools
 	deps.RollbackList = func(ctx context.Context) (json.RawMessage, error) {
@@ -270,6 +271,7 @@ func run() error {
 			return json.Marshal(map[string]string{"status": "ok"})
 		},
 		DispatchAskStream: func(ctx context.Context, query, sessionID string, cb func(string, []byte)) (json.RawMessage, error) {
+			reloadLLMSettings(ctx, db, llmClient, proxyServer.APIKey())
 			var streamCB agent.StreamCallback
 			if cb != nil {
 				streamCB = func(ev agent.StreamEvent) {
@@ -299,6 +301,9 @@ func run() error {
 			}
 			return raw, nil
 		},
+		APIKey: func(context.Context) string {
+			return proxyServer.APIKey()
+		},
 	})
 
 	// AIMA inference HTTP routes and OpenClaw config sync share backend/catalog readers,

cmd/aima/main_test.go

@@ -1972,6 +1972,66 @@ func TestReloadLLMSettings_FallsBackToServeAPIKeyForLocalProxy(t *testing.T) {
 	}
 }
 
+func TestBuildFreshAgentStatusPayloadReloadsModelFromDB(t *testing.T) {
+	ctx := context.Background()
+	db, err := state.Open(ctx, ":memory:")
+	if err != nil {
+		t.Fatalf("Open: %v", err)
+	}
+	defer db.Close()
+
+	t.Setenv("AIMA_LLM_ENDPOINT", "")
+	t.Setenv("AIMA_LLM_MODEL", "")
+	t.Setenv("AIMA_API_KEY", "")
+	t.Setenv("AIMA_LLM_USER_AGENT", "")
+	t.Setenv("AIMA_LLM_EXTRA_PARAMS", "")
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/status":
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"status":"ok","models":[{"model_name":"new-model","ready":true}]}`))
+		case "/v1/models":
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"data":[{"id":"new-model"}]}`))
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer server.Close()
+
+	if err := db.SetConfig(ctx, "llm.endpoint", server.URL+"/v1"); err != nil {
+		t.Fatalf("SetConfig endpoint: %v", err)
+	}
+	if err := db.SetConfig(ctx, "llm.model", "new-model"); err != nil {
+		t.Fatalf("SetConfig model: %v", err)
+	}
+
+	client := agent.NewOpenAIClient(server.URL+"/v1", agent.WithModel("old-model"))
+	data, err := buildFreshAgentStatusPayload(ctx, db, client, "", "enabled", 0)
+	if err != nil {
+		t.Fatalf("buildFreshAgentStatusPayload: %v", err)
+	}
+
+	var payload struct {
+		LLMRoute struct {
+			ConfiguredModel string `json:"configured_model"`
+			Selected        struct {
+				Model string `json:"model"`
+			} `json:"selected"`
+		} `json:"llm_route"`
+	}
+	if err := json.Unmarshal(data, &payload); err != nil {
+		t.Fatalf("unmarshal payload: %v", err)
+	}
+	if payload.LLMRoute.ConfiguredModel != "new-model" {
+		t.Fatalf("configured model = %q, want new-model", payload.LLMRoute.ConfiguredModel)
+	}
+	if payload.LLMRoute.Selected.Model != "new-model" {
+		t.Fatalf("selected model = %q, want new-model", payload.LLMRoute.Selected.Model)
+	}
+}
+
 func TestMCPToolAdapter_SystemConfigReadAllowedWriteBlocked(t *testing.T) {
 	s := mcp.NewServer()
 	called := 0

cmd/aima/runtime_select.go

@@ -245,6 +245,41 @@ func findMatchingDeployments(ctx context.Context, query string, suppress func(*r
 	return matches
 }
 
+func findExactDeploymentNameMatches(ctx context.Context, query string, suppress func(*runtime.DeploymentStatus) bool, rts ...runtime.Runtime) []matchedDeployment {
+	matches := make([]matchedDeployment, 0)
+	seen := make(map[string]struct{})
+	for _, rt := range uniqueRuntimes(rts...) {
+		if status, err := rt.Status(ctx, query); err == nil && status != nil && strings.EqualFold(status.Name, query) {
+			if suppress == nil || !suppress(status) {
+				key := fmt.Sprintf("%p|%s", rt, status.Name)
+				if _, ok := seen[key]; !ok {
+					seen[key] = struct{}{}
+					matches = append(matches, matchedDeployment{Runtime: rt, Status: status})
+				}
+			}
+		}
+		statuses, err := rt.List(ctx)
+		if err != nil {
+			continue
+		}
+		for _, status := range statuses {
+			if status == nil || !strings.EqualFold(status.Name, query) {
+				continue
+			}
+			if suppress != nil && suppress(status) {
+				continue
+			}
+			key := fmt.Sprintf("%p|%s", rt, status.Name)
+			if _, ok := seen[key]; ok {
+				continue
+			}
+			seen[key] = struct{}{}
+			matches = append(matches, matchedDeployment{Runtime: rt, Status: status})
+		}
+	}
+	return matches
+}
+
 func summarizeMatchedDeployments(matches []matchedDeployment) string {
 	if len(matches) == 0 {
 		return ""
@@ -327,3 +362,25 @@ func shouldReuseExistingDeployment(existing *runtime.DeploymentStatus, engineTyp
 	}
 	return len(configOverrides) == 0
 }
+
+func findReusableDeployment(ctx context.Context, deployName, modelName, engineType, slot string, configOverrides map[string]any, suppress func(*runtime.DeploymentStatus) bool, rts ...runtime.Runtime) (*runtime.DeploymentStatus, error) {
+	matches := findMatchingDeployments(ctx, modelName, suppress, rts...)
+	reusable := make([]matchedDeployment, 0, len(matches))
+	for _, match := range matches {
+		if shouldReuseExistingDeployment(match.Status, engineType, slot, configOverrides) {
+			reusable = append(reusable, match)
+		}
+	}
+	if len(reusable) > 1 {
+		return nil, fmt.Errorf("model %q already has multiple active deployments (%s); use an exact deployment name to undeploy the extra instance", modelName, summarizeMatchedDeployments(reusable))
+	}
+	if len(reusable) == 1 {
+		return reusable[0].Status, nil
+	}
+
+	existing, err := findDeploymentStatus(ctx, deployName, suppress, rts...)
+	if err != nil || !shouldReuseExistingDeployment(existing, engineType, slot, configOverrides) {
+		return nil, nil
+	}
+	return existing, nil
+}

cmd/aima/tooldeps_deploy.go

@@ -153,40 +153,46 @@ func buildDeployDeps(ac *appContext, deps *mcp.ToolDeps,
 		}
 		deployName := knowledge.SanitizePodName(modelName + "-" + resolved.Engine)
 		suppressRecentlyDeleted := loadDeletedDeploymentSuppressor(ctx, db)
-		if existing, _ := findDeploymentStatus(ctx, deployName, suppressRecentlyDeleted, activeRt, rt, nativeRt, dockerRt); existing != nil {
-			if shouldReuseExistingDeployment(existing, engineType, slot, configOverrides) {
-				proxyServer.RegisterBackend(modelName, &proxy.Backend{
-					ModelName:           modelName,
-					UpstreamModel:       deploymentUpstreamModel(existing, upstreamModel),
-					EngineType:          resolved.Engine,
-					Address:             existing.Address,
-					Ready:               existing.Ready,
-					ParameterCount:      firstNonEmpty(existing.Labels[proxy.LabelParameterCount], catalogModelParameterCount(cat, modelName)),
-					ContextWindowTokens: firstPositiveInt(contextWindowFromStatus(existing), contextWindowFromResolvedConfig(resolved.Config)),
-				})
-				runtimeName := activeRt.Name()
-				if existing.Runtime != "" {
-					runtimeName = existing.Runtime
-				}
-				status := "deploying"
-				if existing.Ready {
-					status = "ready"
-				}
-				result := map[string]any{
-					"name":    deployName,
-					"model":   modelName,
-					"engine":  resolved.Engine,
-					"slot":    resolved.Slot,
-					"status":  status,
-					"phase":   existing.Phase,
-					"runtime": runtimeName,
-					"config":  resolved.Config,
-				}
-				if existing.Address != "" {
-					result["address"] = existing.Address
-				}
-				return json.Marshal(result)
-			}
+		if existing, err := findReusableDeployment(ctx, deployName, modelName, engineType, slot, configOverrides, suppressRecentlyDeleted, activeRt, rt, nativeRt, dockerRt); err != nil {
+			return nil, err
+		} else if existing != nil {
+			proxyServer.RegisterBackend(modelName, &proxy.Backend{
+				ModelName:           modelName,
+				UpstreamModel:       deploymentUpstreamModel(existing, upstreamModel),
+				EngineType:          resolved.Engine,
+				Address:             existing.Address,
+				Ready:               existing.Ready,
+				ParameterCount:      firstNonEmpty(existing.Labels[proxy.LabelParameterCount], catalogModelParameterCount(cat, modelName)),
+				ContextWindowTokens: firstPositiveInt(contextWindowFromStatus(existing), contextWindowFromResolvedConfig(resolved.Config)),
+			})
+			runtimeName := activeRt.Name()
+			if existing.Runtime != "" {
+				runtimeName = existing.Runtime
+			}
+			status := "deploying"
+			if existing.Ready {
+				status = "ready"
+			}
+			existingName := firstNonEmpty(existing.Name, deployName)
+			result := map[string]any{
+				"name":    existingName,
+				"model":   modelName,
+				"engine":  resolved.Engine,
+				"slot":    resolved.Slot,
+				"status":  status,
+				"phase":   existing.Phase,
+				"runtime": runtimeName,
+				"config":  resolved.Config,
+				"reused":  true,
+				"message": fmt.Sprintf("deployment %s already exists; returning current deployment", existingName),
+			}
+			if existing.Address != "" {
+				result["address"] = existing.Address
+			}
+			if err := setActiveLLMModelConfig(ctx, db, modelName); err != nil {
+				return nil, err
+			}
+			return json.Marshal(result)
 		}
 		// Pre-flight: ensure image is available in containerd for K3S deployments.
 		// Auto-import from Docker or pre-pull from registries if needed.
@@ -296,6 +302,9 @@ func buildDeployDeps(ac *appContext, deps *mcp.ToolDeps,
 			ParameterCount:      catalogModelParameterCount(cat, modelName),
 			ContextWindowTokens: contextWindowFromResolvedConfig(resolved.Config),
 		})
+		if err := setActiveLLMModelConfig(ctx, db, modelName); err != nil {
+			return nil, err
+		}
 		result := map[string]any{
 			"name":  deployName,
 			"model": modelName, "engine": resolved.Engine,
@@ -450,7 +459,10 @@ func buildDeployDeps(ac *appContext, deps *mcp.ToolDeps,
 	}
 
 	deps.DeployDelete = func(ctx context.Context, name string) error {
-		matches := findMatchingDeployments(ctx, name, nil, rt, nativeRt, dockerRt)
+		matches := findExactDeploymentNameMatches(ctx, name, nil, rt, nativeRt, dockerRt)
+		if len(matches) == 0 {
+			matches = findMatchingDeployments(ctx, name, nil, rt, nativeRt, dockerRt)
+		}
 		if len(matches) == 0 {
 			// Backward-compatible fallback: some UI paths pass the model name
 			// instead of the concrete deployment name.
@@ -463,6 +475,9 @@ func buildDeployDeps(ac *appContext, deps *mcp.ToolDeps,
 		if len(matches) == 0 {
 			return fmt.Errorf("deployment %q not found", name)
 		}
+		if len(matches) > 1 {
+			return fmt.Errorf("deployment %q is ambiguous; matches: %s; use an exact deployment name", name, summarizeMatchedDeployments(matches))
+		}
 
 		for _, match := range matches {
 			if match.Status == nil {
@@ -481,7 +496,6 @@ func buildDeployDeps(ac *appContext, deps *mcp.ToolDeps,
 		deletedAt := time.Now()
 		tombstoneKeys := []string{name}
 		seenKeys := map[string]struct{}{normalizeDeletedDeploymentKey(name): {}}
-		verificationQueries := []string{name}
 		rememberKey := func(key string) {
 			norm := normalizeDeletedDeploymentKey(key)
 			if norm == "" {
@@ -493,18 +507,6 @@ func buildDeployDeps(ac *appContext, deps *mcp.ToolDeps,
 			seenKeys[norm] = struct{}{}
 			tombstoneKeys = append(tombstoneKeys, key)
 		}
-		rememberVerificationQuery := func(key string) {
-			norm := normalizeDeletedDeploymentKey(key)
-			if norm == "" {
-				return
-			}
-			for _, existing := range verificationQueries {
-				if normalizeDeletedDeploymentKey(existing) == norm {
-					return
-				}
-			}
-			verificationQueries = append(verificationQueries, key)
-		}
 
 		for _, match := range matches {
 			if match.Runtime == nil || match.Status == nil {
@@ -516,14 +518,10 @@ func buildDeployDeps(ac *appContext, deps *mcp.ToolDeps,
 			rememberKey(match.Status.Name)
 			modelKey := deploymentModelKey(match.Status)
 			rememberKey(modelKey)
-			rememberVerificationQuery(match.Status.Name)
-			rememberVerificationQuery(modelKey)
 		}
 
-		for _, query := range verificationQueries {
-			if remaining := findMatchingDeployments(ctx, query, nil, rt, nativeRt, dockerRt); len(remaining) > 0 {
-				return fmt.Errorf("delete deployment %q: deployment still active after delete (%s)", name, summarizeMatchedDeployments(remaining))
-			}
+		if remaining := findExactDeploymentNameMatches(ctx, matches[0].Status.Name, nil, rt, nativeRt, dockerRt); len(remaining) > 0 {
+			return fmt.Errorf("delete deployment %q: deployment still active after delete (%s)", name, summarizeMatchedDeployments(remaining))
 		}
 
 		for _, key := range tombstoneKeys {
@@ -605,6 +603,17 @@ func buildDeployDeps(ac *appContext, deps *mcp.ToolDeps,
 	}
 }
 
+func setActiveLLMModelConfig(ctx context.Context, db *state.DB, modelName string) error {
+	modelName = strings.TrimSpace(modelName)
+	if db == nil || modelName == "" {
+		return nil
+	}
+	if err := db.SetConfig(ctx, "llm.model", modelName); err != nil {
+		return fmt.Errorf("update llm.model after deploy: %w", err)
+	}
+	return nil
+}
+
 func catalogModelParameterCount(cat *knowledge.Catalog, name string) string {
 	if cat == nil {
 		return ""