@vertesia/tools-sdk 1.4.0-dev.20260615.042549Z → 1.4.0-dev.20260629.130134Z

package/src/server/app-package.ts

@@ -1,5 +1,4 @@
 import type {
-    AppDashboardDefinition,
     AppPackage,
     AppPackageScope,
     AppWidgetInfo,
@@ -16,19 +15,14 @@ function getRequestPayload<T>(c: Context): Promise<T | undefined> {
     return c.req.method === 'POST' ? c.req.json<T>() : Promise.resolve(undefined);
 }
 
-export interface BuildAppPackageOptions {
-    scope?: AppPackageScope | AppPackageScope[] | string;
-    origin?: string;
-    toolUseContext?: ToolUseContext;
-}
-
-type AppPackageBuilder = (pkg: AppPackage, config: ToolServerConfig, options: BuildAppPackageOptions) => Promise<void>;
-
-const builders: Record<Exclude<AppPackageScope, 'all'>, AppPackageBuilder> = {
-    async tools(pkg: AppPackage, config: ToolServerConfig, options: BuildAppPackageOptions) {
+const builders: Record<
+    Exclude<AppPackageScope, 'all'>,
+    (pkg: AppPackage, config: ToolServerConfig, c: Context) => Promise<void>
+> = {
+    async tools(pkg: AppPackage, config: ToolServerConfig, c: Context) {
         const { tools: toolCollections = [], skills: skillCollections = [] } = config;
 
-        const filterContext = options.toolUseContext;
+        const filterContext = await getRequestPayload<ToolUseContext>(c);
 
         // Aggregate all tools from all collections
         const allTools = toolCollections.flatMap((collection) => collection.getToolDefinitions(filterContext));
@@ -65,23 +59,13 @@ const builders: Record<Exclude<AppPackageScope, 'all'>, AppPackageBuilder> = {
         pkg.interactions = allInteractions;
     },
     async types(pkg: AppPackage, config: ToolServerConfig) {
-        // A type's public id is its BARE name: stored objects reference it as the portable
-        // `app:<app>:<type>` string, so the in-code collection (a code-organization grouping,
-        // unlike tool/skill collections which are semantic) must NOT leak into the id.
-        // Names must therefore be unique across collections — fail the package build otherwise.
         const allTypes: InCodeTypeDefinition[] = [];
-        const seen = new Map<string, string>();
         for (const coll of config.types || []) {
             for (const type of coll.types) {
-                const existing = seen.get(type.name);
-                if (existing) {
-                    throw new Error(
-                        `Duplicate content type name '${type.name}' (collections '${existing}' and '${coll.name}'). ` +
-                            `Type names must be unique across collections so the portable 'app:<app>:${type.name}' ref resolves.`,
-                    );
-                }
-                seen.set(type.name, coll.name);
-                allTypes.push({ ...type, id: type.name });
+                allTypes.push({
+                    ...type,
+                    id: `${coll.name}:${type.name}`,
+                });
             }
         }
         pkg.types = allTypes;
@@ -102,19 +86,6 @@ const builders: Record<Exclude<AppPackageScope, 'all'>, AppPackageBuilder> = {
             })),
         );
     },
-    async dashboards(pkg: AppPackage, config: ToolServerConfig) {
-        const seen = new Set<string>();
-        const dashboards: AppDashboardDefinition[] = [];
-        for (const dashboard of config.dashboards || []) {
-            if (seen.has(dashboard.id)) {
-                console.warn(`[app-package] Duplicate dashboard id "${dashboard.id}", skipping`);
-                continue;
-            }
-            seen.add(dashboard.id);
-            dashboards.push(dashboard);
-        }
-        pkg.dashboards = dashboards;
-    },
     async widgets(pkg: AppPackage, config: ToolServerConfig) {
         const { skills: skillCollections = [] } = config;
         const widgets: Record<string, AppWidgetInfo> = {};
@@ -131,10 +102,10 @@ const builders: Record<Exclude<AppPackageScope, 'all'>, AppPackageBuilder> = {
         }
         pkg.widgets = widgets;
     },
-    async ui(pkg: AppPackage, config: ToolServerConfig, options: BuildAppPackageOptions) {
+    async ui(pkg: AppPackage, config: ToolServerConfig, c: Context) {
         if (config.uiConfig) {
             pkg.ui = { ...config.uiConfig };
-            const origin = options.origin || 'http://localhost';
+            const origin = new URL(c.req.url).origin;
             pkg.ui.src = new URL(pkg.ui.src, origin).toString();
             if (!pkg.ui.isolation) {
                 pkg.ui.isolation = 'shadow';
@@ -157,71 +128,52 @@ const builders: Record<Exclude<AppPackageScope, 'all'>, AppPackageBuilder> = {
     },
 };
 
-function normalizeScopes(scope: BuildAppPackageOptions['scope']): Set<AppPackageScope> {
-    const values = Array.isArray(scope) ? scope : typeof scope === 'string' ? scope.split(',') : [scope || 'all'];
-    return new Set(values.filter(Boolean) as AppPackageScope[]);
-}
-
-export async function buildAppPackage(
-    config: ToolServerConfig,
-    options: BuildAppPackageOptions = {},
-): Promise<AppPackage> {
+async function handlePackageRequest(c: Context, config: ToolServerConfig) {
+    const scope = c.req.query('scope') || 'all';
     const pkg: AppPackage = {};
 
-    const scopes = normalizeScopes(options.scope);
+    const scopes = new Set<AppPackageScope>(scope.split(',') as AppPackageScope[]);
+    // TODO build pkg based on the query param scope
     if (scopes.has('all')) {
-        await builders.tools(pkg, config, options);
-        await builders.interactions(pkg, config, options);
-        await builders.types(pkg, config, options);
-        await builders.processes(pkg, config, options);
-        await builders.templates(pkg, config, options);
-        await builders.dashboards(pkg, config, options);
-        await builders.widgets(pkg, config, options);
-        await builders.ui(pkg, config, options);
-        await builders.settings(pkg, config, options);
-        await builders.activities(pkg, config, options);
+        await builders.tools(pkg, config, c);
+        await builders.interactions(pkg, config, c);
+        await builders.types(pkg, config, c);
+        await builders.processes(pkg, config, c);
+        await builders.templates(pkg, config, c);
+        await builders.widgets(pkg, config, c);
+        await builders.ui(pkg, config, c);
+        await builders.settings(pkg, config, c);
+        await builders.activities(pkg, config, c);
     } else {
         if (scopes.has('tools')) {
-            await builders.tools(pkg, config, options);
+            await builders.tools(pkg, config, c);
         }
         if (scopes.has('interactions')) {
-            await builders.interactions(pkg, config, options);
+            await builders.interactions(pkg, config, c);
         }
         if (scopes.has('types')) {
-            await builders.types(pkg, config, options);
+            await builders.types(pkg, config, c);
         }
         if (scopes.has('processes')) {
-            await builders.processes(pkg, config, options);
+            await builders.processes(pkg, config, c);
         }
         if (scopes.has('templates')) {
-            await builders.templates(pkg, config, options);
-        }
-        if (scopes.has('dashboards')) {
-            await builders.dashboards(pkg, config, options);
+            await builders.templates(pkg, config, c);
         }
         if (scopes.has('widgets')) {
-            await builders.widgets(pkg, config, options);
+            await builders.widgets(pkg, config, c);
         }
         if (scopes.has('ui')) {
-            await builders.ui(pkg, config, options);
+            await builders.ui(pkg, config, c);
         }
         if (scopes.has('settings')) {
-            await builders.settings(pkg, config, options);
+            await builders.settings(pkg, config, c);
         }
         if (scopes.has('activities')) {
-            await builders.activities(pkg, config, options);
+            await builders.activities(pkg, config, c);
         }
     }
 
-    return pkg;
-}
-
-async function handlePackageRequest(c: Context, config: ToolServerConfig) {
-    const pkg = await buildAppPackage(config, {
-        scope: c.req.query('scope') || 'all',
-        origin: new URL(c.req.url).origin,
-        toolUseContext: await getRequestPayload<ToolUseContext>(c),
-    });
     return c.json(pkg);
 }
 

package/src/server/content-types.ts

@@ -10,15 +10,13 @@ import type { ToolServerConfig } from './types.js';
 export function createContentTypesRoute(app: Hono, basePath: string, config: ToolServerConfig) {
     const { types = [] } = config;
 
-    // GET /api/types - Returns all content types from all collections.
-    // A type's public id is its declared BARE name, verbatim (`app:<app>:<type>` once
-    // app-prefixed): collections organize code, they are not part of the type identity.
+    // GET /api/types - Returns all interactions from all collections
     app.get(basePath, (c) => {
         const allTypes: InCodeTypeDefinition[] = [];
 
         for (const coll of types) {
             for (const type of coll.types) {
-                allTypes.push({ ...type, id: type.name });
+                allTypes.push({ ...type, id: `${coll.name}:${toPathName(type.name)}` });
             }
         }
 
@@ -39,51 +37,20 @@ export function createContentTypesRoute(app: Hono, basePath: string, config: Too
         app.route(`${basePath}/${coll.name}`, createContentTypeEndpoints(coll));
     }
 
-    // GET /api/types/:name - Direct access to content type.
-    // Canonical form is the BARE type name (`<type>`), matching the portable
-    // `app:<app>:<type>` ref convention used by objects.create/search — the
-    // collection is an in-code grouping, not part of the type's public id.
-    // `<collection>:<type>` is also accepted as a backward-compatible alias.
+    // GET /api/types/:name - Direct access to content type
     app.get(`${basePath}/:name`, async (c) => {
         const name = c.req.param('name');
         const parts = name.split(':');
-        if (parts.length === 1) {
-            // Match the declared name verbatim; fall back to the toPathName variant for
-            // leniency with legacy refs that used the path-mangled form.
-            const matches = types.flatMap((coll) =>
-                coll.types
-                    .filter((t) => t.name === name || toPathName(t.name) === name)
-                    .map((t) => ({ coll, type: t })),
-            );
-            if (matches.length === 1) {
-                return c.json({ ...matches[0].type, id: matches[0].type.name });
-            }
-            if (matches.length > 1) {
-                const colls = matches.map((m) => m.coll.name).join(', ');
-                throw new HTTPException(409, {
-                    message:
-                        `Ambiguous content type name '${name}': defined in collections ${colls}. ` +
-                        'Type names must be unique across collections so the portable ' +
-                        `'app:<app>:${name}' ref resolves; rename one of them, or address it as '<collection>:<type>'.`,
-                });
-            }
-            throw new HTTPException(404, {
-                message: `No content type found with name: ${name}`,
-            });
-        }
         if (parts.length !== 2) {
             throw new HTTPException(400, {
-                message: "Invalid content type name. Expected '<type>' or 'collection:type'",
+                message: "Invalid content type name. Expected format 'collection:type'",
             });
         }
         const collName = parts[0];
-        const typeName = parts[1];
-        const ctype = types
-            .find((t) => t.name === collName)
-            ?.types.find((t) => t.name === typeName || toPathName(t.name) === toPathName(typeName));
+        const typeName = toPathName(parts[1]);
+        const ctype = types.find((t) => t.name === collName)?.getTypeByName(typeName);
         if (ctype) {
-            // Alias lookup still returns the canonical bare id.
-            return c.json({ ...ctype, id: ctype.name });
+            return c.json({ ...ctype, id: `${collName}:${typeName}` });
         }
 
         throw new HTTPException(404, {
@@ -96,12 +63,12 @@ function createContentTypeEndpoints(coll: ContentTypesCollection): Hono {
     const endpoint = new Hono();
 
     endpoint.get('/', (c: Context) => {
-        return c.json(coll.types.map((t) => ({ ...t, id: t.name })));
+        return c.json(coll.types.map((t) => ({ ...t, id: `${coll.name}:${toPathName(t.name)}` })));
     });
 
     endpoint.get('/:name', (c: Context) => {
         const name = c.req.param('name');
-        const ctype = coll.types.find((t) => t.name === name || toPathName(t.name) === name);
+        const ctype = coll.types.find((t) => toPathName(t.name) === name);
         if (!ctype) {
             throw new HTTPException(404, {
                 message: `No content type found with name: ${name}`,
@@ -109,7 +76,7 @@ function createContentTypeEndpoints(coll: ContentTypesCollection): Hono {
         }
         return c.json({
             ...ctype,
-            id: ctype.name,
+            id: `${coll.name}:${toPathName(ctype.name)}`,
         });
     });
 

package/src/server/types.ts

@@ -1,10 +1,5 @@
 import type { JSONSchema } from '@llumiverse/common';
-import type {
-    AppDashboardDefinition,
-    AppUIConfig,
-    InCodeProcessDefinition,
-    ProjectConfiguration,
-} from '@vertesia/common';
+import type { AppUIConfig, InCodeProcessDefinition, ProjectConfiguration } from '@vertesia/common';
 import type { Context } from 'hono';
 import type { ActivityCollection } from '../ActivityCollection.js';
 import type { AuthSession } from '../auth.js';
@@ -68,10 +63,6 @@ export interface ToolServerConfig {
      * Process definitions to expose as app-contributed processes.
      */
     processes?: InCodeProcessDefinition[];
-    /**
-     * Dashboard definitions to expose as app-contributed dashboards.
-     */
-    dashboards?: AppDashboardDefinition[];
     /**
      * Skill collections to expose
      */

package/src/server.ts

@@ -5,7 +5,6 @@ import { z } from 'zod';
 import { createActivitiesRoute } from './server/activities.js';
 import { createPackageRoute } from './server/app-package.js';
 import { createContentTypesRoute } from './server/content-types.js';
-import { createDashboardsRoute } from './server/dashboards.js';
 import { createInteractionsRoute } from './server/interactions.js';
 import { createMcpRoute } from './server/mcp.js';
 import { createProcessesRoute } from './server/processes.js';
@@ -50,7 +49,6 @@ export function createToolServer(config: ToolServerConfig): Hono {
         skills = [],
         templates = [],
         activities = [],
-        dashboards = [],
         mcpProviders = [],
         disableHtml = false,
     } = config;
@@ -102,7 +100,6 @@ export function createToolServer(config: ToolServerConfig): Hono {
                 interactions: interactions.map((col) => `${prefix}/interactions/${col.name}`),
                 templates: templates.map((col) => `${prefix}/templates/${col.name}`),
                 processes: `${prefix}/processes`,
-                dashboards: dashboards.length > 0 ? `${prefix}/dashboards` : undefined,
                 activities: activities.map((col) => `${prefix}/activities/${col.name}`),
                 mcp: mcpProviders.map((p) => `${prefix}/mcp/${p.name}`),
             },
@@ -118,7 +115,6 @@ export function createToolServer(config: ToolServerConfig): Hono {
     createTemplatesRoute(app, `${prefix}/templates`, config);
     createContentTypesRoute(app, `${prefix}/types`, config);
     createProcessesRoute(app, `${prefix}/processes`, config);
-    createDashboardsRoute(app, `${prefix}/dashboards`, config);
     createMcpRoute(app, `${prefix}/mcp`, config);
 
     // Global error handler - returns ToolExecutionResponseError format

package/src/types.ts

@@ -99,6 +99,16 @@ export type ToolFn<ParamsT extends object = object> = (
     context: ToolExecutionContext,
 ) => Promise<ToolExecutionResult>;
 
+/**
+ * Approval behavior class for a tool.
+ *
+ * - `read_only`: reads or inspects state without changing Vertesia, external systems, or user-visible artifacts.
+ * - `side_effecting`: can create, update, delete, send, execute, schedule, or otherwise change state.
+ * - `control`: affects agent control flow or tool availability, not user data or external systems.
+ * - `requires_confirmation`: high-impact action that must ask the user even in interactive full-control mode.
+ */
+export type ToolApprovalClassification = 'read_only' | 'side_effecting' | 'control' | 'requires_confirmation';
+
 export interface ToolUseContext {
     project_id?: string;
     account_id?: string;
@@ -124,12 +134,11 @@ export interface Tool<ParamsT extends object = object> extends ToolDefinition {
     annotations?: MCPToolAnnotations;
 
     /**
-     * When true, agents must obtain explicit user confirmation via `ask_user`
-     * (Yes/No) before invoking this tool. If the user answers No, the tool
-     * must not run. Stronger than `annotations.destructiveHint` — this is a
-     * hard contract.
+     * Internal approval classification used by interactive agent approval modes.
+     * Use `requires_confirmation` for actions that must prompt even in full-control mode.
+     * Remote/MCP tools can omit this and rely on annotations.
      */
-    requires_user_confirmation?: boolean;
+    approval_class?: ToolApprovalClassification;
 
     /**
      * Optional filter to check if the tool is enabled for the given project configuration.

package/lib/server/dashboards.d.ts

@@ -1,4 +0,0 @@
-import type { Hono } from 'hono';
-import type { ToolServerConfig } from './types.js';
-export declare function createDashboardsRoute(app: Hono, basePath: string, config: ToolServerConfig): void;
-//# sourceMappingURL=dashboards.d.ts.map

package/lib/server/dashboards.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dashboards.d.ts","sourceRoot":"","sources":["../../src/server/dashboards.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAEjC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,QAqB1F"}

package/lib/server/dashboards.js

@@ -1,25 +0,0 @@
-import { HTTPException } from 'hono/http-exception';
-export function createDashboardsRoute(app, basePath, config) {
-    const { dashboards = [] } = config;
-    app.get(basePath, (c) => {
-        return c.json({
-            title: 'All Dashboards',
-            description: 'All available dashboard definitions',
-            dashboards,
-        });
-    });
-    app.get(`${basePath}/:id`, (c) => {
-        const id = c.req.param('id');
-        const dashboard = findDashboard(dashboards, id);
-        if (!dashboard) {
-            throw new HTTPException(404, {
-                message: `No dashboard found with id: ${id}`,
-            });
-        }
-        return c.json(dashboard);
-    });
-}
-function findDashboard(dashboards, id) {
-    return dashboards.find((dashboard) => dashboard.id === id || dashboard.name === id || dashboard.title === id);
-}
-//# sourceMappingURL=dashboards.js.map

package/lib/server/dashboards.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dashboards.js","sourceRoot":"","sources":["../../src/server/dashboards.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,MAAM,UAAU,qBAAqB,CAAC,GAAS,EAAE,QAAgB,EAAE,MAAwB;IACvF,MAAM,EAAE,UAAU,GAAG,EAAE,EAAE,GAAG,MAAM,CAAC;IAEnC,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE;QACpB,OAAO,CAAC,CAAC,IAAI,CAAC;YACV,KAAK,EAAE,gBAAgB;YACvB,WAAW,EAAE,qCAAqC;YAClD,UAAU;SACb,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;IAEH,GAAG,CAAC,GAAG,CAAC,GAAG,QAAQ,MAAM,EAAE,CAAC,CAAC,EAAE,EAAE;QAC7B,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC7B,MAAM,SAAS,GAAG,aAAa,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;QAChD,IAAI,CAAC,SAAS,EAAE,CAAC;YACb,MAAM,IAAI,aAAa,CAAC,GAAG,EAAE;gBACzB,OAAO,EAAE,+BAA+B,EAAE,EAAE;aAC/C,CAAC,CAAC;QACP,CAAC;QACD,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC7B,CAAC,CAAC,CAAC;AACP,CAAC;AAED,SAAS,aAAa,CAAC,UAAoC,EAAE,EAAU;IACnE,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,IAAI,SAAS,CAAC,IAAI,KAAK,EAAE,IAAI,SAAS,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC;AAClH,CAAC"}

package/src/server/app-package.test.ts

@@ -1,140 +0,0 @@
-import { PromptRole } from '@llumiverse/common';
-import { PROCESS_DEFINITION_FORMAT_VERSION, TemplateType } from '@vertesia/common';
-import { describe, expect, it } from 'vitest';
-import { ContentTypesCollection } from '../ContentTypesCollection.js';
-import { InteractionCollection } from '../InteractionCollection.js';
-import { buildAppPackage } from './app-package.js';
-import type { ToolServerConfig } from './types.js';
-
-describe('buildAppPackage', () => {
-    it('builds the same package artifact inventory used by the package route', async () => {
-        const config = {
-            interactions: [
-                new InteractionCollection({
-                    name: 'claims',
-                    interactions: [
-                        {
-                            name: 'review',
-                            title: 'Review Claim',
-                            prompts: [
-                                {
-                                    role: PromptRole.user,
-                                    content: '{{user_prompt}}',
-                                    content_type: TemplateType.handlebars,
-                                },
-                            ],
-                        },
-                    ],
-                }),
-            ],
-            types: [
-                new ContentTypesCollection({
-                    name: 'claims',
-                    types: [
-                        {
-                            name: 'claim',
-                            object_schema: {
-                                type: 'object',
-                                properties: {
-                                    status: { type: 'string' },
-                                },
-                            },
-                        },
-                    ],
-                }),
-            ],
-            processes: [
-                {
-                    id: 'claims:intake',
-                    name: 'Claims Intake',
-                    definition: {
-                        format_version: PROCESS_DEFINITION_FORMAT_VERSION,
-                        process: 'claims_intake',
-                        initial: 'done',
-                        context: {
-                            schema: {
-                                type: 'object',
-                                additionalProperties: true,
-                            },
-                            initial: {},
-                        },
-                        nodes: {
-                            done: { type: 'final', title: 'Done' },
-                        },
-                    },
-                },
-            ],
-            dashboards: [
-                {
-                    id: 'claims:ops',
-                    title: 'Claims Ops',
-                    spec: {},
-                },
-            ],
-            uiConfig: {
-                src: '/lib/plugin.js',
-                available_in: ['app_portal'],
-            },
-        } satisfies ToolServerConfig;
-
-        const pkg = await buildAppPackage(config, {
-            origin: 'https://apps.example.test',
-            scope: 'all',
-        });
-
-        expect(pkg.interactions?.map((interaction) => interaction.id)).toEqual(['claims:review']);
-        expect(pkg.types?.map((type) => type.id)).toEqual(['claim']);
-        expect(pkg.processes?.map((process) => process.id)).toEqual(['claims:intake']);
-        expect(pkg.dashboards?.map((dashboard) => dashboard.id)).toEqual(['claims:ops']);
-        expect(pkg.ui?.src).toBe('https://apps.example.test/lib/plugin.js');
-    });
-
-    it('honors package scopes', async () => {
-        const config = {
-            interactions: [
-                new InteractionCollection({
-                    name: 'claims',
-                    interactions: [{ name: 'review', prompts: [] }],
-                }),
-            ],
-            types: [
-                new ContentTypesCollection({
-                    name: 'claims',
-                    types: [{ name: 'claim' }],
-                }),
-            ],
-        } satisfies ToolServerConfig;
-
-        const pkg = await buildAppPackage(config, { scope: 'types' });
-
-        expect(pkg.types?.map((type) => type.id)).toEqual(['claim']);
-        expect(pkg.interactions).toBeUndefined();
-    });
-});
-
-describe('buildAppPackage type identity', () => {
-    it('exposes the bare type name as the public id (collections are code organization only)', async () => {
-        const config = {
-            types: [
-                new ContentTypesCollection({ name: 'claims', types: [{ name: 'claim' }] }),
-                new ContentTypesCollection({ name: 'audit', types: [{ name: 'audit_event' }] }),
-            ],
-        } satisfies ToolServerConfig;
-
-        const pkg = await buildAppPackage(config, { scope: 'types' });
-        expect(pkg.types?.map((type) => type.id)).toEqual(['claim', 'audit_event']);
-    });
-
-    it('fails the package build when a type name is duplicated across collections', async () => {
-        const config = {
-            types: [
-                new ContentTypesCollection({ name: 'claims', types: [{ name: 'claim' }] }),
-                new ContentTypesCollection({ name: 'legacy', types: [{ name: 'claim' }] }),
-            ],
-        } satisfies ToolServerConfig;
-
-        await expect(buildAppPackage(config, { scope: 'types' })).rejects.toThrow(
-            /Duplicate content type name 'claim'/,
-        );
-    });
-});

package/src/server/content-types.test.ts

@@ -1,64 +0,0 @@
-import { Hono } from 'hono';
-import { describe, expect, it } from 'vitest';
-import { ContentTypesCollection } from '../ContentTypesCollection.js';
-import { createContentTypesRoute } from './content-types.js';
-import type { ToolServerConfig } from './types.js';
-
-function makeApp(config: ToolServerConfig): Hono {
-    const app = new Hono();
-    createContentTypesRoute(app, '/api/types', config);
-    return app;
-}
-
-const config = {
-    types: [
-        new ContentTypesCollection({
-            name: 'contracts',
-            types: [{ name: 'contract' }, { name: 'review_note' }],
-        }),
-        new ContentTypesCollection({
-            name: 'audit',
-            types: [{ name: 'audit_event' }],
-        }),
-    ],
-} satisfies ToolServerConfig;
-
-describe('content types route', () => {
-    it('lists all types with bare ids (collection is not part of the type identity)', async () => {
-        const res = await makeApp(config).request('/api/types');
-        expect(res.status).toBe(200);
-        const body = (await res.json()) as { types: Array<{ id: string }> };
-        expect(body.types.map((t) => t.id)).toEqual(['contract', 'review_note', 'audit_event']);
-    });
-
-    it('resolves the canonical bare type name (the app:<app>:<type> ref convention)', async () => {
-        const res = await makeApp(config).request('/api/types/contract');
-        expect(res.status).toBe(200);
-        const body = (await res.json()) as { id: string; name: string };
-        expect(body.id).toBe('contract');
-        expect(body.name).toBe('contract');
-    });
-
-    it('still resolves the legacy collection:type alias, returning the bare id', async () => {
-        const res = await makeApp(config).request('/api/types/contracts:contract');
-        expect(res.status).toBe(200);
-        const body = (await res.json()) as { id: string };
-        expect(body.id).toBe('contract');
-    });
-
-    it('409s on an ambiguous bare name so the collision is loud, not silent', async () => {
-        const ambiguous = {
-            types: [
-                new ContentTypesCollection({ name: 'a', types: [{ name: 'note' }] }),
-                new ContentTypesCollection({ name: 'b', types: [{ name: 'note' }] }),
-            ],
-        } satisfies ToolServerConfig;
-        const res = await makeApp(ambiguous).request('/api/types/note');
-        expect(res.status).toBe(409);
-    });
-
-    it('404s for an unknown type name', async () => {
-        const res = await makeApp(config).request('/api/types/nope');
-        expect(res.status).toBe(404);
-    });
-});

package/src/server/dashboards.ts

@@ -1,31 +0,0 @@
-import type { AppDashboardDefinition } from '@vertesia/common';
-import type { Hono } from 'hono';
-import { HTTPException } from 'hono/http-exception';
-import type { ToolServerConfig } from './types.js';
-
-export function createDashboardsRoute(app: Hono, basePath: string, config: ToolServerConfig) {
-    const { dashboards = [] } = config;
-
-    app.get(basePath, (c) => {
-        return c.json({
-            title: 'All Dashboards',
-            description: 'All available dashboard definitions',
-            dashboards,
-        });
-    });
-
-    app.get(`${basePath}/:id`, (c) => {
-        const id = c.req.param('id');
-        const dashboard = findDashboard(dashboards, id);
-        if (!dashboard) {
-            throw new HTTPException(404, {
-                message: `No dashboard found with id: ${id}`,
-            });
-        }
-        return c.json(dashboard);
-    });
-}
-
-function findDashboard(dashboards: AppDashboardDefinition[], id: string): AppDashboardDefinition | undefined {
-    return dashboards.find((dashboard) => dashboard.id === id || dashboard.name === id || dashboard.title === id);
-}