@telorun/mcp-server 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# @telorun/mcp-server
+
+## 0.2.0
+
+### Minor Changes
+
+- 5288f6c: Initial release of the `mcp-server` module.
+
+  Adds five resource kinds for exposing a Model Context Protocol server from Telo
+  manifests: `Mcp.StdioServer` (stdio transport, `Telo.Service`), `Mcp.HttpEndpoint`
+  (Streamable-HTTP transport, `Telo.Mount` on `Http.Server`), and three passive
+  bundle kinds — `Mcp.Tools`, `Mcp.Resources`, `Mcp.Prompts` (`Telo.Type`). v1 ships
+  runtime dispatch for `Mcp.Tools`; `Resources` and `Prompts` are schema-only and
+  gain runtime in v2.
+
+  Bundles compose by reference: a transport's `tools:` array can reference multiple
+  bundles (entries are merged with cross-bundle duplicate detection at init), and a
+  single bundle can be referenced from both stdio and HTTP transports without
+  re-declaration. Each tool entry maps the MCP envelope (`request.{name, arguments,
+meta, session}`) to any `Telo.Invocable` handler via CEL `inputs:` / `result:` /
+  `catches:` adapters — the handler stays oblivious to MCP.

package/LICENSE

@@ -0,0 +1,17 @@
+# SUSTAINABLE USE LICENSE (Fair-code)
+
+Copyright (c) 2026 DiglyAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to use, copy, modify, and distribute the Software for any purpose—including commercial purposes—subject to the following conditions:
+
+1. ANTI-COMPETITION RESTRICTION: The Software may not be provided to third parties as a managed service, commercial SaaS (Software-as-a-Service), PaaS (Platform-as-a-Service), BaaS (Backend-as-a-Service), or similar offering where the primary value provided to the user is the functionality of the Software itself, without a separate commercial license from the copyright holder.
+
+2. PERMITTED COMMERCIAL USE: You are free to use the Software to build, host, and monetize your own commercial applications, products, and services, provided such use does not violate Clause 1.
+
+3. ATTRIBUTION: This copyright notice and license must be included in all copies or substantial portions of the Software.
+
+4. CONTRIBUTIONS: Contributions to the Software are welcome and encouraged. By contributing, you agree that your contributions may be incorporated into the Software and distributed under this license.
+
+5. DISCLAIMER: The Software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the Software or the use or other dealings in the Software.
+
+For commercial licensing, managed hosting exemptions, or enterprise inquiries, please contact DiglyAI.

package/README.md

