Fix metadata API to query MetadataService directly in server mode

**Problem**: In server mode (Vercel deployment), the metadata API endpoints
were not returning runtime-registered types like 'agent' and 'tool'.

**Root Cause**: The HTTP dispatcher's fallback chain tried:
1. Protocol service (only knows static types from packages)
2. Broker call (no metadata broker actions registered)
3. Hardcoded defaults ['object', 'app', 'plugin']

It never queried MetadataService directly, which holds runtime-registered
metadata from AI Service Plugin and other sources.

**Fix**: Modified HTTP dispatcher to query MetadataService directly:
- `GET /api/v1/meta` now calls `metadataService.getRegisteredTypes()`
- `GET /api/v1/meta/:type` now calls `metadataService.list(type)`

Both are inserted into the fallback chain after protocol service but before
broker calls, ensuring runtime metadata is available in server mode.

**Affected Endpoints**:
- GET /api/v1/meta → now includes 'agent' and 'tool' types
- GET /api/v1/meta/agent → now returns registered agents
- GET /api/v1/meta/tool → now returns registered tools

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

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

Author: Claude

packages/runtime/src/http-dispatcher.ts

@@ -347,6 +347,17 @@ export class HttpDispatcher {
                 const result = await protocol.getMetaTypes({});
                 return { handled: true, response: this.success(result) };
             }
+            // Try MetadataService directly (includes runtime-registered types like agents/tools)
+            const metadataService = await this.getService(CoreServiceName.enum.metadata);
+            if (metadataService && typeof (metadataService as any).getRegisteredTypes === 'function') {
+                try {
+                    const types = await (metadataService as any).getRegisteredTypes();
+                    return { handled: true, response: this.success({ types }) };
+                } catch (e: any) {
+                    // Log error but continue to fallbacks
+                    console.debug('[HttpDispatcher] MetadataService.getRegisteredTypes() failed:', e.message);
+                }
+            }
             // Fallback: ask broker for registered types
             if (broker) {
                 try {
@@ -464,7 +475,7 @@ export class HttpDispatcher {
             const typeOrName = parts[0];
             // Extract optional package filter from query string
             const packageId = query?.package || undefined;
-            
+
             // Try protocol service first for any type
             const protocol = await this.resolveService('protocol');
             if (protocol && typeof protocol.getMetaItems === 'function') {
@@ -479,6 +490,20 @@ export class HttpDispatcher {
                 }
             }
 
+            // Try MetadataService directly for runtime-registered metadata (agents, tools, etc.)
+            const metadataService = await this.getService(CoreServiceName.enum.metadata);
+            if (metadataService && typeof (metadataService as any).list === 'function') {
+                try {
+                    const items = await (metadataService as any).list(typeOrName);
+                    if (items && items.length > 0) {
+                        return { handled: true, response: this.success({ type: typeOrName, items }) };
+                    }
+                } catch (e: any) {
+                    // MetadataService doesn't know this type or failed, continue to other fallbacks
+                    console.debug(`[HttpDispatcher] MetadataService.list('${typeOrName}') failed:`, e.message);
+                }
+            }
+
             // Try broker for the type
             if (broker) {
                 try {