fix: Access kernel services dynamically to fix AI metadata visibility

**Root Cause:**
Protocol callback captured PluginContext during ObjectQLPlugin.init(), but MetadataPlugin
registers its service AFTER ObjectQLPlugin. This meant ctx.getServices() returned a snapshot
without the metadata service, causing agents/tools to be invisible in Studio sidebar.

**Fix:**
Changed protocol initialization to access kernel.context.getServices() dynamically at request
time instead of capturing ctx.getServices() during init. This ensures the protocol always
accesses the live services registry with all registered services including MetadataService.

**Changes:**
- ObjectQLPlugin: Use ctx.getKernel() to get kernel reference, access services via kernel.context
- Protocol: Removed diagnostic logging (no longer needed)
- AIServicePlugin: Removed diagnostic logging
- MetadataPlugin: Removed diagnostic logging

**Verified:**
- Protocol now accesses services dynamically at runtime
- MetadataService is accessible even though it registers after ObjectQLPlugin
- Agents and tools should now be visible in Studio sidebar on Vercel

Agent-Logs-Url: https://github.com/objectstack-ai/framework/sessions/8252cffa-ca7f-44e7-9646-e56ed9b05e6a

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Claude

packages/metadata/src/plugin.ts

@@ -46,7 +46,6 @@ export class MetadataPlugin implements Plugin {
 
         // Register Metadata Manager as the primary metadata service provider.
         ctx.registerService('metadata', this.manager);
-        console.log('[MetadataPlugin] Registered metadata service, has getRegisteredTypes:', typeof this.manager.getRegisteredTypes);
 
         // Register metadata system objects via the manifest service (if available).
         // MetadataPlugin may init before ObjectQLPlugin, so wrap in try/catch.

packages/objectql/src/plugin.ts

@@ -72,10 +72,16 @@ export class ObjectQLPlugin implements Plugin {
     });
 
     // Register Protocol Implementation
+    // IMPORTANT: Use getKernel() to access services dynamically.
+    // ctx.getServices() returns a snapshot at call time, but we need
+    // live access to services that are registered after this plugin's init().
+    // MetadataPlugin and AIServicePlugin register after ObjectQLPlugin,
+    // so we must access kernel.context.getServices() at request time.
+    const kernel = ctx.getKernel();
     const protocolShim = new ObjectStackProtocolImplementation(
       this.ql,
-      () => ctx.getServices ? ctx.getServices() : new Map(),
-      () => ctx.getServices()?.get('feed') as any
+      () => kernel.context?.getServices() ?? new Map(),
+      () => kernel.context?.getService('feed') as any
     );
 
     ctx.registerService('protocol', protocolShim);

packages/objectql/src/protocol.ts

@@ -186,20 +186,15 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         let runtimeTypes: string[] = [];
         try {
             const services = this.getServicesRegistry?.();
-            console.log('[Protocol] getMetaTypes - services registry available:', !!services, 'size:', services?.size);
             const metadataService = services?.get('metadata');
-            console.log('[Protocol] getMetaTypes - metadata service available:', !!metadataService, 'has getRegisteredTypes:', typeof metadataService?.getRegisteredTypes);
             if (metadataService && typeof metadataService.getRegisteredTypes === 'function') {
                 runtimeTypes = await metadataService.getRegisteredTypes();
-                console.log('[Protocol] getMetaTypes - runtime types from metadata service:', runtimeTypes);
             }
-        } catch (err) {
+        } catch {
             // MetadataService not available
-            console.warn('[Protocol] getMetaTypes - error accessing metadata service:', err);
         }
 
         const allTypes = Array.from(new Set([...schemaTypes, ...runtimeTypes]));
-        console.log('[Protocol] getMetaTypes - final types:', allTypes);
         return { types: allTypes };
     }
 
@@ -253,12 +248,9 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         // Merge with MetadataService (runtime-registered items: agents, tools, etc.)
         try {
             const services = this.getServicesRegistry?.();
-            console.log('[Protocol] getMetaItems - type:', request.type, 'services available:', !!services, 'size:', services?.size);
             const metadataService = services?.get('metadata');
-            console.log('[Protocol] getMetaItems - metadata service available:', !!metadataService, 'has list:', typeof metadataService?.list);
             if (metadataService && typeof metadataService.list === 'function') {
                 const runtimeItems = await metadataService.list(request.type);
-                console.log('[Protocol] getMetaItems - runtime items from metadata service:', runtimeItems?.length, 'items');
                 if (runtimeItems && runtimeItems.length > 0) {
                     // Merge, avoiding duplicates by name
                     const itemMap = new Map<string, any>();
@@ -275,12 +267,10 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
                         }
                     }
                     items = Array.from(itemMap.values());
-                    console.log('[Protocol] getMetaItems - merged items count:', items.length);
                 }
             }
-        } catch (err) {
+        } catch {
             // MetadataService not available or doesn't support this type
-            console.warn('[Protocol] getMetaItems - error accessing metadata service:', err);
         }
 
         return {

packages/services/service-ai/src/plugin.ts

@@ -250,9 +250,7 @@ export class AIServicePlugin implements Plugin {
     let metadataService: IMetadataService | undefined;
     try {
       metadataService = ctx.getService<IMetadataService>('metadata');
-      console.log('[AI Plugin] Retrieved metadata service:', !!metadataService, 'has getRegisteredTypes:', typeof (metadataService as any)?.getRegisteredTypes);
     } catch (e: any) {
-      console.log('[AI] Metadata service not available:', e.message);
       ctx.logger.debug('[AI] Metadata service not available');
     }
 
@@ -289,10 +287,8 @@ export class AIServicePlugin implements Plugin {
 
             if (!agentExists) {
               await metadataService.register('agent', DATA_CHAT_AGENT.name, DATA_CHAT_AGENT);
-              console.log('[AI] Registered data_chat agent to metadataService');
               ctx.logger.info('[AI] data_chat agent registered');
             } else {
-              console.log('[AI] data_chat agent already exists, skipping');
               ctx.logger.debug('[AI] data_chat agent already exists, skipping auto-registration');
             }
           } catch (err) {
@@ -333,10 +329,8 @@ export class AIServicePlugin implements Plugin {
 
           if (!agentExists) {
             await metadataService.register('agent', METADATA_ASSISTANT_AGENT.name, METADATA_ASSISTANT_AGENT);
-            console.log('[AI] Registered metadata_assistant agent to metadataService');
             ctx.logger.info('[AI] metadata_assistant agent registered');
           } else {
-            console.log('[AI] metadata_assistant agent already exists, skipping');
             ctx.logger.debug('[AI] metadata_assistant agent already exists, skipping auto-registration');
           }
         } catch (err) {