fix: AI agent routes not registered due to redundant ctx.getService('metadata') call

Agent-Logs-Url: https://github.com/objectstack-ai/framework/sessions/35f9d46b-5132-451b-89f4-7dbee7066a1f

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

Author: Copilot

CHANGELOG.md

@@ -71,6 +71,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   match the current monorepo layout.
 
 ### Fixed
+- **AI Chat agent selector missing `data_chat` and `metadata_assistant`** — Fixed `GET /api/v1/ai/agents`
+  returning 404, which caused the Studio AI Chat panel to show only "General Chat". Root cause was a
+  redundant second `ctx.getService('metadata')` call inside `AIServicePlugin.start()` that shadowed
+  the outer resolved variable and failed silently, preventing `buildAgentRoutes()` from being called.
+  Fix: reuse the already-resolved `metadataService` variable instead of re-fetching it. Additionally,
+  added a fallback in `DispatcherPlugin.start()` that recovers AI routes from the `kernel.__aiRoutes`
+  cache in case the `ai:routes` hook fires before the listener is registered (timing edge case).
 - **ObjectQLPlugin: cold-start metadata restoration** — `ObjectQLPlugin.start()` now calls
   `protocol.loadMetaFromDb()` after driver initialization and before schema sync, restoring
   all persisted metadata (objects, views, apps, etc.) from the `sys_metadata` table into the

packages/runtime/src/dispatcher-plugin.ts

@@ -464,6 +464,80 @@ export function createDispatcherPlugin(config: DispatcherPluginConfig = {}): Plu
                 }
                 ctx.logger.info(`[Dispatcher] Registered ${routes.length} AI routes`);
             });
+
+            // ── Fallback: recover routes cached before hook was registered ──
+            // If AIServicePlugin.start() ran before DispatcherPlugin.start()
+            // (possible when plugin start order differs from registration order),
+            // the 'ai:routes' trigger fires with no listener. The AIServicePlugin
+            // caches the routes on the kernel as __aiRoutes so we can recover here.
+            const cachedRoutes = (kernel as any).__aiRoutes as RouteDefinition[] | undefined;
+            if (cachedRoutes && Array.isArray(cachedRoutes) && cachedRoutes.length > 0) {
+                let registered = 0;
+                for (const route of cachedRoutes) {
+                    const routePath = route.path.startsWith('/api/v1')
+                        ? route.path
+                        : `${prefix}${route.path}`;
+
+                    const handler = async (req: any, res: any) => {
+                        try {
+                            const result = await route.handler({
+                                body: req.body,
+                                params: req.params,
+                                query: req.query,
+                            });
+
+                            if (result.stream && result.events) {
+                                res.status(result.status);
+                                if (result.headers) {
+                                    for (const [k, v] of Object.entries(result.headers)) {
+                                        res.header(k, v as string);
+                                    }
+                                } else {
+                                    res.header('Content-Type', 'text/event-stream');
+                                    res.header('Cache-Control', 'no-cache');
+                                    res.header('Connection', 'keep-alive');
+                                }
+                                if (typeof res.write === 'function' && typeof res.end === 'function') {
+                                    for await (const event of result.events) {
+                                        res.write(typeof event === 'string' ? event : `data: ${JSON.stringify(event)}\n\n`);
+                                    }
+                                    res.end();
+                                } else {
+                                    const events = [];
+                                    for await (const event of result.events) {
+                                        events.push(event);
+                                    }
+                                    res.json({ events });
+                                }
+                            } else {
+                                res.status(result.status);
+                                if (result.body !== undefined) {
+                                    res.json(result.body);
+                                } else {
+                                    res.end();
+                                }
+                            }
+                        } catch (err: any) {
+                            errorResponse(err, res);
+                        }
+                    };
+
+                    const m = route.method.toLowerCase();
+                    if (m === 'get' && typeof server.get === 'function') {
+                        server.get(routePath, handler);
+                        registered++;
+                    } else if (m === 'post' && typeof server.post === 'function') {
+                        server.post(routePath, handler);
+                        registered++;
+                    } else if (m === 'delete' && typeof server.delete === 'function') {
+                        server.delete(routePath, handler);
+                        registered++;
+                    }
+                }
+                if (registered > 0) {
+                    ctx.logger.info(`[Dispatcher] Recovered ${registered} cached AI routes (hook timing fallback)`);
+                }
+            }
         },
     };
 }

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

@@ -308,14 +308,12 @@ export class AIServicePlugin implements Plugin {
     const routes = buildAIRoutes(this.service, this.service.conversationService, ctx.logger);
 
     // Build agent routes if metadata service is available
-    try {
-      const metadataService = ctx.getService<IMetadataService>('metadata');
-      if (metadataService) {
-        const agentRuntime = new AgentRuntime(metadataService);
-        const agentRoutes = buildAgentRoutes(this.service, agentRuntime, ctx.logger);
-        routes.push(...agentRoutes);
-      }
-    } catch {
+    if (metadataService) {
+      const agentRuntime = new AgentRuntime(metadataService);
+      const agentRoutes = buildAgentRoutes(this.service, agentRuntime, ctx.logger);
+      routes.push(...agentRoutes);
+      ctx.logger.info(`[AI] Agent routes registered (${agentRoutes.length} routes)`);
+    } else {
       ctx.logger.debug('[AI] Metadata service not available, skipping agent routes');
     }