agent-trellis 0.11.0 → 0.12.0

package/dist/lib/mcpConnect.js

@@ -12,10 +12,8 @@
  * which servers are in scope, or knows what a tool is; callers isolate
  * failures in whatever way suits them.
  */
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport, getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { Client, StreamableHTTPClientTransport, SSEClientTransport } from "@modelcontextprotocol/client";
+import { StdioClientTransport, getDefaultEnvironment } from "@modelcontextprotocol/client/stdio";
 import { resolveSecretEnv } from "./secretEnv.js";
 import { extractTemplateVarNames } from "./envVarNames.js";
 export const DEFAULT_CONNECT_TIMEOUT_MS = 10_000;
@@ -68,7 +66,7 @@ export async function connectWithCleanup(client, transport, timeoutMs, message)
     }
 }
 export async function connectStdio(def, secretsPolicy, timeoutMs, clientInfo) {
-    const client = new Client(clientInfo, { capabilities: {} });
+    const client = new Client(clientInfo, { capabilities: {}, versionNegotiation: { mode: "auto", probe: { timeoutMs: Math.min(3000, timeoutMs / 2) } } });
     const envAliases = def.envAliases ?? {};
     // `envAliases`' values are source variable names — resolved through the
     // exact same call as `env`'s own names, never delivered as the raw
@@ -81,6 +79,9 @@ export async function connectStdio(def, secretsPolicy, timeoutMs, clientInfo) {
     const transport = new StdioClientTransport({
         command: def.command,
         args: def.args,
+        // A 16 MiB skill file can expand sixfold when JSON escapes control bytes.
+        // Keep framing bounded without rejecting a valid Skills-extension file.
+        maxBufferSize: 128 * 1024 * 1024,
         // staticEnv merges last: a literal, intentionally-plain value (an
         // email, an environment tag) always wins over an unresolved name-only
         // entry's empty-string fallback for the same key — though in practice
@@ -102,12 +103,13 @@ export function resolveHeaders(def, secretsPolicy) {
     return result;
 }
 export async function connectHttp(def, secretsPolicy, timeoutMs, clientInfo) {
-    const client = new Client(clientInfo, { capabilities: {} });
+    const client = new Client(clientInfo, { capabilities: {}, versionNegotiation: { mode: "auto", probe: { timeoutMs } } });
     const headers = resolveHeaders(def, secretsPolicy);
     const opts = headers ? { requestInit: { headers } } : undefined;
     return connectWithCleanup(client, new StreamableHTTPClientTransport(new URL(def.url), opts), timeoutMs, `connect timed out after ${timeoutMs}ms`);
 }
 export async function connectSse(def, secretsPolicy, timeoutMs, clientInfo) {
+    // HTTP+SSE is a legacy transport; it cannot carry modern discovery.
     const client = new Client(clientInfo, { capabilities: {} });
     const headers = resolveHeaders(def, secretsPolicy);
     const opts = headers ? { requestInit: { headers } } : undefined;

package/dist/lib/mcpRuntime.d.ts

@@ -1,5 +1,5 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import type { CallToolResult, GetPromptResult, Implementation, Prompt, ReadResourceResult, Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
+import { Server } from "@modelcontextprotocol/server";
+import type { CallToolResult, GetPromptResult, Implementation, Prompt, ReadResourceResult, Resource, Tool } from "@modelcontextprotocol/server";
 import type { AgentId } from "../core/types.js";
 import type { GatewayBackend } from "./gatewayBackend.js";
 import type { SkillEntry } from "./skillManifest.js";
@@ -47,6 +47,10 @@ export declare class UpstreamProvider implements TrellisProvider {
     constructor(backend: GatewayBackend);
     listTools(): Promise<Tool[]>;
     callTool(name: string, args: unknown): Promise<CallToolResult>;
+    listResources(): Promise<Resource[]>;
+    readResource(uri: URL): Promise<ReadResourceResult>;
+    listSkillEntries(): Promise<SkillEntry[]>;
+    getSkillEntry(uri: string): Promise<SkillEntry | undefined>;
     close(): Promise<void>;
 }
 export declare function createRuntimeServer(serverInfo: Implementation, context: RuntimeContext, registry: BuiltinRegistry): Server;

package/dist/lib/mcpRuntime.js

@@ -1,6 +1,7 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolRequestSchema, ErrorCode, McpError, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { Server, ProtocolErrorCode, ProtocolError } from "@modelcontextprotocol/server";
+import { z } from "zod/v4";
 import { allocateExposedToolNames } from "./mcpToolRegistry.js";
+import { withoutUpstreamServerInfo } from "./upstreamResources.js";
 function compactBuiltinToolName(name) {
     return name.startsWith("trellis.") ? name.slice("trellis.".length).replaceAll(".", "_") : name;
 }
@@ -102,6 +103,9 @@ export class BuiltinRegistry {
             await this.listResources(context);
             provider = this.resourceOwners.get(key);
         }
+        // A manifest can introduce supporting files not returned by resources/list.
+        if (!provider && uri.protocol === "trellis-upstream:")
+            provider = this.providers.find((candidate) => candidate.id === "upstream");
         if (!provider?.readResource)
             throw new Error(`unknown Trellis resource "${key}"`);
         return provider.readResource(uri, context);
@@ -190,8 +194,16 @@ export class UpstreamProvider {
         return (await this.backend.listTools());
     }
     async callTool(name, args) {
-        return (await this.backend.callTool(name, args));
+        return withoutUpstreamServerInfo((await this.backend.callTool(name, args)));
     }
+    async listResources() { return await this.backend.listResources?.() ?? []; }
+    async readResource(uri) {
+        if (!this.backend.readResource)
+            throw new Error("upstream resources unavailable");
+        return this.backend.readResource(uri.toString());
+    }
+    async listSkillEntries() { return await this.backend.listSkills?.() ?? []; }
+    async getSkillEntry(uri) { return this.backend.getSkill?.(uri); }
     async close() {
         await this.backend.close();
     }
@@ -202,35 +214,33 @@ export function createRuntimeServer(serverInfo, context, registry) {
             tools: { listChanged: true },
             resources: { listChanged: true },
             prompts: { listChanged: true },
+            extensions: { "io.modelcontextprotocol/skills": {} },
         },
     });
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: await registry.listTools(context) }));
-    server.setRequestHandler(CallToolRequestSchema, async (request) => registry.callTool(request.params.name, request.params.arguments, context));
-    server.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: await registry.listResources(context) }));
-    server.setRequestHandler(ReadResourceRequestSchema, async (request) => registry.readResource(new URL(request.params.uri), context));
-    server.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: await registry.listPrompts(context) }));
-    server.setRequestHandler(GetPromptRequestSchema, async (request) => registry.getPrompt(request.params.name, request.params.arguments, context));
-    // `skills/list` and `skills/get` are not in this SDK's schema set (it speaks
-    // at most 2025-11-25), so they are answered through the SDK's fallback for
-    // methods with no registered handler, which keeps the extension free of a new
-    // direct zod dependency. The extension itself is deliberately NOT declared in
-    // the capabilities above: the specification declares it only through
-    // `server/discover`, which this revision lacks, and inventing another field
-    // would claim a protocol nobody defined (trellis-skills-over-mcp D4). Any
-    // other unknown method keeps the SDK's usual "method not found".
-    server.fallbackRequestHandler = async (request) => {
-        const cache = { resultType: "complete", ttlMs: 0, cacheScope: "private" };
-        if (request.method === "skills/list") {
-            return { ...cache, skills: await registry.listSkills(context) };
+    server.setRequestHandler("tools/list", async () => ({ tools: await registry.listTools(context) }));
+    server.setRequestHandler("tools/call", async ({ params }) => registry.callTool(params.name, params.arguments, context));
+    server.setRequestHandler("resources/list", async () => ({ resources: await registry.listResources(context) }));
+    server.setRequestHandler("resources/read", async ({ params }) => {
+        try {
+            return await registry.readResource(new URL(params.uri), context);
         }
-        if (request.method === "skills/get") {
-            const uri = request.params?.uri;
-            const entry = typeof uri === "string" ? await registry.getSkill(uri, context) : undefined;
-            if (!entry)
-                throw new McpError(ErrorCode.InvalidParams, "unknown skill");
-            return { ...cache, skill: entry };
+        catch (err) {
+            if (err instanceof TypeError || (err instanceof Error && /unknown|not found|not allowed|outside|secret-like|invalid.*uri/i.test(err.message))) {
+                throw new ProtocolError(ProtocolErrorCode.InvalidParams, "unknown or unreadable resource");
+            }
+            throw err;
         }
-        throw new McpError(ErrorCode.MethodNotFound, `Method not found: ${request.method}`);
-    };
+    });
+    server.setRequestHandler("prompts/list", async () => ({ prompts: await registry.listPrompts(context) }));
+    server.setRequestHandler("prompts/get", async ({ params }) => registry.getPrompt(params.name, params.arguments, context));
+    const result = z.looseObject({});
+    const cache = { ttlMs: 0, cacheScope: "private" };
+    server.setRequestHandler("skills/list", { params: z.object({ cursor: z.string().optional() }), result }, async () => ({ ...cache, skills: await registry.listSkills(context) }));
+    server.setRequestHandler("skills/get", { params: z.object({ uri: z.string() }), result }, async ({ uri }) => {
+        const entry = await registry.getSkill(uri, context);
+        if (!entry)
+            throw new ProtocolError(ProtocolErrorCode.InvalidParams, "unknown skill");
+        return { ...cache, skill: entry };
+    });
     return server;
 }

package/dist/lib/mcpStatusProvider.d.ts

@@ -1,4 +1,4 @@
-import type { CallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { CallToolResult, Tool } from "@modelcontextprotocol/server";
 import type { GatewayBackend } from "./gatewayBackend.js";
 import type { RuntimeContext, TrellisProvider } from "./mcpRuntime.js";
 export declare class McpStatusProvider implements TrellisProvider {

package/dist/lib/memoryProvider.d.ts

@@ -1,4 +1,4 @@
-import type { CallToolResult, ReadResourceResult, Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { CallToolResult, ReadResourceResult, Resource, Tool } from "@modelcontextprotocol/server";
 import type { Scope } from "../core/types.js";
 import type { RuntimeContext, TrellisProvider } from "./mcpRuntime.js";
 /**

package/dist/lib/oauth/discovery.d.ts

@@ -27,6 +27,7 @@ export interface AuthorizationServerMetadata {
     registrationEndpoint?: string;
     scopesSupported?: string[];
     codeChallengeMethodsSupported?: string[];
+    issuerParameterSupported?: boolean;
 }
 export type FetchLike = (url: string, init?: {
     method?: string;

package/dist/lib/oauth/discovery.js

@@ -37,6 +37,8 @@ function toMetadata(raw) {
         out.scopesSupported = raw.scopes_supported;
     if (raw.code_challenge_methods_supported)
         out.codeChallengeMethodsSupported = raw.code_challenge_methods_supported;
+    if (raw.authorization_response_iss_parameter_supported)
+        out.issuerParameterSupported = true;
     return out;
 }
 async function tryJson(fetchImpl, url) {

package/dist/lib/oauth/flow.d.ts

@@ -31,6 +31,9 @@ export interface AuthorizeOptions {
      * is actually bound, so a fixed one is never required. */
     callbackPort?: number;
     timeoutMs?: number;
+    signal?: AbortSignal;
+    resourceUrl?: string;
+    onProgress?: (phase: "registering" | "waiting" | "exchanging") => void;
 }
 /**
  * RFC 7591. Returns `undefined` when the AS advertises no registration
@@ -58,3 +61,4 @@ export declare function registerClient(metadata: AuthorizationServerMetadata, re
  * caller's decision, so this stays testable without a home directory.
  */
 export declare function authorize(serverName: string, metadata: AuthorizationServerMetadata, opts?: AuthorizeOptions): Promise<StoredToken>;
+export declare function abortable<T>(value: T | Promise<T>, signal?: AbortSignal): Promise<T>;

package/dist/lib/oauth/flow.js

@@ -15,6 +15,7 @@
  */
 import { createServer } from "node:http";
 import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
 import { createPkcePair } from "./pkce.js";
 export class AuthorizationError extends Error {
 }
@@ -89,6 +90,11 @@ function listenForCallback(port) {
         });
         const server = createServer((req, res) => {
             const url = new URL(req.url ?? "/", "http://127.0.0.1");
+            if (req.method !== "GET" || url.pathname !== "/callback") {
+                res.writeHead(404);
+                res.end();
+                return;
+            }
             const result = {};
             const code = url.searchParams.get("code");
             const state = url.searchParams.get("state");
@@ -97,6 +103,9 @@ function listenForCallback(port) {
                 result.code = code;
             if (state)
                 result.state = state;
+            const issuer = url.searchParams.get("iss");
+            if (issuer)
+                result.issuer = issuer;
             if (error) {
                 result.error = error;
                 const description = url.searchParams.get("error_description");
@@ -106,7 +115,7 @@ function listenForCallback(port) {
             res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
             res.end(result.error
                 ? `<html><body><h1>Authorization failed</h1><p>${escapeHtml(result.errorDescription ?? result.error)}</p></body></html>`
-                : "<html><body><h1>Authorized</h1><p>You can close this tab and return to your terminal.</p></body></html>");
+                : "<html><body><h1>Authorization response received</h1><p>You can close this tab and return to Trellis.</p></body></html>");
             settle(result);
         });
         server.on("error", reject);
@@ -124,7 +133,8 @@ function escapeHtml(value) {
  * caller's decision, so this stays testable without a home directory.
  */
 export async function authorize(serverName, metadata, opts = {}) {
-    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    opts.signal?.throwIfAborted();
+    const fetchImpl = opts.fetchImpl ?? ((url, init) => fetch(url, { ...init, signal: opts.signal }));
     const now = opts.now ?? Date.now;
     const timeoutMs = opts.timeoutMs ?? 300_000;
     const { server, port, received } = await listenForCallback(opts.callbackPort ?? 0);
@@ -133,13 +143,14 @@ export async function authorize(serverName, metadata, opts = {}) {
         let clientId = opts.clientId;
         let clientSecret = opts.clientSecret;
         if (!clientId) {
+            opts.onProgress?.("registering");
             // The AS cannot register us AND canonical carries no client_id — the
             // one dead end a person has to resolve by hand, so it is reported as
             // such rather than as a generic registration failure
             // (trellis-mcp-oauth-static-client design.md D3, task 2.3).
             let registered;
             try {
-                registered = await registerClient(metadata, redirectUri, { fetchImpl, scope: opts.scope });
+                registered = await abortable(registerClient(metadata, redirectUri, { fetchImpl, scope: opts.scope }), opts.signal);
             }
             catch (err) {
                 if (err instanceof AuthorizationError) {
@@ -164,8 +175,12 @@ export async function authorize(serverName, metadata, opts = {}) {
         authUrl.searchParams.set("state", state);
         if (opts.scope)
             authUrl.searchParams.set("scope", opts.scope);
-        await (opts.openBrowser ?? defaultOpenBrowser)(authUrl.toString());
-        const callback = await withTimeout(received, timeoutMs, `timed out waiting for the authorization callback for "${serverName}"`);
+        if (opts.resourceUrl)
+            authUrl.searchParams.set("resource", opts.resourceUrl);
+        opts.signal?.throwIfAborted();
+        opts.onProgress?.("waiting");
+        await abortable((opts.openBrowser ?? defaultOpenBrowser)(authUrl.toString()), opts.signal);
+        const callback = await withTimeout(received, timeoutMs, `timed out waiting for the authorization callback for "${serverName}"`, opts.signal);
         if (callback.error) {
             throw new AuthorizationError(`authorization for "${serverName}" was refused: ${callback.errorDescription ?? callback.error}`);
         }
@@ -177,6 +192,11 @@ export async function authorize(serverName, metadata, opts = {}) {
         if (callback.state !== state) {
             throw new AuthorizationError(`authorization callback for "${serverName}" carried an unexpected state parameter`);
         }
+        if ((callback.issuer && callback.issuer !== metadata.issuer) || (metadata.issuerParameterSupported && !callback.issuer)) {
+            throw new AuthorizationError("authorization callback issuer does not match the discovered authorization server");
+        }
+        opts.signal?.throwIfAborted();
+        opts.onProgress?.("exchanging");
         const body = new URLSearchParams({
             grant_type: "authorization_code",
             code: callback.code,
@@ -186,11 +206,13 @@ export async function authorize(serverName, metadata, opts = {}) {
         });
         if (clientSecret)
             body.set("client_secret", clientSecret);
-        const response = await fetchImpl(metadata.tokenEndpoint, {
+        if (opts.resourceUrl)
+            body.set("resource", opts.resourceUrl);
+        const response = await abortable(fetchImpl(metadata.tokenEndpoint, {
             method: "POST",
             headers: { "content-type": "application/x-www-form-urlencoded", accept: "application/json" },
             body: body.toString(),
-        });
+        }), opts.signal);
         if (!response.ok) {
             throw new AuthorizationError(`token exchange for "${serverName}" failed with HTTP ${response.status}`);
         }
@@ -202,6 +224,8 @@ export async function authorize(serverName, metadata, opts = {}) {
             accessToken: payload.access_token,
             tokenEndpoint: metadata.tokenEndpoint,
             clientId,
+            issuer: metadata.issuer,
+            ...(opts.resourceUrl ? { resourceUrl: opts.resourceUrl } : {}),
         };
         if (payload.refresh_token)
             token.refreshToken = payload.refresh_token;
@@ -214,25 +238,38 @@ export async function authorize(serverName, metadata, opts = {}) {
         return token;
     }
     finally {
+        server.closeAllConnections();
         server.close();
     }
 }
-function withTimeout(promise, timeoutMs, message) {
+function withTimeout(promise, timeoutMs, message, signal) {
     return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new AuthorizationError(message)), timeoutMs);
+        const abort = () => { clearTimeout(timer); signal?.removeEventListener("abort", abort); reject(signal?.reason ?? new Error("authorization cancelled")); };
+        const timer = setTimeout(() => { signal?.removeEventListener("abort", abort); reject(new AuthorizationError(message)); }, timeoutMs);
+        signal?.addEventListener("abort", abort, { once: true });
+        if (signal?.aborted)
+            abort();
         promise.then((value) => {
             clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
             resolve(value);
         }, (err) => {
             clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
             reject(err);
         });
     });
 }
+export function abortable(value, signal) {
+    return withTimeout(Promise.resolve(value), 300_000, "authorization timed out", signal);
+}
 async function defaultOpenBrowser(url) {
-    const { spawn } = await import("node:child_process");
     const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
     // Detached and fully ignored: a browser that outlives this command is
     // correct, and its stdio must not be inherited onto ours.
-    spawn(command, [url], { detached: true, stdio: "ignore" }).unref();
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, [url], { detached: true, stdio: "ignore" });
+        child.once("error", reject);
+        child.once("spawn", () => { child.unref(); resolve(); });
+    });
 }

package/dist/lib/oauth/refresh.d.ts

@@ -12,6 +12,7 @@ import { type StoredToken } from "./store.js";
 import type { FetchLike } from "./discovery.js";
 export interface RefreshOptions {
     fetchImpl?: FetchLike;
+    timeoutMs?: number;
     /** Test seam; also lets a caller widen the early-refresh skew. */
     now?: () => number;
     skewMs?: number;

package/dist/lib/oauth/refresh.js

@@ -49,7 +49,7 @@ export async function ensureFreshToken(homeDir, serverName, opts = {}) {
     }, { timeoutMs: opts.lockTimeoutMs, now });
 }
 export async function performRefresh(serverName, token, opts = {}) {
-    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    const fetchImpl = opts.fetchImpl ?? ((url, init) => fetch(url, { ...init, signal: AbortSignal.timeout(opts.timeoutMs ?? 10_000) }));
     const now = opts.now ?? Date.now;
     if (!token.tokenEndpoint) {
         throw new RefreshError(`OAuth token for "${serverName}" has no recorded token endpoint — run \`trellis mcp auth ${serverName}\``);
@@ -59,6 +59,8 @@ export async function performRefresh(serverName, token, opts = {}) {
         body.set("client_id", token.clientId);
     if (token.clientSecret)
         body.set("client_secret", token.clientSecret);
+    if (token.resourceUrl)
+        body.set("resource", token.resourceUrl);
     const response = await fetchImpl(token.tokenEndpoint, {
         method: "POST",
         headers: { "content-type": "application/x-www-form-urlencoded", accept: "application/json" },

package/dist/lib/oauth/store.d.ts

@@ -29,6 +29,8 @@ export interface StoredToken {
      * metadata — the gateway's refresh path should be one request. */
     tokenEndpoint?: string;
     scope?: string;
+    resourceUrl?: string;
+    issuer?: string;
 }
 export declare function oauthDir(homeDir: string): string;
 /**

package/dist/lib/runtimeControlProvider.d.ts

@@ -1,4 +1,4 @@
-import type { CallToolResult, ReadResourceResult, Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { CallToolResult, ReadResourceResult, Resource, Tool } from "@modelcontextprotocol/server";
 import type { GatewayBackend } from "./gatewayBackend.js";
 import type { RuntimeContext, TrellisProvider } from "./mcpRuntime.js";
 export declare class RuntimeControlProvider implements TrellisProvider {

package/dist/lib/skillManifest.d.ts

@@ -22,6 +22,7 @@ export interface SkillEntry {
     uri: string;
     frontmatter: Record<string, unknown>;
     resources: SkillManifestFile[];
+    _meta?: Record<string, unknown>;
 }
 export type SkillBuild = {
     ok: true;

package/dist/lib/skillManifest.js

@@ -94,7 +94,7 @@ export function mimeTypeFor(path) {
  * base64 blob, or the bytes a host verifies would not be the bytes we hashed. */
 export function toResourceContent(uri, path, bytes) {
     try {
-        const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        const text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
         return { uri, mimeType: mimeTypeFor(path), text };
     }
     catch {

package/dist/lib/skillProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Resource, ReadResourceResult, Tool, CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { Resource, ReadResourceResult, Tool, CallToolResult } from "@modelcontextprotocol/server";
 import type { RuntimeContext, TrellisProvider } from "./mcpRuntime.js";
 import { type SkillEntry } from "./skillManifest.js";
 export declare class SkillProvider implements TrellisProvider {

package/dist/lib/taskProvider.d.ts

@@ -1,4 +1,4 @@
-import type { CallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { CallToolResult, Tool } from "@modelcontextprotocol/server";
 import type { RuntimeContext, TrellisProvider } from "./mcpRuntime.js";
 export declare class TaskProvider implements TrellisProvider {
     readonly id = "tasks";

package/dist/lib/upstreamResources.d.ts

@@ -0,0 +1,23 @@
+import type { Client, Resource, ReadResourceResult } from "@modelcontextprotocol/client";
+import { type SkillEntry } from "./skillManifest.js";
+/** The outer response belongs to the gateway; upstream identity is provenance. */
+export declare function withoutUpstreamServerInfo<T extends {
+    _meta?: Record<string, unknown>;
+}>(result: T): T;
+/** Retain path segments so relative supporting-file references remain valid. */
+export declare function upstreamUri(source: string, uri: string): string;
+export declare class UpstreamResources {
+    private readonly timeoutMs;
+    private readonly warn;
+    private readonly clients;
+    private readonly files;
+    constructor(timeoutMs: number, warn: (message: string) => void);
+    add(source: string, client: Client): void;
+    private skillsEnabled;
+    private isolated;
+    listResources(): Promise<Resource[]>;
+    private registerSkill;
+    listSkills(): Promise<SkillEntry[]>;
+    getSkill(uri: string): Promise<SkillEntry | undefined>;
+    readResource(uri: string): Promise<ReadResourceResult>;
+}