@anteros/core 0.0.41 → 0.0.44

package/server/boot.ts

@@ -14,6 +14,7 @@ import { syncFileCollections } from '../database/file'
 import { syncVars } from '../database/vars'
 import { startReplication, stopReplication } from '../database/replication'
 import { loadLifecycles, runBeforeBoot, runAfterBoot, runOnDestroy } from '../lib/lifecycle'
+import { workflowStats } from '../lib/workflow'
 
 import { loadRoutes } from '../lib/routes'
 import { runScripts } from '../lib/scripts'
@@ -22,6 +23,7 @@ import { loadServices } from '../lib/services'
 import { loadSockets } from '../lib/sockets'
 import { syncWorkflows } from '../lib/workflow'
 import { syncMcpTools } from '../lib/mcp'
+import { syncAgents, agentsStats } from '../lib/agents'
 import { loadTenantsMiddlewares } from '../lib/middleware'
 import crypto from 'node:crypto';
 import os from 'node:os';
@@ -87,6 +89,14 @@ function renderBanner(opts: {
     }
     box += `Replication: ${replicationInfo}`.gray.bold + '\n'
 
+    // Workflows loaded from `{tenant.dir}/workflows/**/*.workflow.ts`
+    const wf = workflowStats();
+    box += `Workflows: ${wf.total ? `${wf.total}`.green.bold + ` (${wf.tenants.join(', ')})`.gray : 'none'.gray}\n`.gray.bold
+
+    // Agents loaded from `{tenant.dir}/agents/**/*.agent.ts`
+    const ag = agentsStats();
+    box += `Agents: ${ag.total ? `${ag.total}`.green.bold + ` (${ag.tenants.join(', ')})`.gray : 'none'.gray}\n`.gray.bold
+
     // Only shown when something is disabled — the default banner stays compact
     if (off.length) {
         box += `Mode: ${capabilitiesLabel(caps)}`.gray.bold + ` (${off.join(', ')} off)`.yellow + '\n';
@@ -144,6 +154,7 @@ async function bootApp(options: BootAppOptions = {} as BootAppOptions) {
             if (caps.sockets) await loadSockets(); // load websocket handlers
             await syncWorkflows();
             await syncMcpTools(); // load MCP tools per tenant (mcp/**/*.tool.ts)
+            await syncAgents(); // load agents per tenant (agents/**/*.agent.ts)
             await loadTenantsMiddlewares();
             await loadRoutes(); // load routes
         }

package/server/hono.ts

@@ -11,8 +11,10 @@ import { Redis } from "ioredis"
 import { cfg } from "./config"
 import { rateLimit, createRedisStore, createMemoryStore, type RateLimitStore } from "./security"
 import { initializeRoutes } from "./routes";
+import { patterns } from "../lib/endpoints";
 import { asyncContextStorage, requestCtxStorage } from "../lib/asyncContextStorage";
 import { initializeApi } from "./api";
+import { initializeAgents } from "./agents";
 import { initializeMcp } from "./mcp";
 import { getGlobalMiddlewares } from "../lib/middleware";
 import { jwt } from "../utils/func";
@@ -326,8 +328,8 @@ function createApp(): Hono<{ Variables: HonoVariables }> {
             keyGenerator: keyByClientIp(''),
         }));
 
