feat(ai): integrate AIServicePlugin and add dynamic route handling for AI services

Author: hotlong

apps/studio/server/index.ts

@@ -33,6 +33,7 @@ import { SecurityPlugin } from '@objectstack/plugin-security';
 import { AuditPlugin } from '@objectstack/plugin-audit';
 import { FeedServicePlugin } from '@objectstack/service-feed';
 import { MetadataPlugin } from '@objectstack/metadata';
+import { AIServicePlugin } from '@objectstack/service-ai';
 import { handle } from '@hono/node-server/vercel';
 import { Hono } from 'hono';
 import { createBrokerShim } from '../src/lib/create-broker-shim.js';
@@ -106,6 +107,7 @@ async function ensureKernel(): Promise<ObjectKernel> {
             await kernel.use(new AuditPlugin());
             await kernel.use(new FeedServicePlugin());
             await kernel.use(new MetadataPlugin({ watch: false }));
+            await kernel.use(new AIServicePlugin());
 
             // Broker shim — bridges HttpDispatcher → ObjectQL engine
             (kernel as any).broker = createBrokerShim(kernel);

packages/adapters/hono/src/index.ts

@@ -66,6 +66,33 @@ export function createHonoApp(options: ObjectStackHonoOptions): Hono {
         if (res.type === 'redirect' && res.url) {
           return c.redirect(res.url);
         }
+        if (res.type === 'stream' && res.events) {
+          // SSE / Vercel Data Stream streaming response
+          const headers: Record<string, string> = {
+            'Content-Type': res.contentType || 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            ...(res.headers || {}),
+          };
+          const stream = new ReadableStream({
+            async start(controller) {
+              try {
+                const encoder = new TextEncoder();
+                for await (const event of res.events) {
+                  const chunk = res.vercelDataStream
+                    ? (typeof event === 'string' ? event : JSON.stringify(event) + '\n')
+                    : `data: ${JSON.stringify(event)}\n\n`;
+                  controller.enqueue(encoder.encode(chunk));
+                }
+              } catch (err) {
+                // Stream error — close gracefully
+              } finally {
+                controller.close();
+              }
+            },
+          });
+          return new Response(stream, { status: 200, headers });
+        }
         if (res.type === 'stream' && res.stream) {
           if (res.headers) {
             Object.entries(res.headers).forEach(([k, v]) => c.header(k, v as string));

packages/cli/src/commands/serve.ts

@@ -243,6 +243,22 @@ export default class Serve extends Command {
         // No translations and no explicit i18n plugin — this is fine, kernel fallback works
       }
 
+      // 3c. Auto-register AIServicePlugin if not already present
+      const hasAiPlugin = plugins.some(
+        (p: any) => p.name === 'com.objectstack.service-ai'
+            || p.constructor?.name === 'AIServicePlugin'
+      );
+      if (!hasAiPlugin) {
+        try {
+          const aiPkg = '@objectstack/service-ai';
+          const { AIServicePlugin } = await import(/* webpackIgnore: true */ aiPkg);
+          await kernel.use(new AIServicePlugin());
+          trackPlugin('AIService');
+        } catch {
+          // @objectstack/service-ai not installed — skip
+        }
+      }
+
       // Add HTTP server plugin BEFORE config plugins so that the
       // http-server service is available for any plugin that needs it
       // during init/start (e.g. AuthPlugin).

packages/plugins/plugin-audit/src/audit-plugin.ts

@@ -25,6 +25,22 @@ export class AuditPlugin implements Plugin {
       objects: [SysAuditLog],
     });
 
+    // Contribute navigation items to the Setup App (if SetupPlugin is loaded).
+    try {
+      const setupNav = ctx.getService<{ contribute(c: any): void }>('setupNav');
+      if (setupNav) {
+        setupNav.contribute({
+          areaId: 'area_system',
+          items: [
+            { id: 'nav_audit_logs', type: 'object', label: { key: 'setup.nav.audit_logs', defaultValue: 'Audit Logs' }, objectName: 'audit_log', icon: 'scroll-text', order: 10 },
+          ],
+        });
+        ctx.logger.info('Audit navigation items contributed to Setup App');
+      }
+    } catch {
+      // SetupPlugin not loaded — skip silently
+    }
+
     ctx.logger.info('Audit Plugin initialized');
   }
 }

packages/plugins/plugin-auth/src/auth-plugin.ts

@@ -112,6 +112,27 @@ export class AuthPlugin implements Plugin {
       ],
     });
 
