Fixes extension loading and data handling

Ensures extensions can load correctly by injecting a context containing i18n, API, and Cache.

Populates socket URLs for extensions relying on Unix sockets, addressing potential connection issues.

Improves AI query parameter handling by filtering and encoding parameters for AI generation requests, ensuring only relevant data is sent to the plugin.

Author: KariHall619

console/atest-ui/src/views/Extension.vue

@@ -1,11 +1,30 @@
 <script setup lang="ts">
-import { ref } from 'vue'
+import { ref, type Ref } from 'vue'
+import { useI18n } from 'vue-i18n'
 import { API } from './net';
+import { Cache } from './cache';
 
 interface Props {
   name: string
 }
 const props = defineProps<Props>()
+const { t, locale } = useI18n()
+
+interface PluginAppContext {
+  i18n: {
+    t: (key: string) => string
+    locale: Ref<string>
+  }
+  API: typeof API
+  Cache: typeof Cache
+}
+
+const pluginContext: PluginAppContext = {
+  i18n: { t, locale },
+  API,
+  Cache
+}
+
 const loading = ref(true)
 const loadPlugin = async (): Promise<void> => {
     try {
@@ -25,14 +44,14 @@ const loadPlugin = async (): Promise<void> => {
 
             // Implement retry mechanism with exponential backoff
             const checkPluginLoad = (retries = 0, maxRetries = 10) => {
-                const globalScope = globalThis as { ATestPlugin?: { mount?: (el: Element) => void } };
+                const globalScope = globalThis as { ATestPlugin?: { mount?: (el: Element, context: PluginAppContext) => void } };
                 const plugin = globalScope.ATestPlugin;
 
                 if (plugin && plugin.mount) {
                     const container = document.getElementById("plugin-container");
                     if (container) {
                         container.innerHTML = ''; // Clear previous content
-                        plugin.mount(container);
+                        plugin.mount(container, pluginContext);
                         loading.value = false;
                     } else {
                         loading.value = false;

pkg/server/remote_server.go

@@ -1225,6 +1225,9 @@ func (s *server) GetStores(ctx context.Context, in *SimpleQuery) (reply *Stores,
 		wg := sync.WaitGroup{}
 		mu := sync.Mutex{}
 		for _, item := range stores {
+			// Ensure socket URL is populated for extensions that rely on Unix sockets
+			handleStore(&item)
+
 			skip := false
 			for _, kind := range kinds.Data {
 				if in != nil && in.Kind != "" && !slices.Contains(kind.Categories, in.Kind) {
@@ -1670,6 +1673,9 @@ func (s *server) getLoaderByStoreName(storeName string) (loader testing.Writer,
 	var store *testing.Store
 	store, err = testing.NewStoreFactory(s.configDir).GetStore(storeName)
 	if err == nil && store != nil {
+		// Backfill socket URL when it is missing in the store definition
+		handleStore(store)
+
 		loader, err = s.storeWriterFactory.NewInstance(*store)
 		if err != nil {
 			err = fmt.Errorf("failed to new grpc loader from store %s, err: %v", store.Name, err)

pkg/testing/remote/grpc_store.go

@@ -327,12 +327,19 @@ func (g *gRPCLoader) Query(query map[string]string) (result testing.DataResult,
 	var dataResult *server.DataQueryResult
 	offset, _ := strconv.ParseInt(query["offset"], 10, 64)
 	limit, _ := strconv.ParseInt(query["limit"], 10, 64)
+	queryType := query["type"]
+	queryKey := query["key"]
 	if dataResult, err = g.client.Query(g.ctx, &server.DataQuery{
+		Type:   queryType,
 		Sql:    query["sql"],
-		Key:    query["key"],
+		Key:    queryKey,
 		Offset: offset,
 		Limit:  limit,
 	}); err == nil {
+		if strings.EqualFold(queryType, "ai") || strings.EqualFold(queryKey, "generate") {
+			return g.convertAIResponse(dataResult), nil
+		}
+
 		result.Pairs = pairToMap(dataResult.Data)
 		for _, item := range dataResult.Items {
 			result.Rows = append(result.Rows, pairToMap(item.Data))
@@ -485,9 +492,16 @@ func (g *gRPCLoader) handleAIQuery(query map[string]string) (testing.DataResult,
 	return g.convertAIResponse(dataResult), nil
 }
 
-// encodeAIGenerateParams encodes the original query parameters into JSON.
+// encodeAIGenerateParams filters and encodes AI generation parameters into JSON string.
+// This function intentionally excludes routing fields (like "method") and only propagates
+// the actual AI request payload that the plugin understands.
 func (g *gRPCLoader) encodeAIGenerateParams(query map[string]string) string {
-	data, _ := json.Marshal(query)
+	params := map[string]string{
+		"model":  query["model"],
+		"prompt": query["prompt"],
+		"config": query["config"],
+	}
+	data, _ := json.Marshal(params)
 	return string(data)
 }