-        // stricter limit for login endpoints
-        app.use('/api/*/login', rateLimit({
+        // stricter limit for login endpoints — the login is a collection action
+        app.use(patterns.login, rateLimit({
             windowMs: cfg.server.rateLimit?.login?.windowMs ?? 60_000,
             max: cfg.server.rateLimit?.login?.max ?? 10,
             store,
@@ -399,7 +401,10 @@ function createApp(): Hono<{ Variables: HonoVariables }> {
     // initialize api
     initializeApi(app);
 
-    // initialize MCP (tools served at /mcp/:tenant_id)
+    // initialize the agents API (/api/:tenant_id/agents/:agent/:action)
+    initializeAgents(app);
+
+    // initialize MCP (tools served at /api/:tenant_id/mcp)
     initializeMcp(app);
 
 

package/server/mcp.ts

@@ -10,72 +10,18 @@ import {
     ErrorCode,
 } from "@modelcontextprotocol/sdk/types.js";
 import { StreamableHTTPTransport } from "@hono/mcp";
-import type Joi from "joi";
 import { cfg } from "./config";
 import { useRest } from "../database/rest";
+import { createAgents } from "../lib/agents";
+import { createApi } from "../lib/api";
 import { logger } from "../utils/logger";
 import type { McpTool, McpResource } from "../types/mcp";
 import type { HonoVariables } from "./env";
+import { joiToJsonSchema } from "../lib/jsonSchema";
+import { patterns } from "../lib/endpoints";
 
-// ─── Joi → JSON Schema (for the MCP protocol) ────────────────────────────
-
-function joiTypeToJson(type: string): string {
-    switch (type) {
-        case 'number': return 'number';
-        case 'integer': return 'integer';
-        case 'boolean': return 'boolean';
-        case 'date': return 'string';
-        default: return 'string';
-    }
-}
-
-/** Minimal Joi → JSON Schema converter (covers the common field types). */
-function joiToJsonSchema(schema: Joi.Schema, describe = schema.describe() as any): any {
-    const node: any = {};
-    const type = describe?.type;
-
-    switch (type) {
-        case 'object': {
-            node.type = 'object';
-            const properties: Record<string, any> = {};
-            const required: string[] = [];
-            for (const [key, child] of Object.entries(describe.keys ?? {})) {
-                properties[key] = joiToJsonSchema(child as any, child);
-                if ((child as any)?.flags?.presence === 'required') required.push(key);
-            }
-            node.properties = properties;
-            if (required.length) node.required = required;
-            break;
-        }
-        case 'array': {
-            node.type = 'array';
-            if (describe.items?.length) node.items = joiToJsonSchema(describe.items[0], describe.items[0]);
-            break;
-        }
-        default: {
-            node.type = joiTypeToJson(type);
-            if (type === 'date') node.format = 'date-time';
-            if (type === 'string') {
-                for (const rule of describe.rules ?? []) {
-                    if (['email', 'uri', 'uuid', 'isoDate', 'ip'].includes(rule.name)) {
-                        node.format = rule.name;
-                    }
-                    if (rule.name === 'pattern' && rule.args?.regex) {
-                        node.pattern = String(rule.args.regex).replace(/^\/|\/[gimsuy]*$/g, '');
-                    }
-                }
-            }
-            if (describe.valids?.length && describe.valids.length <= 50) {
-                node.enum = describe.valids;
-            }
-            break;
-        }
-    }
-
-    if (describe?.flags?.presence === 'required') node.description = node.description ?? 'required';
-    if (describe?.flags?.description) node.description = describe.flags.description;
-    return node;
-}
+// The Joi → JSON Schema converter is shared with the agent runtime — a tool
+// must look identical whether it is exposed over MCP or to a model.
 
 // ─── URI template matching (users://{id} → params) ───────────────────────
 
@@ -148,7 +94,13 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
 
         const rest = new useRest({ tenant_id: tenantId });
         try {
-            const result = await tool.exec({ c: undefined as any, rest, args: value });
+            const result = await tool.exec({
+                c: undefined as any,
+                rest,
+                args: value,
+                agents: createAgents(tenantId, rest),
+                api: createApi(rest),
+            });
             const isError = !!(result as any)?.isError;
             logger[isError ? 'warn' : 'info']('MCP tools/call', { method: 'tools/call', tenant: tenantId, tool: req.params.name, args: value, isError, duration: ms(start) });
             if (result && Array.isArray(result.content)) return result;
@@ -205,6 +157,8 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
             const result = await matched.resource.read({
                 c: undefined as any,
                 rest,
+                agents: createAgents(tenantId, rest),
+                api: createApi(rest),
                 params: matched.params,
                 uri,
             });
@@ -221,7 +175,7 @@ function buildServer(tenantId: string, tools: McpTool[], resources: McpResource[
 
 /**
  * Expose each tenant's MCP tools & resources over the Model Context Protocol
- * at `GET/POST /mcp/:tenant_id` (Streamable HTTP transport — works with
+ * at `GET/POST /api/:tenant_id/mcp` (Streamable HTTP transport — works with
  * Claude, Cursor, VS Code, and any MCP client).
  */
 export function initializeMcp(app: Hono<{ Variables: HonoVariables }>) {
@@ -238,7 +192,7 @@ export function initializeMcp(app: Hono<{ Variables: HonoVariables }>) {
         resourcesByTenant.set(resource._tenant_ ?? '', list);
     }
 
-    app.all('/mcp/:tenant_id', async (c: Context<{ Variables: HonoVariables }>) => {
+    app.all(patterns.mcp, async (c: Context<{ Variables: HonoVariables }>) => {
         const tenantId = c.req.param('tenant_id') ?? '';
         const tools = toolsByTenant.get(tenantId) ?? [];
         const resources = resourcesByTenant.get(tenantId) ?? [];

package/server/routes.ts

@@ -3,10 +3,26 @@ import { cfg } from "./config";
 import path from "path";
 import { jwt } from "../utils/func";
 import { useRest } from "../database/rest";
+import { createAgents } from "../lib/agents";
+import { createApi } from "../lib/api";
 import { io } from "./io";
 import { requestCtxStorage } from "../lib/asyncContextStorage";
 import type { HonoVariables } from "./env";
 
+/** The context of a route handler — `rest` and `agents` share the same tenant. */
+function routeContext(c: any, tenantId: string) {
+    const rest = new useRest({ tenant_id: tenantId });
+    return {
+        c,
+        rest,
+        // Tenant-scoped LLM registry, bound to this request's `rest`
+        agents: createAgents(tenantId, rest),
+        api: createApi(rest),
+        jwt: jwt,
+        io: io,
+    };
+}
+
 function initializeRoutes(app: Hono<{ Variables: HonoVariables }>) {
     for (let route of cfg.routes ?? []) {
         if (route._prefix_) {
@@ -24,42 +40,21 @@ function initializeRoutes(app: Hono<{ Variables: HonoVariables }>) {
             if (route.method == "GET") {
                 app.get(routePath, async (c) => { //
                     resolveTenant();
-                    return route.handler({
-                        c,
-                        rest: new useRest({
-                            tenant_id: route._tenant_,
-                        }),
-                        jwt: jwt,
-                        io: io,
-                    });
+                    return route.handler(routeContext(c, route._tenant_!));
                 });
             }
 
             if (route.method == 'POST') {
                 app.post(routePath, async (c) => {
                     resolveTenant();
-                    return route.handler({
-                        c,
-                        rest: new useRest({
-                            tenant_id: route._tenant_,
-                        }),
-                        jwt: jwt,
-                        io: io,
-                    });
+                    return route.handler(routeContext(c, route._tenant_!));
                 });
             }
 
             if (route.method == "PUT") {
                 app.put(routePath, async (c) => { //
                     resolveTenant();
-                    return route.handler({
-                        c,
-                        rest: new useRest({
-                            tenant_id: route._tenant_,
-                        }),
-                        jwt: jwt,
-                        io: io,
-                    });
+                    return route.handler(routeContext(c, route._tenant_!));
                 });
             }
         }

package/tests/agent-mcp.test.ts

@@ -0,0 +1,116 @@
+/**
+ * The MCP **client** — an agent consuming a remote server's tools.
+ *
+ * The endpoint under test is the framework's own (`/api/:tenant/mcp`, served by
+ * `@hono/mcp`): the SDK client and our server are two independent implementations of
+ * the protocol, which is exactly what makes the round trip worth testing end to end —
+ * list, call, and back into the conversation as if the tool were local.
+ */
+import { describe, it, expect, beforeAll, afterAll } from "bun:test";
+import { Agent, define, v } from "../index";
+import { cfg, formatConfig } from "../server/config";
+import { syncTenants } from "../database/tenant";
+import { syncMcpTools } from "../lib/mcp";
+import { closeMcpClients } from "../lib/mcpClient";
+import { createApp } from "../server/hono";
+import { at, fakeProvider, openaiText, openaiTool, request, type Fake } from "./fixtures/fake-provider";
+
+const TENANT = "mcp-client";
+const DIR = "packages/core/tests/fixtures/mcp-tenant";
+
+let server: any;
+let mcpUrl: string;
+const servers: Fake[] = [];
+
+const track = (fake: Fake): Fake => (servers.push(fake), fake);
+
+beforeAll(async () => {
+    formatConfig({
+        server: { port: 4000 },
+        tenants: [{ id: TENANT, dir: DIR, database: { uri: "mongodb://localhost:27017/none" } }],
+    });
+    await syncTenants();
+    await syncMcpTools();
+
+    server = Bun.serve({ port: 0, fetch: createApp().fetch });
+    mcpUrl = `${server.url.href.replace(/\/$/, "")}/api/${TENANT}/mcp`;
+});
+
+afterAll(async () => {
+    for (const fake of servers) fake.stop();
+    await closeMcpClients();
+    try { server?.stop(true); } catch (_) {}
+    cfg.agents = [];
+});
+
+function makeAgent(provider: Fake, overrides: Record<string, any> = {}) {
+    return new Agent({
+        id: "test",
+        description: "A test agent.",
+        instructions: "You are a test agent.",
+        provider: { model: "test-model", apiKey: "test-key", baseUrl: provider.url, options: { retries: 0 } },
+        mcp: [mcpUrl],
+        ...overrides,
+    } as any);
+}
+
+describe("agent mcp — a remote server's tools", () => {
+    it("lists them as tools, calls one, and feeds the result back", async () => {
+        const provider = track(fakeProvider((_body, _req, hits) =>
+            hits === 1 ? openaiTool("echo", { msg: "hello mcp", times: 1 }) : openaiText("done")));
+        const agent = makeAgent(provider);
+
+        const result = await agent.generate("echo something");
+
+        // The remote tools are offered like any other
+        const names = request(provider, 0).body.tools.map((tool: any) => tool.function.name);
+        expect(names).toContain("echo");
+        expect(names).toContain("badge");
+
+        // …and the call really crossed the wire: the answer is the server's
+        const entry = at(result.toolResults, 0);
+        expect(entry.error).toBeUndefined();
+        expect(entry.result.content[0].text).toContain("hello mcp");
+        // What the model saw is the flattened text, not the protocol envelope
+        const toolMessage = result.messages.find((message) => message.role === "tool");
+        expect(toolMessage?.content).toContain("hello mcp");
+        expect(result.text).toBe("done");
+    });
+
+    it("lets a declared tool win over a remote one of the same name", async () => {
+        const provider = track(fakeProvider(() => openaiText("done")));
+        const local = define.Tool({
+            id: "echo",
+            description: "The tenant's own echo.",
+            inputSchema: v.object({}),
+            execute: async () => "local",
+        });
+        const agent = makeAgent(provider, { tools: { echo: local } });
+
+        await agent.generate("hi");
+
+        const offered = request(provider, 0).body.tools.filter((tool: any) => tool.function.name === "echo");
+        expect(offered).toHaveLength(1);
+        expect(offered[0].function.description).toBe("The tenant's own echo.");
+    });
+
+    it("contacts nothing with `tools: false`", async () => {
+        const provider = track(fakeProvider(() => openaiText("direct")));
+        const agent = makeAgent(provider);
+
+        await agent.generate("hi", { tools: false });
+
+        expect(request(provider, 0).body.tools).toBeUndefined();
+    });
+
+    it("runs anyway when the server is unreachable", async () => {
+        const provider = track(fakeProvider(() => openaiText("still here")));
+        const agent = makeAgent(provider, { mcp: ["http://127.0.0.1:9/mcp"] });
+
+        const result = await agent.generate("hi");
+
+        // A remote that is down costs its tools, not the run
+        expect(result.text).toBe("still here");
+        expect(request(provider, 0).body.tools).toBeUndefined();
+    }, 20_000);
+});