@@ -0,0 +1,94 @@
+# MCP Server
+
+Model Context Protocol (MCP) server resource kinds for Telo: stdio + Streamable HTTP transports, composable tool/resource/prompt bundles.
+
+The module mirrors the `http-server` shape: **transport kinds**
+(`Mcp.StdioServer`, `Mcp.HttpEndpoint`) own the listener and a session model;
+**bundle kinds** (`Mcp.Tools`, `Mcp.Resources`, `Mcp.Prompts`) are passive
+declarations that compose by reference. A single bundle can be referenced by
+both stdio and HTTP transports without re-declaration.
+
+## Capabilities at a glance
+
+| Kind               | Capability     | Role                                                                    |
+| ------------------ | -------------- | ----------------------------------------------------------------------- |
+| `Mcp.StdioServer`  | `Telo.Service` | Listens on stdin/stdout (one client per process). Owns one SDK Server.  |
+| `Mcp.HttpEndpoint` | `Telo.Mount`   | Mounts on `Http.Server` at a path. Per-session SDK Server (Streamable). |
+| `Mcp.Tools`        | `Telo.Type`    | Bundle of tool entries dispatched via `tools/call`.                     |
+| `Mcp.Resources`    | `Telo.Type`    | Bundle of resource entries (schema'd in v1, runtime in v2).             |
+| `Mcp.Prompts`      | `Telo.Type`    | Bundle of prompt entries (schema'd in v1, runtime in v2).               |
+
+## Minimal stdio example
+
+```yaml
+kind: Telo.Application
+metadata: { name: my-stdio-mcp }
+targets: [Server]
+---
+kind: Telo.Import
+metadata: { name: Mcp }
+source: ../modules/mcp-server
+---
+kind: Telo.Import
+metadata: { name: JS }
+source: ../modules/javascript
+---
+kind: Mcp.StdioServer
+metadata: { name: Server }
+serverInfo: { name: my-stdio-mcp, version: 1.0.0 }
+tools: [WeatherTools]
+---
+kind: Mcp.Tools
+metadata: { name: WeatherTools }
+entries:
+  - name: get_weather
+    description: Get current weather for a city.
+    argumentsSchema:
+      type: object
+      properties:
+        city: { type: string }
+      required: [city]
+    handler:
+      kind: JS.Script
+      name: GetWeatherImpl
+    inputs:
+      city: "${{ request.arguments.city }}"
+    result:
+      content:
+        - type: text
+          text: "${{ result.summary }}"
+```
+
+## Tool entries
+
+Each `Mcp.Tools.entries[]` row declares everything MCP advertises plus the
+glue that bridges between MCP envelopes and your handler's domain types:
+
+| Field             | Purpose                                                                                    |
+| ----------------- | ------------------------------------------------------------------------------------------ |
+| `name`            | Tool identifier sent in `tools/call`.                                                      |
+| `description`     | Human-readable summary surfaced to MCP clients.                                            |
+| `argumentsSchema` | JSON Schema validated by the MCP SDK on every call.                                        |
+| `handler`         | Any `Telo.Invocable` (e.g. `JS.Script`, `Run.Sequence`, `Ai.Text`).                        |
+| `inputs`          | CEL map: MCP request → handler input. Sees `request.{name,arguments,meta,session}`.        |
+| `result`          | CEL map: handler output → full MCP `CallToolResult`. Sees `result` and `request`.          |
+| `catches`         | Maps thrown `InvokeError`s into JSON-RPC error responses (distinct from `result.isError`). |
+
+`isError` on `result` signals a _soft_ tool failure where the LLM should read
+the failure as content. `catches:` is for actual `throw`s and produces a
+JSON-RPC error.
+
+## Composition
+
+- **Multiple bundles into one transport.** `tools: [WeatherTools, DatabaseTools]` merges entries from both bundles. Duplicate names across bundles throw at init.
+- **One bundle into multiple transports.** Reference the same `Mcp.Tools` from both `Mcp.StdioServer` and `Mcp.HttpEndpoint` — registrations are independent per-transport, no shared runtime state.
+
+## Out of scope for v1
+
+- `Mcp.Resources` and `Mcp.Prompts` runtime dispatch — schemas land in v1, controllers in v2.
+- Streaming tool content / progress notifications.
+- Streamable HTTP idle-session GC + max-sessions cap (sessions live until `Http.Server` shuts down).
+- Server-initiated `sampling`, `roots`, OAuth.
+- A polymorphic `Telo.Mount` dispatch protocol — `Mcp.HttpEndpoint` duck-types `register(app, prefix)` to satisfy `Http.Server`'s mount loop today.
+
+See [docs/](./docs) for per-kind reference.

package/dist/http-endpoint-controller.d.ts

@@ -0,0 +1,36 @@
+import { type ControllerContext, type ResourceContext } from "@telorun/sdk";
+import type { FastifyInstance } from "fastify";
+import { type ServerInfo } from "./registry.js";
+interface HttpEndpointManifest {
+    metadata: {
+        name: string;
+    };
+    serverInfo: ServerInfo;
+    tools?: string[];
+    resources?: string[];
+    prompts?: string[];
+}
+export declare function register(_ctx: ControllerContext): Promise<void>;
+export declare class McpHttpEndpoint {
+    private readonly resource;
+    private readonly ctx;
+    private readonly sessions;
+    private toolsBundles;
+    constructor(resource: HttpEndpointManifest, ctx: ResourceContext);
+    init(): Promise<void>;
+    /** Mount contract — duck-typed against Http.Server's mount loop. The
+     *  signature matches Http.Api.register(); see plan §3 mount contract.
+     *
+     *  Routes are declared with `app.route(...)` directly rather than via
+     *  `app.register(plugin, { prefix })`. The latter is async (the plugin
+     *  loads inside `app.ready()`); declaring the route synchronously removes
+     *  any ordering coupling with the host's `app.listen()` call. Both
+     *  `<prefix>` and `<prefix>/` are registered so trailing-slash variants
+     *  both reach the handler. */
+    register(app: FastifyInstance, prefix?: string): void;
+    private handleRequest;
+    private createSession;
+    private closeAllSessions;
+}
+export declare function create(resource: HttpEndpointManifest, ctx: ResourceContext): Promise<McpHttpEndpoint>;
+export {};

package/dist/http-endpoint-controller.js

@@ -0,0 +1,162 @@
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { RuntimeError } from "@telorun/sdk";
+import { buildServer } from "./registry.js";
+export async function register(_ctx) { }
+export class McpHttpEndpoint {
+    resource;
+    ctx;
+    sessions = new Map();
+    toolsBundles = [];
+    constructor(resource, ctx) {
+        this.resource = resource;
+        this.ctx = ctx;
+    }
+    async init() {
+        if ((this.resource.resources ?? []).length > 0 || (this.resource.prompts ?? []).length > 0) {
+            throw new RuntimeError("ERR_MCP_V2_NOT_IMPLEMENTED", `Mcp.HttpEndpoint[${this.resource.metadata.name}]: resources/prompts are schema-only in v1; runtime dispatch is v2 work`);
+        }
+        this.toolsBundles = (this.resource.tools ?? []).map((bundleName) => {
+            const inst = this.ctx.moduleContext.getInstance(bundleName);
+            if (!inst) {
+                throw new RuntimeError("ERR_MCP_BUNDLE_NOT_FOUND", `Mcp.HttpEndpoint[${this.resource.metadata.name}]: tools bundle '${bundleName}' not found in module scope`);
+            }
+            return inst;
+        });
+    }
+    /** Mount contract — duck-typed against Http.Server's mount loop. The
+     *  signature matches Http.Api.register(); see plan §3 mount contract.
+     *
+     *  Routes are declared with `app.route(...)` directly rather than via
+     *  `app.register(plugin, { prefix })`. The latter is async (the plugin
+     *  loads inside `app.ready()`); declaring the route synchronously removes
+     *  any ordering coupling with the host's `app.listen()` call. Both
+     *  `<prefix>` and `<prefix>/` are registered so trailing-slash variants
+     *  both reach the handler. */
+    register(app, prefix = "") {
+        const handler = async (request, reply) => {
+            await this.handleRequest(request, reply);
+        };
+        const methods = ["POST", "GET", "DELETE"];
+        // Normalize prefix: strip a trailing slash unless the prefix is exactly
+        // "/", so a configured `/mcp/` doesn't expand to `/mcp//`.
+        const base = prefix && prefix !== "/" && prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+        if (base && base !== "/") {
+            app.route({ method: methods, url: base, handler });
+            app.route({ method: methods, url: `${base}/`, handler });
+        }
+        else {
+            app.route({ method: methods, url: "/", handler });
+        }
+        app.addHook("onClose", async () => {
+            await this.closeAllSessions();
+        });
+    }
+    async handleRequest(request, reply) {
+        const sessionHeader = (request.headers["mcp-session-id"] ?? "");
+        const body = request.body;
+        let record;
+        if (sessionHeader) {
+            record = this.sessions.get(sessionHeader);
+            if (!record) {
+                reply.code(404);
+                reply.header("Content-Type", "application/json");
+                reply.send({
+                    jsonrpc: "2.0",
+                    error: { code: -32001, message: "Mcp: unknown session" },
+                    id: null,
+                });
+                return;
+            }
+        }
+        else if (request.method === "POST" && body && isInitializeRequest(body)) {
+            record = await this.createSession();
+        }
+        else {
+            reply.code(400);
+            reply.header("Content-Type", "application/json");
+            reply.send({
+                jsonrpc: "2.0",
+                error: {
+                    code: -32000,
+                    message: "Mcp: missing Mcp-Session-Id header (or initialize request body)",
+                },
+                id: null,
+            });
+            return;
+        }
+        // Hand the raw request/response off to the SDK transport. Fastify has
+        // already parsed the body, so we pass it explicitly — the transport will
+        // not re-read the stream.
+        reply.hijack();
+        await record.transport.handleRequest(request.raw, reply.raw, body);
+    }
+    async createSession() {
+        const sessionContext = { id: "", clientInfo: {}, capabilities: {} };
+        // Pre-allocate the SessionRecord shell so the onsessioninitialized
+        // closure can capture a stable object reference and register the session
+        // synchronously, before the transport writes the initialize response.
+        // Registering after `await transport.handleRequest()` would open a race
+        // where the client's follow-up request races with the registration.
+        const record = { context: sessionContext };
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (id) => {
+                sessionContext.id = id;
+                this.sessions.set(id, record);
+            },
+        });
+        record.transport = transport;
+        record.server = buildServer({
+            serverInfo: this.resource.serverInfo,
+            toolsBundles: this.toolsBundles,
+            sessionResolver: () => sessionContext,
+            ctx: this.ctx,
+            moduleContext: this.ctx.moduleContext,
+        });
+        transport.onclose = () => {
+            if (sessionContext.id) {
+                this.sessions.delete(sessionContext.id);
+            }
+        };
+        await record.server.connect(transport);
+        return record;
+    }
+    async closeAllSessions() {
+        const records = Array.from(this.sessions.values());
+        this.sessions.clear();
+        for (const record of records) {
+            const sessionId = record.context.id || "<unbound>";
+            try {
+                await record.transport.close();
+            }
+            catch (err) {
+                await this.ctx.emitEvent(`${this.resource.metadata.name}.SessionCloseFailed`, {
+                    sessionId,
+                    stage: "transport",
+                    error: errorPayload(err),
+                });
+            }
+            try {
+                await record.server.close();
+            }
+            catch (err) {
+                await this.ctx.emitEvent(`${this.resource.metadata.name}.SessionCloseFailed`, {
+                    sessionId,
+                    stage: "server",
+                    error: errorPayload(err),
+                });
+            }
+        }
+    }
+}
+function errorPayload(err) {
+    if (err instanceof Error) {
+        return { message: err.message, stack: err.stack, code: err.code };
+    }
+    return { message: String(err) };
+}
+export async function create(resource, ctx) {
+    return new McpHttpEndpoint(resource, ctx);
+}

