@objectstack/runtime 4.0.2 → 4.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/runtime",
-  "version": "4.0.2",
+  "version": "4.0.3",
   "license": "Apache-2.0",
   "description": "ObjectStack Core Runtime & Query Engine",
   "type": "module",
@@ -15,14 +15,14 @@
   },
   "dependencies": {
     "zod": "^4.3.6",
-    "@objectstack/core": "4.0.2",
-    "@objectstack/rest": "4.0.2",
-    "@objectstack/spec": "4.0.2",
-    "@objectstack/types": "4.0.2"
+    "@objectstack/core": "4.0.3",
+    "@objectstack/types": "4.0.3",
+    "@objectstack/spec": "4.0.3",
+    "@objectstack/rest": "4.0.3"
   },
   "devDependencies": {
     "typescript": "^6.0.2",
-    "vitest": "^4.1.2"
+    "vitest": "^4.1.4"
   },
   "scripts": {
     "build": "tsup --config ../../tsup.config.ts",

package/src/dispatcher-plugin.ts

@@ -22,6 +22,75 @@ interface RouteDefinition {
     handler: (req: any) => Promise<any>;
 }
 
+/**
+ * Register a single RouteDefinition on the HTTP server.
+ * Returns true if the route was successfully registered.
+ */
+function mountRouteOnServer(route: RouteDefinition, server: IHttpServer, routePath: string): boolean {
+    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) {
+                // SSE streaming response
+                res.status(result.status);
+
+                // Apply headers from the route result if available
+                if (result.headers) {
+                    for (const [k, v] of Object.entries(result.headers)) {
+                        res.header(k, String(v));
+                    }
+                } else {
+                    res.header('Content-Type', 'text/event-stream');
+                    res.header('Cache-Control', 'no-cache');
+                    res.header('Connection', 'keep-alive');
+                }
+
+                // Write the stream — events are pre-encoded SSE strings
+                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 {
+                    // Fallback: collect events into array
+                    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);
+        return true;
+    } else if (m === 'post' && typeof server.post === 'function') {
+        server.post(routePath, handler);
+        return true;
+    } else if (m === 'delete' && typeof server.delete === 'function') {
+        server.delete(routePath, handler);
+        return true;
+    }
+    return false;
+}
+
 /**
  * Send an HttpDispatcherResult through IHttpResponse.
  * Differentiates between handled, unhandled (404), and special results.
@@ -402,68 +471,33 @@ export function createDispatcherPlugin(config: DispatcherPluginConfig = {}): Plu
                     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) {
-                                // SSE streaming response
-                                res.status(result.status);
-
-                                // Apply headers from the route result if available
-                                if (result.headers) {
-                                    for (const [k, v] of Object.entries(result.headers)) {
-                                        res.header(k, v);
-                                    }
-                                } else {
-                                    res.header('Content-Type', 'text/event-stream');
-                                    res.header('Cache-Control', 'no-cache');
-                                    res.header('Connection', 'keep-alive');
-                                }
-
-                                // Write the stream — events are pre-encoded SSE strings
-                                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 {
-                                    // Fallback: collect events into array
-                                    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);
-                    } else if (m === 'post' && typeof server.post === 'function') {
-                        server.post(routePath, handler);
-                    } else if (m === 'delete' && typeof server.delete === 'function') {
-                        server.delete(routePath, handler);
-                    }
+                    mountRouteOnServer(route, server, routePath);
                 }
                 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 (see AIServicePlugin.start())
+            // as an internal cross-plugin protocol so we can recover them here.
+            // TODO: replace with a formal kernel.getCachedRoutes('ai') API in a future release.
+            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}`;
+                    if (mountRouteOnServer(route, server, routePath)) {
+                        registered++;
+                    }
+                }
+                if (registered > 0) {
+                    ctx.logger.info(`[Dispatcher] Recovered ${registered} cached AI routes (hook timing fallback)`);
+                }
+            }
         },
     };
 }

package/src/http-dispatcher.ts

@@ -2,6 +2,7 @@
 
 import { ObjectKernel, getEnv, resolveLocale } from '@objectstack/core';
 import { CoreServiceName } from '@objectstack/spec/system';
+import { pluralToSingular } from '@objectstack/spec/shared';
 
 /** Browser-safe UUID generator — prefers Web Crypto, falls back to RFC 4122 v4 */
 function randomUUID(): string {
@@ -341,22 +342,82 @@ export class HttpDispatcher {
         
         // GET /metadata/types
         if (parts[0] === 'types') {
-            // Try protocol service for dynamic types
+            // PRIORITY 1: Try MetadataService directly (includes both typeRegistry with agent/tool AND runtime-registered types)
+            console.log('[HttpDispatcher] Attempting to resolve MetadataService...');
+            console.log('[HttpDispatcher] Available kernel methods:', {
+                hasGetServiceAsync: typeof this.kernel.getServiceAsync === 'function',
+                hasGetService: typeof this.kernel.getService === 'function',
+                hasContext: !!this.kernel.context,
+                hasContextGetService: typeof this.kernel.context?.getService === 'function',
+            });
+
+            // Try all service resolution paths with detailed logging
+            let metadataService: any = null;
+
+            // Path 1: kernel.getServiceAsync
+            if (typeof this.kernel.getServiceAsync === 'function') {
+                try {
+                    metadataService = await this.kernel.getServiceAsync('metadata');
+                    console.log('[HttpDispatcher] kernel.getServiceAsync("metadata") returned:', !!metadataService);
+                } catch (e: any) {
+                    console.log('[HttpDispatcher] kernel.getServiceAsync("metadata") failed:', e.message);
+                }
+            }
+
+            // Path 2: kernel.getService (if not found via async)
+            if (!metadataService && typeof this.kernel.getService === 'function') {
+                try {
+                    metadataService = await this.kernel.getService('metadata');
+                    console.log('[HttpDispatcher] kernel.getService("metadata") returned:', !!metadataService);
+                } catch (e: any) {
+                    console.log('[HttpDispatcher] kernel.getService("metadata") failed:', e.message);
+                }
+            }
+
+            // Path 3: kernel.context.getService (if not found)
+            if (!metadataService && this.kernel.context?.getService) {
+                try {
+                    metadataService = await this.kernel.context.getService('metadata');
+                    console.log('[HttpDispatcher] kernel.context.getService("metadata") returned:', !!metadataService);
+                } catch (e: any) {
+                    console.log('[HttpDispatcher] kernel.context.getService("metadata") failed:', e.message);
+                }
+            }
+
+            console.log('[HttpDispatcher] Final metadataService:', !!metadataService, 'has getRegisteredTypes:', typeof (metadataService as any)?.getRegisteredTypes);
+
+            if (metadataService && typeof (metadataService as any).getRegisteredTypes === 'function') {
+                try {
+                    const types = await (metadataService as any).getRegisteredTypes();
+                    console.log('[HttpDispatcher] MetadataService.getRegisteredTypes() returned:', types);
+                    return { handled: true, response: this.success({ types }) };
+                } catch (e: any) {
+                    // Log error but continue to fallbacks
+                    console.warn('[HttpDispatcher] MetadataService.getRegisteredTypes() failed:', e.message, e.stack);
+                }
+            } else {
+                console.log('[HttpDispatcher] MetadataService not available or missing getRegisteredTypes, falling back to protocol service');
+            }
+            // PRIORITY 2: Try protocol service (returns SchemaRegistry types only - missing agent/tool)
             const protocol = await this.resolveService('protocol');
             if (protocol && typeof protocol.getMetaTypes === 'function') {
                 const result = await protocol.getMetaTypes({});
+                console.log('[HttpDispatcher] Protocol service returned types:', result);
                 return { handled: true, response: this.success(result) };
             }
-            // Fallback: ask broker for registered types
+            // PRIORITY 3: ask broker for registered types
             if (broker) {
                 try {
                     const data = await broker.call('metadata.types', {}, { request: context.request });
+                    console.log('[HttpDispatcher] Broker returned types:', data);
                     return { handled: true, response: this.success(data) };
-                } catch {
+                } catch (e) {
+                    console.log('[HttpDispatcher] Broker call failed:', e);
                     // fall through to hardcoded defaults
                 }
             }
             // Last resort: hardcoded defaults
+            console.warn('[HttpDispatcher] Falling back to hardcoded defaults for metadata types');
             return { handled: true, response: this.success({ types: ['object', 'app', 'plugin'] }) };
         }
 
@@ -429,9 +490,8 @@ export class HttpDispatcher {
                     return { handled: true, response: this.error('Not found', 404) };
                 }
 
-                // If type is singular (e.g. 'app'), use it directly
-                // If plural (e.g. 'apps'), slice it
-                const singularType = type.endsWith('s') ? type.slice(0, -1) : type;
+                // Normalize plural URL paths to singular registry type names
+                const singularType = pluralToSingular(type);
 
                 // Try Protocol Service First (Preferred)
                 const protocol = await this.resolveService('protocol');
@@ -464,7 +524,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 +539,22 @@ 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
+                    // Sanitize typeOrName to prevent log injection (CodeQL warning)
+                    const sanitizedType = String(typeOrName).replace(/[\r\n\t]/g, '');
+                    console.debug(`[HttpDispatcher] MetadataService.list() failed for type:`, sanitizedType, 'error:', e.message);
+                }
+            }
+
             // Try broker for the type
             if (broker) {
                 try {

package/vitest.config.ts

@@ -12,6 +12,7 @@ export default defineConfig({
       '@objectstack/spec/contracts': path.resolve(__dirname, '../spec/src/contracts/index.ts'),
       '@objectstack/spec/data': path.resolve(__dirname, '../spec/src/data/index.ts'),
       '@objectstack/spec/kernel': path.resolve(__dirname, '../spec/src/kernel/index.ts'),
+      '@objectstack/spec/shared': path.resolve(__dirname, '../spec/src/shared/index.ts'),
       '@objectstack/spec/system': path.resolve(__dirname, '../spec/src/system/index.ts'),
       '@objectstack/spec': path.resolve(__dirname, '../spec/src/index.ts'),
       '@objectstack/types': path.resolve(__dirname, '../types/src/index.ts'),