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

package/src/auth.ts

@@ -35,7 +35,19 @@ export async function verifyToken(token: string) {
 }
 
 
-export async function authorize(ctx: Context) {
+export interface EndpointOverrides {
+    studio?: string;
+    store?: string;
+    token?: string;
+}
+
+export interface ToolContext {
+    toolName?: string;
+    toolUseId?: string;
+    runId?: string;
+}
+
+export async function authorize(ctx: Context, endpointOverrides?: EndpointOverrides, toolContext?: ToolContext) {
     const auth = ctx.req.header('Authorization');
     if (!auth) {
         throw new HTTPException(401, {
@@ -55,7 +67,7 @@ export async function authorize(ctx: Context) {
     }
     try {
         const { payload } = await verifyToken(value);
-        const session = new AuthSession(value, payload);
+        const session = new AuthSession(value, payload, endpointOverrides, toolContext);
         ctx.set("auth", session);
         return session;
     } catch (err: any) {
@@ -71,17 +83,36 @@ export class AuthSession implements ToolExecutionContext {
     endpoints: {
         studio: string;
         store: string;
+        token: string;
     };
+    toolContext?: ToolContext;
 
-    constructor(public token: string, public payload: AuthTokenPayload) {
-        this.endpoints = decodeEndpoints(payload.endpoints) as {
-            studio: string, store: string
+    constructor(
+        public token: string,
+        public payload: AuthTokenPayload,
+        endpointOverrides?: EndpointOverrides,
+        toolContext?: ToolContext
+    ) {
+        const decoded = decodeEndpoints(payload.endpoints);
+        // Use overrides from workflow config if provided, falling back to JWT endpoints
+        this.endpoints = {
+            studio: endpointOverrides?.studio || decoded.studio,
+            store: endpointOverrides?.store || decoded.store,
+            token: endpointOverrides?.token || decoded.token || payload.iss,
         };
+        this.toolContext = toolContext;
     }
 
     async getClient() {
         if (!this._client) {
-            this._client = await VertesiaClient.fromAuthToken(this.token, this.payload);
+            const toolInfo = this.toolContext?.toolName ? ` for ${this.toolContext.toolName}` : '';
+            console.log(`[VertesiaClient] Initializing client${toolInfo}`, {
+                tool: this.toolContext?.toolName,
+                toolUseId: this.toolContext?.toolUseId,
+                runId: this.toolContext?.runId,
+                endpoints: this.endpoints,
+            });
+            this._client = await VertesiaClient.fromAuthToken(this.token, this.payload, this.endpoints);
         }
         return this._client;
     }

package/src/index.ts

@@ -1,9 +1,13 @@
 export { authorize, AuthSession } from "./auth.js";
+export * from "./ContentTypesCollection.js";
+export { copyRuntimeAssets } from "./copy-assets.js";
 export * from "./InteractionCollection.js";
+export * from "./server.js";
+export * from "./server/types.js";
+export * from "./site/templates.js";
 export * from "./SkillCollection.js";
 export * from "./ToolCollection.js";
 export * from "./ToolRegistry.js";
 export * from "./types.js";
-export * from "./server.js";
-export * from "./site/templates.js";
-export { copyRuntimeAssets } from "./copy-assets.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

@@ -0,0 +1,100 @@
+// ================== Interaction Endpoints ==================
+
+import { CatalogInteractionRef } from "@vertesia/common";
+import { Context, Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { authorize } from "../auth.js";
+import { InteractionCollection } from "../InteractionCollection.js";
+import { ToolServerConfig } from "./types.js";
+
+export function createInteractionsRoute(app: Hono, basePath: string, config: ToolServerConfig) {
+    const { interactions = [] } = config;
+
+    // GET /api/interactions - Returns all interactions from all collections
+    app.get(basePath, (c) => {
+        const allInteractions: CatalogInteractionRef[] = [];
+
+        for (const coll of 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 || [],
+                });
+            }
+        }
+
+        return c.json({
+            title: 'All Interactions',
+            description: 'All available interactions across all collections',
+            interactions: allInteractions,
+            collections: interactions.map(i => ({
+                name: i.name,
+                title: i.title,
+                description: i.description,
+            })),
+        });
+    });
+
+    // Create interaction collection endpoints
+    for (const coll of interactions) {
+        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
+        });
+    });
+
+}
+
+
+
+
+function createInteractionEndpoints(coll: InteractionCollection): Hono {
+    const endpoint = new Hono();
+
+    endpoint.get('/', (c: Context) => {
+        return c.json(coll.interactions.map(inter => ({
+            type: "app",
+            id: coll.name + ":" + inter.name,
+            name: inter.name,
+            title: inter.title || inter.name,
+            description: inter.description,
+            tags: inter.tags || [],
+        } satisfies CatalogInteractionRef)));
+    });
+
+    endpoint.get('/:name', async (c: Context) => {
+        await authorize(c);
+        const name = c.req.param('name');
+        const inter = coll.getInteractionByName(name);
+        if (!inter) {
+            throw new HTTPException(404, {
+                message: "No interaction found with name: " + name
+            });
+        }
+        return c.json({
+            ...inter,
+            id: coll.name + ":" + inter.name,
+        });
+    });
+
+    return endpoint;
+}

package/src/server/mcp.ts

@@ -0,0 +1,51 @@
+// ================== MCP Endpoints ==================
+
+import { Context, Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { authorize } from "../auth.js";
+import { ToolServerConfig } from "../index.js";
+import { MCPProviderConfig } from "./types.js";
+
+
+
+export function createMcpRoute(app: Hono, basePath: string, config: ToolServerConfig) {
+    const { mcpProviders = [] } = config;
+    // Create MCP provider endpoints
+    if (mcpProviders.length > 0) {
+        app.route(basePath, createMCPEndpoints(mcpProviders));
+    }
+
+}
+
+function createMCPEndpoints(providers: MCPProviderConfig[]): Hono {
+    const endpoint = new Hono();
+
+    for (const p of providers) {
+        endpoint.post(`/${p.name}`, async (c: Context) => {
+            const session = await authorize(c);
+            const config = await readJsonBody(c);
+            const info = await p.createMCPConnection(session, config);
+            return c.json(info);
+        });
+
+        endpoint.get(`/${p.name}`, (c: Context) => c.json({
+            name: p.name,
+            description: p.description,
+        }));
+    }
+
+    return endpoint;
+}
+
+async function readJsonBody(ctx: Context): Promise<Record<string, any>> {
+    try {
+        const text = await ctx.req.text();
+        const jsonContent = text?.trim() || '';
+        if (!jsonContent) return {};
+        return JSON.parse(jsonContent) as Record<string, any>;
+    } catch (err: any) {
+        throw new HTTPException(400, {
+            message: "Failed to parse JSON body: " + err.message
+        });
+    }
+}

package/src/server/site.ts

@@ -0,0 +1,53 @@
+import { Hono } from "hono";
+import {
+    contentTypeCollectionPage,
+    indexPage,
+    interactionCollectionPage,
+    skillCollectionPage,
+    toolCollectionPage
+} from "../site/templates.js";
+import { ToolServerConfig } from "./types.js";
+
+
+export function createSiteRoute(app: Hono, basePath: string, config: ToolServerConfig) {
+    const {
+        tools = [],
+        interactions = [],
+        types = [],
+        skills = [],
+    } = config;
+
+    // Index page
+    app.get(`${basePath}/`, (c) => {
+        return c.html(indexPage(config));
+    });
+
+    // Tool collection pages
+    for (const coll of tools) {
+        app.get(`${basePath}/tools/${coll.name}`, (c) => {
+            return c.html(toolCollectionPage(coll));
+        });
+    }
+
+    // Skill collection pages
+    for (const coll of skills) {
+        app.get(`${basePath}/skills/${coll.name}`, (c) => {
+            return c.html(skillCollectionPage(coll));
+        });
+    }
+
+    // Interaction collection pages
+    for (const coll of interactions) {
+        app.get(`${basePath}/interactions/${coll.name}`, (c) => {
+            return c.html(interactionCollectionPage(coll));
+        });
+    }
+
+    // Content type collection pages
+    for (const coll of types) {
+        app.get(`${basePath}/types/${coll.name}`, (c) => {
+            return c.html(contentTypeCollectionPage(coll));
+        });
+    }
+
+}

package/src/server/skills.ts

@@ -0,0 +1,133 @@
+// ================== Skill Endpoints ==================
+
+import { Context, Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { SkillCollection } from "../SkillCollection.js";
+import { SkillDefinition, ToolCollectionDefinition, ToolDefinition } from "../types.js";
+import { makeScriptUrl } from "../utils.js";
+import { ToolContext, ToolServerConfig } from "./types.js";
+
+export function createSkillsRoute(app: Hono, basePath: string, config: ToolServerConfig) {
+    const { skills = [] } = config;
+
+    // Build a map of skill name -> collection for routing
+    const skillToCollection = new Map<string, SkillCollection>();
+    for (const coll of skills) {
+        for (const skill of coll.getSkillDefinitions()) {
+            skillToCollection.set(skill.name, coll);
+            // Also map the learn_ prefixed name
+            skillToCollection.set(`learn_${skill.name}`, coll);
+        }
+    }
+
+    // GET /api/skills - Returns all skills from all collections
+    app.get(basePath, (c) => {
+        const url = new URL(c.req.url);
+        const allSkills: ToolDefinition[] = [];
+
+        for (const coll of skills) {
+            allSkills.push(...coll.getToolDefinitions());
+        }
+
+        return c.json({
+            src: `${url.origin}${url.pathname}`,
+            title: 'All Skills',
+            description: 'All available skills across all collections',
+            tools: allSkills,
+            collections: skills.map(s => ({
+                name: s.name,
+                title: s.title,
+                description: s.description,
+            })),
+        } satisfies ToolCollectionDefinition & { collections: any[] });
+    });
+
+    // POST /api/skills - Route to the correct collection based on tool_name
+    app.post(basePath, async (c) => {
+        const ctx = c as unknown as ToolContext;
+
+        // Payload is already parsed and validated by middleware
+        if (!ctx.payload) {
+            throw new HTTPException(400, {
+                message: 'Invalid or missing skill execution payload. Expected { tool_use: { id, tool_name, tool_input? }, metadata? }'
+            });
+        }
+
+        const toolName = ctx.payload.tool_use.tool_name;
+
+        // Find the collection for this skill
+        const collection = skillToCollection.get(toolName);
+        if (!collection) {
+            // Extract skill name for better error message
+            const skillName = toolName.startsWith('learn_') ? toolName.slice(6) : toolName;
+            throw new HTTPException(404, {
+                message: `Skill not found: ${skillName}. Available skills: ${Array.from(skillToCollection.keys()).filter(k => !k.startsWith('learn_')).join(', ')}`
+            });
+        }
+
+        // Delegate to the collection's execute method with pre-parsed payload
+        return collection.execute(c, ctx.payload);
+    });
+
+    // Create skill collection endpoints (exposed as tools)
+    for (const coll of skills) {
+        app.route(`${basePath}/${coll.name}`, createSkillEndpoints(coll));
+    }
+
+}
+
+function createSkillEndpoints(coll: SkillCollection): Hono {
+    const endpoint = new Hono();
+
+    // List skills as tool definitions (tool collection format)
+    // This allows skills to be used exactly like tools
+    endpoint.get('/', (c: Context) => {
+        const url = new URL(c.req.url);
+        return c.json({
+            src: `${url.origin}${url.pathname}`,
+            title: coll.title || coll.name,
+            description: coll.description || '',
+            tools: coll.getToolDefinitions()
+        } satisfies ToolCollectionDefinition);
+    });
+
+    // Get scripts for a specific skill
+    // Returns all scripts bundled with the skill
+    endpoint.get('/:name/scripts', (c: Context) => {
+        const name = c.req.param('name');
+        const skillName = name.startsWith('learn_') ? name.slice(6) : name;
+        const skill = coll.getSkill(skillName);
+        if (!skill) {
+            throw new HTTPException(404, {
+                message: `Skill not found: ${skillName}`
+            });
+        }
+        const url = new URL(c.req.url);
+        return c.json({
+            skill_name: skill.name,
+            scripts: skill.scripts ? skill.scripts.map(s => makeScriptUrl(url.origin, s)) : []
+        });
+    });
+
+
+    // Get a specific skill by name
+    endpoint.get('/:name', (c: Context) => {
+        const name = c.req.param('name');
+        // Handle both "learn_name" and "name" formats
+        const skillName = name.startsWith('learn_') ? name.slice(6) : name;
+        const skill = coll.getSkill(skillName);
+        if (!skill) {
+            throw new HTTPException(404, {
+                message: `Skill not found: ${skillName}`
+            });
+        }
+        return c.json(skill satisfies SkillDefinition);
+    });
+
+    // Execute skill (standard tool execution format)
+    endpoint.post('/', (c: Context) => {
+        return coll.execute(c);
+    });
+
+    return endpoint;
+}