package/dist/outcome.d.ts

@@ -0,0 +1,45 @@
+import type { ResourceInstance } from "@telorun/sdk";
+/** Single catches: entry on a tool/resource/prompt entry. `when` is typed
+ *  loosely because the manifest schema says `type: boolean` but the value at
+ *  this point is a `CompiledValue` (when the user wrote `${{ ... }}`) or a
+ *  bare boolean literal (when the user wrote `when: true`/`when: false`).
+ *  Truthiness checks would mis-classify the literal `false` case as "no
+ *  when field" — see matchCatch below. */
+export interface CatchEntry {
+    code?: string;
+    when?: unknown;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+/** Resolved entry handed to the registry — handler ref is captured before
+ *  Phase 5 injection (kind/name) and the live instance is read after. */
+export interface ResolvedToolEntry {
+    name: string;
+    description?: string;
+    argumentsSchema: Record<string, unknown>;
+    inputs: Record<string, unknown>;
+    result: Record<string, unknown>;
+    catches?: CatchEntry[];
+    handlerKind: string;
+    handlerName: string;
+    handler: ResourceInstance;
+}
+/** Module-context-shaped surface used by registry dispatch — matches the
+ *  shape consumed by http-api-controller's dispatchReturns/dispatchCatches. */
+export interface ModuleLikeContext {
+    expandWith: (v: unknown, ctx: Record<string, unknown>) => unknown;
+}
+interface InvokeError {
+    code: string;
+    message: string;
+    data?: unknown;
+}
+/** Pick the first `catches:` entry that matches the thrown InvokeError. An
+ *  entry matches when *every* declared predicate passes: `code:` (if present)
+ *  must equal the error's code AND `when:` (if present) must evaluate truthy.
+ *  An entry with neither field is the catch-all and matches last. */
+export declare function matchCatch(catches: CatchEntry[] | undefined, err: InvokeError, celCtx: Record<string, unknown>, moduleContext: ModuleLikeContext): CatchEntry | undefined;
+export {};

package/dist/outcome.js

@@ -0,0 +1,22 @@
+/** Pick the first `catches:` entry that matches the thrown InvokeError. An
+ *  entry matches when *every* declared predicate passes: `code:` (if present)
+ *  must equal the error's code AND `when:` (if present) must evaluate truthy.
+ *  An entry with neither field is the catch-all and matches last. */
+export function matchCatch(catches, err, celCtx, moduleContext) {
+    if (!catches || catches.length === 0)
+        return undefined;
+    let fallback;
+    for (const entry of catches) {
+        if (entry.when === undefined && entry.code === undefined) {
+            fallback ??= entry;
+            continue;
+        }
+        if (entry.code !== undefined && entry.code !== err.code)
+            continue;
+        if (entry.when !== undefined && moduleContext.expandWith(entry.when, celCtx) !== true) {
+            continue;
+        }
+        return entry;
+    }
+    return fallback;
+}

package/dist/prompts-controller.d.ts

@@ -0,0 +1,18 @@
+import { type ControllerContext, type ResourceContext } from "@telorun/sdk";
+interface PromptsManifest {
+    metadata?: {
+        name?: string;
+    };
+    entries?: unknown[];
+}
+export declare function register(_ctx: ControllerContext): Promise<void>;
+/** v2 runtime — schema-only in v1. See resources-controller.ts for the same
+ *  pattern. */
+export declare class McpPromptsBundle {
+    readonly bundleName: string;
+    readonly entries: unknown[];
+    constructor(bundleName: string, entries: unknown[]);
+    resolveEntries(): never;
+}
+export declare function create(resource: PromptsManifest, _ctx: ResourceContext): Promise<McpPromptsBundle>;
+export {};

package/dist/prompts-controller.js

@@ -0,0 +1,22 @@
+import { RuntimeError } from "@telorun/sdk";
+export async function register(_ctx) { }
+/** v2 runtime — schema-only in v1. See resources-controller.ts for the same
+ *  pattern. */
+export class McpPromptsBundle {
+    bundleName;
+    entries;
+    constructor(bundleName, entries) {
+        this.bundleName = bundleName;
+        this.entries = entries;
+    }
+    resolveEntries() {
+        throw new RuntimeError("ERR_MCP_V2_NOT_IMPLEMENTED", `Mcp.Prompts[${this.bundleName}]: runtime dispatch is v2 work`);
+    }
+}
+export async function create(resource, _ctx) {
+    const bundleName = resource.metadata?.name;
+    if (!bundleName) {
+        throw new RuntimeError("ERR_MCP_PROMPTS_INVALID", "Mcp.Prompts: metadata.name is required");
+    }
+    return new McpPromptsBundle(bundleName, resource.entries ?? []);
+}

package/dist/registry.d.ts

@@ -0,0 +1,28 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { type ResourceContext } from "@telorun/sdk";
+import { type ModuleLikeContext } from "./outcome.js";
+import type { McpToolsBundle } from "./tools-controller.js";
+export interface ServerInfo {
+    name: string;
+    version: string;
+}
+export interface BuildOptions {
+    serverInfo: ServerInfo;
+    toolsBundles: McpToolsBundle[];
+    /** Per-session metadata exposed to CEL inputs as `request.session`. */
+    sessionResolver: () => SessionContext;
+    ctx: ResourceContext;
+    moduleContext: ModuleLikeContext;
+}
+export interface SessionContext {
+    id: string;
+    clientInfo: {
+        name?: string;
+        version?: string;
+    } | Record<string, unknown>;
+    capabilities: Record<string, unknown>;
+}
+/** Build a fully-wired SDK Server. For stdio the caller connects this once;
+ *  for streamable HTTP a fresh Server is built per session, so this is called
+ *  every time a new Mcp-Session-Id is minted. */
+export declare function buildServer(opts: BuildOptions): Server;

package/dist/registry.js

@@ -0,0 +1,84 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { isInvokeError, RuntimeError } from "@telorun/sdk";
+import { matchCatch } from "./outcome.js";
+/** Merge entries from every bundle, throwing if two bundles register the same
+ *  tool name. The plan calls for the analyzer to also catch this at compile
+ *  time (§5.1 item 2) — this runtime guard backstops it until that lands. */
+function mergeToolEntries(bundles) {
+    const byName = new Map();
+    const owners = new Map();
+    for (const bundle of bundles) {
+        for (const entry of bundle.resolveEntries()) {
+            const priorOwner = owners.get(entry.name);
+            if (priorOwner) {
+                throw new RuntimeError("ERR_MCP_TOOLS_DUPLICATE", `Mcp: duplicate tool name '${entry.name}' across bundles '${priorOwner}' and '${bundle.bundleName}'`);
+            }
+            owners.set(entry.name, bundle.bundleName);
+            byName.set(entry.name, entry);
+        }
+    }
+    return byName;
+}
+/** Build a fully-wired SDK Server. For stdio the caller connects this once;
+ *  for streamable HTTP a fresh Server is built per session, so this is called
+ *  every time a new Mcp-Session-Id is minted. */
+export function buildServer(opts) {
+    const tools = mergeToolEntries(opts.toolsBundles);
+    const server = new Server({ name: opts.serverInfo.name, version: opts.serverInfo.version }, { capabilities: { tools: {} } });
+    const advertised = Array.from(tools.values()).map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.argumentsSchema,
+    }));
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: advertised }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const tool = tools.get(request.params.name);
+        if (!tool) {
+            throw new RuntimeError("ERR_MCP_UNKNOWN_TOOL", `Mcp: unknown tool '${request.params.name}'`);
+        }
+        const session = opts.sessionResolver();
+        const requestCtx = {
+            request: {
+                name: tool.name,
+                arguments: request.params.arguments ?? {},
+                meta: request.params._meta ?? {},
+                session: {
+                    id: session.id,
+                    clientInfo: session.clientInfo,
+                    capabilities: session.capabilities,
+                },
+            },
+        };
+        const inputs = opts.moduleContext.expandWith(tool.inputs, requestCtx);
+        let handlerResult;
+        try {
+            handlerResult = await opts.ctx.invokeResolved(tool.handlerKind, tool.handlerName, tool.handler, { ...inputs, inputs });
+        }
+        catch (err) {
+            if (!isInvokeError(err))
+                throw err;
+            const errPayload = { code: err.code, message: err.message, data: err.data };
+            const celCtx = { error: errPayload, request: requestCtx.request };
+            const matched = matchCatch(tool.catches, errPayload, celCtx, opts.moduleContext);
+            if (!matched) {
+                throw err;
+            }
+            const expanded = opts.moduleContext.expandWith(matched.error, celCtx);
+            const ipcError = new Error(expanded.message);
+            ipcError.code = expanded.code;
+            ipcError.data = expanded.data;
+            throw ipcError;
+        }
+        const resultCtx = { result: handlerResult, request: requestCtx.request };
+        const rendered = opts.moduleContext.expandWith(tool.result, resultCtx);
+        // Schema requires `content` to be present, but the value comes from CEL
+        // expansion at runtime so its type can't be enforced statically. Verify
+        // the expanded shape here.
+        if (!Array.isArray(rendered.content)) {
+            throw new RuntimeError("ERR_MCP_RESULT_INVALID", `Mcp: tool '${tool.name}' result.content is not an array of content blocks`);
+        }
+        return rendered;
+    });
+    return server;
+}