+    // Contribute navigation items to the Setup App (if SetupPlugin is loaded).
+    // Uses try/catch so AuthPlugin works independently of SetupPlugin.
+    try {
+      const setupNav = ctx.getService<{ contribute(c: any): void }>('setupNav');
+      if (setupNav) {
+        setupNav.contribute({
+          areaId: 'area_administration',
+          items: [
+            { id: 'nav_users', type: 'object', label: { key: 'setup.nav.users', defaultValue: 'Users' }, objectName: 'user', icon: 'users', order: 10 },
+            { id: 'nav_organizations', type: 'object', label: { key: 'setup.nav.organizations', defaultValue: 'Organizations' }, objectName: 'organization', icon: 'building-2', order: 20 },
+            { id: 'nav_teams', type: 'object', label: { key: 'setup.nav.teams', defaultValue: 'Teams' }, objectName: 'team', icon: 'users-round', order: 30 },
+            { id: 'nav_api_keys', type: 'object', label: { key: 'setup.nav.api_keys', defaultValue: 'API Keys' }, objectName: 'api_key', icon: 'key', order: 40 },
+            { id: 'nav_sessions', type: 'object', label: { key: 'setup.nav.sessions', defaultValue: 'Sessions' }, objectName: 'session', icon: 'monitor', order: 50 },
+          ],
+        });
+        ctx.logger.info('Auth navigation items contributed to Setup App');
+      }
+    } catch {
+      // SetupPlugin not loaded — skip silently
+    }
+
     ctx.logger.info('Auth Plugin initialized successfully');
   }
 

packages/plugins/plugin-security/src/security-plugin.ts

@@ -48,6 +48,23 @@ export class SecurityPlugin implements Plugin {
       objects: [SysRole, SysPermissionSet],
     });
 
+    // Contribute navigation items to the Setup App (if SetupPlugin is loaded).
+    try {
+      const setupNav = ctx.getService<{ contribute(c: any): void }>('setupNav');
+      if (setupNav) {
+        setupNav.contribute({
+          areaId: 'area_administration',
+          items: [
+            { id: 'nav_roles', type: 'object', label: { key: 'setup.nav.roles', defaultValue: 'Roles' }, objectName: 'role', icon: 'shield-check', order: 60 },
+            { id: 'nav_permission_sets', type: 'object', label: { key: 'setup.nav.permission_sets', defaultValue: 'Permission Sets' }, objectName: 'permission_set', icon: 'lock', order: 70 },
+          ],
+        });
+        ctx.logger.info('Security navigation items contributed to Setup App');
+      }
+    } catch {
+      // SetupPlugin not loaded — skip silently
+    }
+
     ctx.logger.info('Security Plugin initialized');
   }
 

packages/runtime/src/dispatcher-plugin.ts

@@ -11,6 +11,17 @@ export interface DispatcherPluginConfig {
     prefix?: string;
 }
 
