@vertesia/tools-sdk 1.0.0-dev.20260128.144200 → 1.0.0-dev.20260203.130115Z

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertesia/tools-sdk",
-  "version": "1.0.0-dev.20260128.144200",
+  "version": "1.0.0-dev.20260203.130115Z",
   "description": "Tools SDK - utilities for building remote tools",
   "type": "module",
   "types": "./lib/types/index.d.ts",
@@ -27,14 +27,14 @@
     "outDir": "lib"
   },
   "peerDependencies": {
-    "hono": "^4.11.4"
+    "hono": "^4.11.7"
   },
   "dependencies": {
     "jose": "^6.0.11",
     "zod": "^4.3.5",
-    "@llumiverse/common": "1.0.0-dev.20260128.144200",
-    "@vertesia/client": "1.0.0-dev.20260128.144200",
-    "@vertesia/common": "1.0.0-dev.20260128.144200"
+    "@llumiverse/common": "1.0.0-dev.20260202.145450Z",
+    "@vertesia/common": "1.0.0-dev.20260203.130115Z",
+    "@vertesia/client": "1.0.0-dev.20260203.130115Z"
   },
   "repository": {
     "type": "git",

package/src/ContentTypesCollection.ts

@@ -0,0 +1,51 @@
+import { InCodeTypeDefinition } from "@vertesia/common";
+import { CollectionProperties, ICollection } from "./types.js";
+import { kebabCaseToTitle } from "./utils.js";
+
+export interface ContentTypesCollectionProps extends CollectionProperties {
+    types: InCodeTypeDefinition[];
+}
+export class ContentTypesCollection implements ICollection<InCodeTypeDefinition> {
+    types: InCodeTypeDefinition[];
+    name: string;
+    title?: string;
+    icon?: string;
+    description?: string;
+    constructor({
+        name, title, icon, description, types
+    }: ContentTypesCollectionProps) {
+        this.name = name;
+        this.title = title || kebabCaseToTitle(name);
+        this.icon = icon;
+        this.description = description;
+        this.types = types;
+    }
+
+    getContentTypes() {
+        return this.types;
+    }
+
+    [Symbol.iterator](): Iterator<InCodeTypeDefinition> {
+        let index = 0;
+        const types = this.types;
+
+        return {
+            next(): IteratorResult<InCodeTypeDefinition> {
+                if (index < types.length) {
+                    return { value: types[index++], done: false };
+                } else {
+                    return { done: true, value: undefined };
+                }
+            }
+        };
+    }
+
+    map<U>(callback: (type: InCodeTypeDefinition, index: number) => U): U[] {
+        return this.types.map(callback);
+    }
+
+    getTypeByName(name: string): InCodeTypeDefinition | undefined {
+        return this.types.find(type => type.name === name);
+    }
+
+}

package/src/InteractionCollection.ts

@@ -1,8 +1,5 @@
-import { readdirSync, statSync, existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { pathToFileURL } from "url";
 import { InteractionSpec } from "@vertesia/common";
-import { ICollection, CollectionProperties } from "./types.js";
+import { CollectionProperties, ICollection } from "./types.js";
 import { kebabCaseToTitle } from "./utils.js";
 
 export interface InteractionCollectionProps extends CollectionProperties {
@@ -23,9 +20,6 @@ export class InteractionCollection implements ICollection<InteractionSpec> {
         this.description = description;
         this.interactions = interactions;
     }
-    addInteraction(interaction: any) {
-        this.interactions.push(interaction);
-    }
 
     getInteractions() {
         return this.interactions;
@@ -54,90 +48,3 @@ export class InteractionCollection implements ICollection<InteractionSpec> {
         return this.interactions.find(interaction => interaction.name === name);
     }
 }
-
-/**
- * Load all interactions from a directory.
- * Scans for subdirectories containing index.ts/index.js files.
- *
- * Directory structure:
- * ```
- * interactions/
- *   nagare/
- *     extract-fund-actuals/
- *       index.ts       # exports default InteractionSpec
- *       prompt.jst     # prompt template (read via readPromptFile helper)
- *     parse-fund-document/
- *       index.ts
- *       prompt.md
- * ```
- *
- * @param interactionsDir - Path to the interactions collection directory
- * @returns Promise resolving to array of InteractionSpec objects
- */
-export async function loadInteractionsFromDirectory(interactionsDir: string): Promise<InteractionSpec[]> {
-    const interactions: InteractionSpec[] = [];
-
-    if (!existsSync(interactionsDir)) {
-        console.warn(`Interactions directory not found: ${interactionsDir}`);
-        return interactions;
-    }
-
-    let entries: string[];
-    try {
-        entries = readdirSync(interactionsDir);
-    } catch {
-        console.warn(`Could not read interactions directory: ${interactionsDir}`);
-        return interactions;
-    }
-
-    for (const entry of entries) {
-        // Skip hidden files and index files
-        if (entry.startsWith('.')) continue;
-        if (entry === 'index.ts' || entry === 'index.js') continue;
-
-        const entryPath = join(interactionsDir, entry);
-
-        try {
-            const stat = statSync(entryPath);
-            if (!stat.isDirectory()) continue;
-
-            // Look for index.ts or index.js in the subdirectory
-            const indexTs = join(entryPath, 'index.ts');
-            const indexJs = join(entryPath, 'index.js');
-            const indexPath = existsSync(indexTs) ? indexTs : existsSync(indexJs) ? indexJs : null;
-
-            if (!indexPath) {
-                continue; // No index file, skip
-            }
-
-            // Dynamic import
-            const fileUrl = pathToFileURL(indexPath).href;
-            const module = await import(fileUrl);
-
-            const interaction = module.default || module.interaction;
-
-            if (interaction && typeof interaction.name === 'string') {
-                interactions.push(interaction);
-            } else {
-                console.warn(`No valid InteractionSpec export found in ${entry}/index`);
-            }
-        } catch (err) {
-            console.warn(`Error loading interaction from ${entry}:`, err);
-        }
-    }
-
-    return interactions;
-}
-
-/**
- * Helper to read a prompt file from the same directory as the interaction.
- * Use this in interaction index.ts files to load prompt templates.
- *
- * @param dirname - Pass __dirname or dirname(fileURLToPath(import.meta.url))
- * @param filename - Prompt filename (e.g., 'prompt.jst' or 'prompt.md')
- * @returns File contents as string
- */
-export function readPromptFile(dirname: string, filename: string): string {
-    const filePath = join(dirname, filename);
-    return readFileSync(filePath, 'utf-8');
-}

package/src/SkillCollection.ts

@@ -11,11 +11,11 @@ import type {
     SkillDefinition,
     SkillExecutionResult,
     ToolCollectionDefinition,
-    ToolDefinitionWithDefault,
     ToolExecutionPayload,
     ToolExecutionResult,
 } from "./types.js";
 import { kebabCaseToTitle } from "./utils.js";
+import { AgentToolDefinition } from "@vertesia/common";
 
 export interface SkillCollectionProperties extends CollectionProperties {
     /**
@@ -87,7 +87,7 @@ export class SkillCollection implements ICollection<SkillDefinition> {
      * When called, they return rendered instructions.
      * Includes related_tools for dynamic tool discovery.
      */
-    getToolDefinitions(): ToolDefinitionWithDefault[] {
+    getToolDefinitions(): AgentToolDefinition[] {
         const defaultSchema: ToolDefinition['input_schema'] = {
             type: 'object',
             properties: {
@@ -110,6 +110,7 @@ export class SkillCollection implements ICollection<SkillDefinition> {
                 description,
                 input_schema: skill.input_schema || defaultSchema,
                 related_tools: skill.related_tools,
+                category: this.name,
             };
         });
     }

package/src/ToolCollection.ts

@@ -6,8 +6,9 @@ import { HTTPException } from "hono/http-exception";
 import { authorize } from "./auth.js";
 import { ToolFilterOptions, ToolRegistry } from "./ToolRegistry.js";
 import { ToolContext } from "./server/types.js";
-import type { CollectionProperties, ICollection, Tool, ToolDefinitionWithDefault, ToolExecutionPayload, ToolExecutionResponse, ToolExecutionResponseError } from "./types.js";
+import type { CollectionProperties, ICollection, Tool, ToolExecutionPayload, ToolExecutionResponse, ToolExecutionResponseError } from "./types.js";
 import { kebabCaseToTitle } from "./utils.js";
+import { AgentToolDefinition } from "@vertesia/common";
 
 export interface ToolCollectionProperties extends CollectionProperties {
     /**
@@ -52,7 +53,8 @@ export class ToolCollection implements ICollection<Tool<any>> {
         this.title = title || kebabCaseToTitle(name);
         this.icon = icon;
         this.description = description;
-        this.tools = new ToolRegistry(tools);
+        // we add the collection name info
+        this.tools = new ToolRegistry(name, tools);
     }
 
     [Symbol.iterator](): Iterator<Tool<any>> {
@@ -126,7 +128,7 @@ export class ToolCollection implements ICollection<Tool<any>> {
      * @param options - Filtering options for default/unlocked tools
      * @returns Filtered tool definitions
      */
-    getToolDefinitions(options?: ToolFilterOptions): ToolDefinitionWithDefault[] {
+    getToolDefinitions(options?: ToolFilterOptions): AgentToolDefinition[] {
         return this.tools.getDefinitions(options);
     }
 
@@ -135,7 +137,7 @@ export class ToolCollection implements ICollection<Tool<any>> {
      * @param unlockedTools - List of tool names that are unlocked
      * @returns Tool definitions for reserve tools
      */
-    getReserveTools(unlockedTools: string[] = []): ToolDefinitionWithDefault[] {
+    getReserveTools(unlockedTools: string[] = []): AgentToolDefinition[] {
         return this.tools.getReserveTools(unlockedTools);
     }
 

package/src/ToolRegistry.ts

@@ -1,5 +1,6 @@
+import { AgentToolDefinition } from "@vertesia/common";
 import { HTTPException } from "hono/http-exception";
-import { Tool, ToolDefinitionWithDefault, ToolExecutionContext, ToolExecutionPayload, ToolExecutionResult } from "./types.js";
+import { Tool, ToolExecutionContext, ToolExecutionPayload, ToolExecutionResult } from "./types.js";
 
 /**
  * Options for filtering tool definitions
@@ -19,9 +20,12 @@ export interface ToolFilterOptions {
 
 export class ToolRegistry {
 
+    // The category name usinfg this registry
+    category: string;
     registry: Record<string, Tool<any>> = {};
 
-    constructor(tools: Tool<any>[] = []) {
+    constructor(category: string, tools: Tool<any>[] = []) {
+        this.category = category;
         for (const tool of tools) {
             this.registry[tool.name] = tool;
         }
@@ -32,7 +36,7 @@ export class ToolRegistry {
      * @param options - Filtering options
      * @returns Filtered tool definitions
      */
-    getDefinitions(options?: ToolFilterOptions): ToolDefinitionWithDefault[] {
+    getDefinitions(options?: ToolFilterOptions): AgentToolDefinition[] {
         const { defaultOnly, unlockedTools = [] } = options || {};
         const unlockedSet = new Set(unlockedTools);
 
@@ -50,6 +54,7 @@ export class ToolRegistry {
                 name: tool.name,
                 description: tool.description,
                 input_schema: tool.input_schema,
+                category: this.category,
                 default: tool.default,
             }));
     }
@@ -59,7 +64,7 @@ export class ToolRegistry {
      * @param unlockedTools - List of tool names that are unlocked
      * @returns Tool definitions for reserve tools
      */
-    getReserveTools(unlockedTools: string[] = []): ToolDefinitionWithDefault[] {
+    getReserveTools(unlockedTools: string[] = []): AgentToolDefinition[] {
         const unlockedSet = new Set(unlockedTools);
 
         return Object.values(this.registry)
@@ -68,6 +73,7 @@ export class ToolRegistry {
                 name: tool.name,
                 description: tool.description,
                 input_schema: tool.input_schema,
+                category: this.category,
                 default: tool.default,
             }));
     }

package/src/index.ts

@@ -1,4 +1,5 @@
 export { authorize, AuthSession } from "./auth.js";
+export * from "./ContentTypesCollection.js";
 export { copyRuntimeAssets } from "./copy-assets.js";
 export * from "./InteractionCollection.js";
 export * from "./server.js";

package/src/server/app-package.ts

@@ -0,0 +1,102 @@
+import { AppPackage, AppPackageScope, CatalogInteractionRef, InCodeTypeDefinition } from "@vertesia/common";
+import { Context, Hono } from "hono";
+import { ToolServerConfig } from "./types.js";
+
+
+const builders: Record<Exclude<AppPackageScope, 'all'>, (pkg: AppPackage, config: ToolServerConfig, c: Context) => void> = {
+    tools(pkg: AppPackage, config: ToolServerConfig) {
+        const { tools: toolCollections = [], skills: skillCollections = [] } = config;
+
+        // Aggregate all tools from all collections
+        const allTools = toolCollections.flatMap(collection =>
+            collection.getToolDefinitions()
+        );
+
+        // same for skills
+        const allSkills = skillCollections.flatMap(collection =>
+            collection.getToolDefinitions()
+        );
+
+        pkg.tools = allSkills.concat(allTools);
+    },
+    interactions(pkg: AppPackage, config: ToolServerConfig) {
+        const allInteractions: CatalogInteractionRef[] = [];
+        for (const coll of (config.interactions || [])) {
+            for (const inter of coll.interactions) {
+                allInteractions.push({
+                    type: "app",
+                    id: coll.name + ":" + inter.name,
+                    name: inter.name,
+                    title: inter.title || inter.name,
+                    description: inter.description,
+                    tags: inter.tags || [],
+                });
+            }
+        }
+        pkg.interactions = allInteractions;
+    },
+    types(pkg: AppPackage, config: ToolServerConfig) {
+        const allTypes: InCodeTypeDefinition[] = [];
+        for (const coll of config.types || []) {
+            for (const type of coll.types) {
+                allTypes.push(type);
+            }
+        }
+        pkg.types = allTypes;
+    },
+    ui(pkg: AppPackage, config: ToolServerConfig, c: Context) {
+        if (config.uiConfig) {
+            pkg.ui = { ...config.uiConfig };
+            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";
+            }
+        }
+    },
+    settings(pkg: AppPackage, config: ToolServerConfig) {
+        if (config.settings) {
+            pkg.settings_schema = { ...config.settings };
+        }
+    },
+}
+
+
+export function createPackageRoute(app: Hono, basePath: string, config: ToolServerConfig) {
+    const { interactions = [], tools: toolCollections = [], mcpProviders = [] } = config;
+
+    app.get(basePath, (c: Context) => {
+        const scope = c.req.query('scope') || 'all';
+        const pkg: AppPackage = {};
+        interactions; toolCollections; mcpProviders;
+
+        const scopes = new Set<AppPackageScope>(scope.split(',') as AppPackageScope[]);
+        // TODO build pkg based on the query param scope
+        if (scopes.has('all')) {
+            builders.tools(pkg, config, c);
+            builders.interactions(pkg, config, c);
+            builders.types(pkg, config, c);
+            builders.ui(pkg, config, c);
+            builders.settings(pkg, config, c);
+        } else {
+            if (scopes.has('tools')) {
+                builders.tools(pkg, config, c);
+            }
+            if (scopes.has('interactions')) {
+                builders.interactions(pkg, config, c);
+            }
+            if (scopes.has('types')) {
+                builders.types(pkg, config, c);
+            }
+            if (scopes.has('ui')) {
+                builders.ui(pkg, config, c);
+            }
+            if (scopes.has('settings')) {
+                builders.settings(pkg, config, c);
+            }
+        }
+
+        return c.json(pkg);
+    });
+}
+

package/src/server/conyent-types.ts

@@ -0,0 +1,71 @@
+// ================== Content Type Endpoints ==================
+
+import { InCodeTypeDefinition } from "@vertesia/common";
+import { Context, Hono } from "hono";
+import { ContentTypesCollection } from "../ContentTypesCollection.js";
+import { ToolServerConfig } from "./types.js";
+import { HTTPException } from "hono/http-exception";
+
+export function createContentTypesRoute(app: Hono, basePath: string, config: ToolServerConfig) {
+    const { types = [] } = config;
+
+    // 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);
+            }
+        }
+
+        return c.json({
+            title: 'All Content Types',
+            description: 'All available content types across all collections',
+            types: allTypes,
+            collections: types.map(i => ({
+                name: i.name,
+                title: i.title,
+                description: i.description,
+            })),
+        });
+    });
+
+    // Create interaction collection endpoints
+    for (const coll of types) {
+        app.route(`${basePath}/${coll.name}`, createContentTypeEndpoints(coll));
+    }
+
+    // GET /api/types/:name - Direct access to content type
+    app.get(`${basePath}/:name`, async (c) => {
+        const name = c.req.param('name');
+
+        // Search across all collections for the interaction
+        for (const coll of types) {
+            const inter = coll.getTypeByName(name);
+            if (inter) {
+                return c.json(inter);
+            }
+        }
+
+        throw new HTTPException(404, {
+            message: "No interaction found with name: " + name
+        });
+    });
+
+}
+
+
+
+
+function createContentTypeEndpoints(coll: ContentTypesCollection): Hono {
+    const endpoint = new Hono();
+
+    endpoint.get('/', (c: Context) => {
+        return c.json(coll.types);
+    });
+
+
+
+    return endpoint;
+}

package/src/server/interactions.ts

@@ -18,7 +18,7 @@ export function createInteractionsRoute(app: Hono, basePath: string, config: Too
             for (const inter of coll.interactions) {
                 allInteractions.push({
                     type: "app",
-                    id: inter.name,
+                    id: coll.name + ":" + inter.name,
                     name: inter.name,
                     title: inter.title || inter.name,
                     description: inter.description,
@@ -44,6 +44,24 @@ export function createInteractionsRoute(app: Hono, basePath: string, config: Too
         app.route(`${basePath}/${coll.name}`, createInteractionEndpoints(coll));
     }
 
+    // GET /api/interactions/:name - Direct access to interaction by name (searches all collections)
+    app.get(`${basePath}/:name`, async (c) => {
+        await authorize(c);
+        const name = c.req.param('name');
+
+        // Search across all collections for the interaction
+        for (const coll of interactions) {
+            const inter = coll.getInteractionByName(name);
+            if (inter) {
+                return c.json(inter);
+            }
+        }
+
+        throw new HTTPException(404, {
+            message: "No interaction found with name: " + name
+        });
+    });
+
 }
 
 
@@ -55,7 +73,7 @@ function createInteractionEndpoints(coll: InteractionCollection): Hono {
     endpoint.get('/', (c: Context) => {
         return c.json(coll.interactions.map(inter => ({
             type: "app",
-            id: inter.name,
+            id: coll.name + ":" + inter.name,
             name: inter.name,
             title: inter.title || inter.name,
             description: inter.description,
@@ -72,7 +90,10 @@ function createInteractionEndpoints(coll: InteractionCollection): Hono {
                 message: "No interaction found with name: " + name
             });
         }
-        return c.json(inter);
+        return c.json({
+            ...inter,
+            id: coll.name + ":" + inter.name,
+        });
     });
 
     return endpoint;

package/src/server/site.ts

@@ -1,5 +1,6 @@
 import { Hono } from "hono";
 import {
+    contentTypeCollectionPage,
     indexPage,
     interactionCollectionPage,
     skillCollectionPage,
@@ -12,6 +13,7 @@ export function createSiteRoute(app: Hono, basePath: string, config: ToolServerC
     const {
         tools = [],
         interactions = [],
+        types = [],
         skills = [],
     } = config;
 
@@ -41,4 +43,11 @@ export function createSiteRoute(app: Hono, basePath: string, config: ToolServerC
         });
     }
 
+    // Content type collection pages
+    for (const coll of types) {
+        app.get(`${basePath}/types/${coll.name}`, (c) => {
+            return c.html(contentTypeCollectionPage(coll));
+        });
+    }
+
 }

package/src/server/types.ts

@@ -3,6 +3,9 @@ import { InteractionCollection } from "../InteractionCollection.js";
 import { SkillCollection } from "../SkillCollection.js";
 import { ToolCollection } from "../ToolCollection.js";
 import { ToolExecutionPayload } from "../types.js";
+import { JSONSchema } from "@llumiverse/common";
+import { AppUIConfig } from "@vertesia/common";
+import { ContentTypesCollection } from "../ContentTypesCollection.js";
 
 /**
  * Extended context with parsed payload for tool/skill execution
@@ -49,6 +52,10 @@ export interface ToolServerConfig {
      * Interaction collections to expose
      */
     interactions?: InteractionCollection[];
+    /**
+     * Content type collections to expose
+     */
+    types?: ContentTypesCollection[];
     /**
      * Skill collections to expose
      */
@@ -57,6 +64,17 @@ export interface ToolServerConfig {
      * MCP providers to expose
      */
     mcpProviders?: MCPProviderConfig[];
+
+    /**
+     * A JSON schema defining settings for the application using this server
+     */
+    settings?: JSONSchema;
+
+    /**
+     * The UI configuration for the application using this server
+     */
+    uiConfig?: AppUIConfig;
+
     /**
      * Disable HTML pages (default: false)
      */

package/src/server.ts

@@ -10,6 +10,8 @@ import { createToolsRoute } from "./server/tools.js";
 import { ToolContext, ToolServerConfig } from "./server/types.js";
 import { ToolExecutionPayload } from "./types.js";
 import { createWidgetsRoute } from "./server/widgets.js";
+import { createPackageRoute } from "./server/app-package.js";
+import { createContentTypesRoute } from "./server/conyent-types.js";
 
 // Schema for tool execution payload
 const ToolExecutionPayloadSchema = z.object({
@@ -98,10 +100,13 @@ export function createToolServer(config: ToolServerConfig): Hono {
         });
     });
 
+
+    createPackageRoute(app, `${prefix}/package`, config);
     createToolsRoute(app, `${prefix}/tools`, config);
     createSkillsRoute(app, `${prefix}/skills`, config);
     createWidgetsRoute(app, `${prefix}/widgets`, config);
     createInteractionsRoute(app, `${prefix}/interactions`, config);
+    createContentTypesRoute(app, `${prefix}/types`, config);
     createMcpRoute(app, `${prefix}/mcp`, config);