package/dist/resources-controller.d.ts

@@ -0,0 +1,20 @@
+import { type ControllerContext, type ResourceContext } from "@telorun/sdk";
+interface ResourcesManifest {
+    metadata?: {
+        name?: string;
+    };
+    entries?: unknown[];
+}
+export declare function register(_ctx: ControllerContext): Promise<void>;
+/** v2 runtime — schema-only in v1. The bundle is created so transport refs
+ *  resolve cleanly, but transports refuse to wire it up: `Mcp.StdioServer` /
+ *  `Mcp.HttpEndpoint` throw at init() if `resources:` is non-empty, and
+ *  `resolveEntries()` throws if anyone calls it directly. */
+export declare class McpResourcesBundle {
+    readonly bundleName: string;
+    readonly entries: unknown[];
+    constructor(bundleName: string, entries: unknown[]);
+    resolveEntries(): never;
+}
+export declare function create(resource: ResourcesManifest, _ctx: ResourceContext): Promise<McpResourcesBundle>;
+export {};

package/dist/resources-controller.js

@@ -0,0 +1,24 @@
+import { RuntimeError } from "@telorun/sdk";
+export async function register(_ctx) { }
+/** v2 runtime — schema-only in v1. The bundle is created so transport refs
+ *  resolve cleanly, but transports refuse to wire it up: `Mcp.StdioServer` /
+ *  `Mcp.HttpEndpoint` throw at init() if `resources:` is non-empty, and
+ *  `resolveEntries()` throws if anyone calls it directly. */
+export class McpResourcesBundle {
+    bundleName;
+    entries;
+    constructor(bundleName, entries) {
+        this.bundleName = bundleName;
+        this.entries = entries;
+    }
+    resolveEntries() {
+        throw new RuntimeError("ERR_MCP_V2_NOT_IMPLEMENTED", `Mcp.Resources[${this.bundleName}]: runtime dispatch is v2 work`);
+    }
+}
+export async function create(resource, _ctx) {
+    const bundleName = resource.metadata?.name;
+    if (!bundleName) {
+        throw new RuntimeError("ERR_MCP_RESOURCES_INVALID", "Mcp.Resources: metadata.name is required");
+    }
+    return new McpResourcesBundle(bundleName, resource.entries ?? []);
+}

package/dist/stdio-server-controller.d.ts

@@ -0,0 +1,26 @@
+import { type ControllerContext, type ResourceContext } from "@telorun/sdk";
+import { type ServerInfo } from "./registry.js";
+interface StdioServerManifest {
+    metadata: {
+        name: string;
+    };
+    serverInfo: ServerInfo;
+    tools?: string[];
+    resources?: string[];
+    prompts?: string[];
+}
+export declare function register(_ctx: ControllerContext): Promise<void>;
+export declare class McpStdioServer {
+    private readonly resource;
+    private readonly ctx;
+    private server;
+    private transport;
+    private releaseHold;
+    private session;
+    constructor(resource: StdioServerManifest, ctx: ResourceContext);
+    init(): Promise<void>;
+    run(): Promise<void>;
+    teardown(): Promise<void>;
+}
+export declare function create(resource: StdioServerManifest, ctx: ResourceContext): Promise<McpStdioServer>;
+export {};