+/**
+ * Route definition emitted by service plugins (e.g. AIServicePlugin) via hooks.
+ * Minimal interface — matches the shape produced by `buildAIRoutes()`.
+ */
+interface RouteDefinition {
+    method: 'GET' | 'POST' | 'DELETE';
+    path: string;
+    description: string;
+    handler: (req: any) => Promise<any>;
+}
+
 /**
  * Send an HttpDispatcherResult through IHttpResponse.
  * Differentiates between handled, unhandled (404), and special results.
@@ -379,6 +390,82 @@ export function createDispatcherPlugin(config: DispatcherPluginConfig = {}): Plu
             });
 
             ctx.logger.info('Dispatcher bridge routes registered', { prefix });
+
+            // ── Dynamic service routes (AI, etc.) ───────────────────
+            // Listen for route definitions emitted by service plugins.
+            // The AIServicePlugin emits 'ai:routes' with RouteDefinition[].
+            ctx.hook('ai:routes', async (routes: RouteDefinition[]) => {
+                if (!server) return;
+                for (const route of routes) {
+                    // Strip the /api/v1 prefix if present (it's already in the path)
+                    // and register on the HTTP server with the configured prefix.
+                    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);
+                                res.header('Content-Type', result.vercelDataStream
+                                    ? 'text/plain; charset=utf-8'
+                                    : 'text/event-stream');
+                                res.header('Cache-Control', 'no-cache');
+                                res.header('Connection', 'keep-alive');
+
+                                // Write the stream — IHttpServer implementations
+                                // may or may not support raw write.  Fall back to
+                                // collecting and sending JSON if write is unavailable.
+                                if (typeof res.write === 'function' && typeof res.end === 'function') {
+                                    for await (const event of result.events) {
+                                        if (result.vercelDataStream) {
+                                            // Events are already TextStreamPart — need encoding
+                                            // Import is dynamic to avoid hard dep on service-ai
+                                            res.write(typeof event === 'string' ? event : JSON.stringify(event) + '\n');
+                                        } else {
+                                            res.write(`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);
+                    }
+                }
+                ctx.logger.info(`[Dispatcher] Registered ${routes.length} AI routes`);
+            });
         },
     };
 }

packages/runtime/src/http-dispatcher.ts

@@ -1210,6 +1210,107 @@ export class HttpDispatcher {
         return s.charAt(0).toUpperCase() + s.slice(1);
     }
 
+    /**
+     * Handle AI service routes (/ai/chat, /ai/models, /ai/conversations, etc.)
+     * Resolves the AI service and its built-in route handlers, then dispatches.
+     */
+    async handleAI(subPath: string, method: string, body: any, query: any, _context: HttpProtocolContext): Promise<HttpDispatcherResult> {
+        let aiService: any;
+        try {
+            aiService = await this.resolveService('ai');
+        } catch {
+            // AI service not registered
+        }
+
+        if (!aiService) {
+            return {
+                handled: true,
+                response: {
+                    status: 404,
+                    body: { success: false, error: { message: 'AI service is not configured', code: 404 } },
+                },
+            };
+        }
+
+        // The AI service exposes route definitions via buildAIRoutes.
+        // We match the request path against known AI route patterns.
+        const fullPath = `/api/v1${subPath}`;
+
+        // Build a simple param-extracting matcher for route patterns like /api/v1/ai/conversations/:id
+        const matchRoute = (pattern: string, path: string): Record<string, string> | null => {
+            const patternParts = pattern.split('/');
+            const pathParts = path.split('/');
+            if (patternParts.length !== pathParts.length) return null;
+            const params: Record<string, string> = {};
+            for (let i = 0; i < patternParts.length; i++) {
+                if (patternParts[i].startsWith(':')) {
+                    params[patternParts[i].substring(1)] = pathParts[i];
+                } else if (patternParts[i] !== pathParts[i]) {
+                    return null;
+                }
+            }
+            return params;
+        };
+
+        // Try to get route definitions from the AI service's cached routes
+        const routes = (this.kernel as any).__aiRoutes as Array<{
+            method: string; path: string; handler: (req: any) => Promise<any>;
+        }> | undefined;
+
+        if (!routes) {
+            return {
+                handled: true,
+                response: {
+                    status: 503,
+                    body: { success: false, error: { message: 'AI service routes not yet initialized', code: 503 } },
+                },
+            };
+        }
+
+        for (const route of routes) {
+            if (route.method !== method) continue;
+            const params = matchRoute(route.path, fullPath);
+            if (params === null) continue;
+
+            const result = await route.handler({ body, params, query });
+
+            if (result.stream && result.events) {
+                // Return a streaming result for the adapter to handle
+                return {
+                    handled: true,
+                    result: {
+                        type: 'stream',
+                        contentType: result.vercelDataStream
+                            ? 'text/plain; charset=utf-8'
+                            : 'text/event-stream',
+                        events: result.events,
+                        vercelDataStream: result.vercelDataStream,
+                        headers: {
+                            'Content-Type': result.vercelDataStream
+                                ? 'text/plain; charset=utf-8'
+                                : 'text/event-stream',
+                            'Cache-Control': 'no-cache',
+                            'Connection': 'keep-alive',
+                        },
+                    },
+                };
+            }
+
+            return {
+                handled: true,
+                response: {
+                    status: result.status,
+                    body: result.body,
+                },
+            };
+        }
+
+        return {
+            handled: true,
+            response: this.routeNotFound(subPath),
+        };
+    }
+
     /**
      * Main Dispatcher Entry Point
      * Routes the request to the appropriate handler based on path and precedence
@@ -1284,6 +1385,11 @@ export class HttpDispatcher {
              return this.handleI18n(cleanPath.substring(5), method, query, context);
         }
 
+        // AI Service — delegate to the registered AI route handlers
+        if (cleanPath.startsWith('/ai')) {
+             return this.handleAI(cleanPath, method, body, query, context);
+        }
+
         // OpenAPI Specification
         if (cleanPath === '/openapi.json' && method === 'GET') {
              const broker = this.ensureBroker();

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

@@ -171,6 +171,12 @@ export class AIServicePlugin implements Plugin {
     // Trigger hook so HTTP server plugins can mount these routes
     await ctx.trigger('ai:routes', routes);
 
+    // Cache routes on the kernel so HttpDispatcher can find them
+    const kernel = ctx.getKernel();
+    if (kernel) {
+      (kernel as any).__aiRoutes = routes;
+    }
+
     ctx.logger.info(
       `[AI] Service started — adapter="${this.service.adapterName}", ` +
       `tools=${this.service.toolRegistry.size}, ` +