holon-sh 0.0.1-dev.16 → 0.0.1-dev.17

package/dist/runtime.js

@@ -1,16 +1,10 @@
-import { Client, isInputRequiredResult, SdkHttpError, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
+import { isInputRequiredResult } from "@modelcontextprotocol/client";
 import { AjvJsonSchemaValidator } from "@modelcontextprotocol/client/validators/ajv";
-import { EXTENSION } from "./ext/files.js";
-import { acceptUploadRequests, downloads, isUploadRequest, prepare, upload } from "./ext/files.client.js";
+import { events } from "./ext/events.client.js";
+import { downloads, isUploadRequest, prepare, upload } from "./ext/files.client.js";
+import { createLink, environment, patient, sleep, untilAborted } from "./link.js";
 import { ToolCallError } from "./protocol.js";
 export { ToolCallError } from "./protocol.js";
-// Environment-bound calls reuse the last server/discover result for the same endpoint and token instead of discovering
-// the server on every call. A dependency keeps only its latest result, so a changed endpoint or token replaces it.
-const DISCOVERY = Symbol("discovery");
-const discovered = new Map();
-const LEGACY_VERDICT_MS = 10 * 60 * 1000;
-// Object methods JavaScript calls implicitly; tools with these names stay reachable through callTool.
-const reserved = new Set(["then", "toJSON", "toString", "valueOf", "toLocaleString"]);
 // The MCP client's own Ajv, one engine per schema so contracts that reuse an $id stay apart. Contracts are module
 // constants, so each schema compiles once however often createApps runs.
 const checks = new WeakMap();
@@ -27,53 +21,6 @@ function defaultValidator(schema) {
     checks.set(schema, check);
     return check;
 }
-function environment(name) {
-    const prefix = `${name.toUpperCase().replaceAll("-", "_")}_MCP_`;
-    const endpoint = process.env[`${prefix}URL`];
-    // Environment-bound dependencies connect for one call at a time, sending <NAME>_MCP_TOKEN as the bearer token when it is set.
-    const token = process.env[`${prefix}TOKEN`];
-    if (endpoint)
-        return { endpoint, scoped: true, [DISCOVERY]: `${endpoint} ${token ?? ""}`, ...(token && { authProvider: { token: async () => token } }) };
-    throw new Error(`Dependency ${name} is unavailable (${prefix}URL). Provide a binding or set the environment variable.`);
-}
-function validate(check, value, label) {
-    if (!check(value))
-        throw new Error(`Invalid ${label}: ${JSON.stringify(check.errors)}`);
-}
-function sleep(milliseconds, signal) {
-    return new Promise(resolve => {
-        const done = () => {
-            clearTimeout(timer);
-            signal?.removeEventListener("abort", done);
-            resolve();
-        };
-        const timer = setTimeout(done, milliseconds);
-        signal?.addEventListener("abort", done, { once: true });
-    });
-}
-function untilAborted(promise, signal) {
-    if (!signal)
-        return promise;
-    return new Promise((resolve, reject) => {
-        const aborted = () => reject(signal.reason);
-        signal.addEventListener("abort", aborted, { once: true });
-        promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", aborted));
-    });
-}
-// The MCP client ends a request after 60 s unless given a timeout. A request without one waits as long as a timer can
-// (2^31 - 1 ms, about 24.8 days). A request with one asks for progress, and progress restarts its timeout.
-function patient(options) {
-    return options?.timeout === undefined
-        ? { ...options, timeout: 2 ** 31 - 1 }
-        : { onprogress: () => { }, resetTimeoutOnProgress: true, ...options };
-}
-// Requests outside the core protocol are checked by their callers.
-const anything = { "~standard": { version: 1, vendor: "holon-sh", validate: (value) => ({ value: (value ?? {}) }) } };
-// A stream that has said nothing for twice the longest heartbeat interval is dead: https://github.com/modelcontextprotocol/experimental-ext-triggers-events/blob/main/docs/design-sketch-proposal.md#lifecycle
-const QUIET = 60_000;
-// A server's refusal ends a subscription: a client error, or an answer that the event type is gone, that access was
-// lost, or that the request is no longer valid. Anything else is tried again from the cursor.
-const refused = (error) => error?.status >= 400 && error.status < 500 || error?.data?.status >= 400 && error.data.status < 500 || [-32602, -32023, -32024, -32026].includes(error?.code);
 /** Construct only the explicitly bound dependencies. Unknown names throw; an empty binding map selects none. Used by generated createApps factories. */
 export function bindApps(identity, contracts, bindings, options) {
     const selected = Object.fromEntries(Object.keys(bindings).map((name) => {
@@ -86,375 +33,148 @@ export function bindApps(identity, contracts, bindings, options) {
 /** Construct runtime clients from identity and contracts. Connections open lazily. Explicit and resolved endpoint bindings reuse one session unless scoped is true; <NAME>_MCP_URL bindings use one session per call. Close persistent clients on shutdown. Most callers use the generated clients. */
 export function createApps(identity, contracts, bindings, options) {
     const { validator = defaultValidator, resolve = environment, session: hosted } = options ?? {};
+    const expect = (schema, label) => {
+        let check;
+        return value => {
+            check ??= validator(schema);
+            if (!check(value))
+                throw new Error(`Invalid ${label}: ${JSON.stringify(check.errors)}`);
+        };
+    };
     const apps = Object.create(null);
     // Without explicit bindings, every declared dependency gets a client; those without a contract are untyped.
     const members = { ...(bindings ? {} : Object.fromEntries(Object.keys(identity.requires ?? {}).map(name => [name, null]))), ...contracts };
     for (const [name, contract] of Object.entries(members)) {
         const binding = bindings?.[name];
-        // Without explicit bindings, the resolve hook supplies the binding on every call.
-        const current = () => binding ?? (bindings ? undefined : resolve(name));
-        let connection;
-        const connect = (resolved, prior) => {
-            // Every client can be asked: a call answers with elicit, or the question reaches its caller. Servers must not assume a client answers: https://modelcontextprotocol.io/specification/2026-07-28/basic/patterns/mrtr#server-requirements-basic-workflow
-            // On 2026-07-28 the client sends these capabilities in every request's _meta: https://github.com/modelcontextprotocol/typescript-sdk/blob/fcef852f6cdafea07f36cf6fae69b37c8adf85be/packages/client/src/client/client.ts#L700-L711
-            const client = new Client({ name: identity.name, version: identity.version }, { capabilities: { elicitation: { form: {}, url: {} }, extensions: { [EXTENSION]: { upload: {}, download: {} } } }, versionNegotiation: { mode: "auto" } });
-            const endpoint = new URL(resolved.endpoint);
-            const transport = acceptUploadRequests(new StreamableHTTPClientTransport(endpoint, { authProvider: resolved.authProvider, fetch: async (input, init) => {
-                    if (String(input) === endpoint.href)
-                        current.authorization = new Headers(init?.headers).get("authorization") ?? undefined;
-                    const response = await (resolved.fetch ?? fetch)(input, init);
-                    current.answered ||= response.ok;
-                    return response;
-                }, requestInit: { credentials: "include", redirect: "error", headers: resolved.installationUID ? { "X-Holon-Installation-UID": resolved.installationUID } : {} } }));
-            transport.onclose = () => { if (connection === current)
-                connection = undefined; };
-            const ready = client.connect(transport, { prior }).catch(async (error) => {
-                await transport.close();
-                throw error;
+        const link = createLink(identity, name, { binding, resolve: bindings ? undefined : resolve, host: binding ? hosted?.(name, binding) : undefined });
+        apps[name] = Object.freeze({ ...tools(link, contract, expect), resources: resources(link, contract, expect), ext: Object.freeze({ events: events(link, contract, expect) }), close: link.close });
+    }
+    return Object.freeze(apps);
+}
+// Object methods JavaScript calls implicitly; tools with these names stay reachable through callTool.
+const reserved = new Set(["then", "toJSON", "toString", "valueOf", "toLocaleString"]);
+function tools(link, contract, expect) {
+    const { name } = link;
+    const definitions = new Map((contract?.tools ?? []).map(definition => [definition.name, { definition, output: definition.outputSchema && expect(definition.outputSchema, `structured output from ${name}.${definition.name}`) }]));
+    const callTool = async (request, { elicit, ...options } = {}) => {
+        const tool = definitions.get(request.name);
+        if (!tool && contract)
+            throw new Error(`Unknown tool ${name}.${request.name}.`);
+        // A contract's tool is the tool as its server listed it.
+        const sent = { ...patient(options), allowInputRequired: true, ...(tool && { toolDefinition: { ...tool.definition, outputSchema: undefined } }) };
+        const label = `${name}.${request.name}`;
+        const result = await link.session(options, async (client, connection) => {
+            const { arguments: args, files } = await prepare(request.arguments, {
+                label, connection,
+                schema: async () => tool?.definition.inputSchema ?? (await client.listTools(undefined, patient(options))).tools.find(({ name }) => name === request.name)?.inputSchema,
             });
-            const current = { client, resolved, ready, answered: false, close: async () => {
-                    await transport.terminateSession().catch(() => { });
-                    await transport.close();
-                    await ready.catch(() => { });
-                } };
-            return current;
-        };
-        // The session hook serves bindings the runtime does not connect to itself.
-        const host = binding ? hosted?.(name, binding) : undefined;
-        const session = async (options, run) => {
-            options?.signal?.throwIfAborted();
-            if (host)
-                return run(host);
-            const resolved = current();
-            if (!resolved?.endpoint)
-                throw new Error(`Dependency ${name} is unavailable. Provide a binding.`);
-            // Bindings marked scoped connect for one call at a time.
-            const scoped = resolved.scoped === true;
-            const key = resolved[DISCOVERY];
-            const cached = discovered.get(name);
-            const prior = key !== undefined && cached?.key === key && Date.now() < cached.expires ? cached.prior : undefined;
-            const active = scoped ? connect(resolved, prior) : (connection ??= connect(resolved));
-            try {
-                await untilAborted(active.ready, options?.signal);
-                if (key !== undefined && !prior) {
-                    const discover = active.client.getDiscoverResult();
-                    discovered.set(name, { key, prior: discover ? { kind: "modern", discover } : { kind: "legacy" }, expires: discover ? Infinity : Date.now() + LEGACY_VERDICT_MS });
+            // The SDK's request type leaves out the continuation fields the protocol carries.
+            let next = files.size ? { ...request, arguments: args } : request;
+            let uploaded = false;
+            for (let round = 0;;) {
+                let result;
+                try {
+                    result = await client.callTool(next, sent);
                 }
-                return await run(active.client, active);
-            }
-            catch (error) {
-                // A server that no longer speaks the discovered protocol rejects the first request without running it.
-                if (!prior || active.answered || !(SdkHttpError.isInstance(error) && error.status === 400))
-                    throw error;
-                discovered.delete(name);
-                return session(options, run);
-            }
-            finally {
-                if (scoped)
-                    await active.close();
-            }
-        };
-        const tools = Object.create(null);
-        const definitions = new Map((contract?.tools ?? []).map(definition => [definition.name, { definition }]));
-        const callTool = async (request, { elicit, ...options } = {}) => {
-            const tool = definitions.get(request.name);
-            if (!tool && contract)
-                throw new Error(`Unknown tool ${name}.${request.name}.`);
-            // A contract's tool is the tool as its server listed it.
-            const sent = { ...patient(options), allowInputRequired: true, ...(tool && { toolDefinition: { ...tool.definition, outputSchema: undefined } }) };
-            const label = `${name}.${request.name}`;
-            const result = await session(options, async (client, connection) => {
-                const { arguments: args, files } = await prepare(request.arguments, {
-                    label, connection,
-                    schema: async () => tool?.definition.inputSchema ?? (await client.listTools(undefined, patient(options))).tools.find(({ name }) => name === request.name)?.inputSchema,
-                });
-                // The SDK's request type leaves out the continuation fields the protocol carries.
-                let next = files.size ? { ...request, arguments: args } : request;
-                let uploaded = false;
-                for (let round = 0;;) {
-                    let result;
-                    try {
-                        result = await client.callTool(next, sent);
-                    }
-                    catch (error) {
-                        if (connection && isUploadRequest(error)) {
-                            if (uploaded)
-                                throw new Error(`${label}: the server asked for a second upload; the tool did not run.`);
-                            const requestState = await upload(error.data, files, connection, options.signal, label);
-                            uploaded = true;
-                            const { inputResponses, ...retry } = next;
-                            next = { ...retry, requestState };
-                            continue;
-                        }
+                catch (error) {
+                    if (connection && isUploadRequest(error)) {
                         if (uploaded)
-                            throw new Error(`${label}: the outcome is unknown; the tool may have run (${error?.message ?? error}).`, { cause: error });
-                        throw error;
-                    }
-                    // A server may keep asking, so answering stops after ten rounds, the MCP clients' own limit, and the last question reaches the caller.
-                    if (!elicit || !isInputRequiredResult(result) || round++ === 10)
-                        return connection ? downloads(result, connection) : result;
-                    const inputResponses = {};
-                    for (const [key, question] of Object.entries(result.inputRequests ?? {})) {
-                        // Every client declares elicitation alone, so it answers nothing else and such a question reaches the caller.
-                        if (question.method !== "elicitation/create")
-                            return result;
-                        inputResponses[key] = await elicit(question.params);
+                            throw new Error(`${label}: the server asked for a second upload; the tool did not run.`);
+                        const requestState = await upload(error.data, files, connection, options.signal, label);
+                        uploaded = true;
+                        const { inputResponses, ...retry } = next;
+                        next = { ...retry, requestState };
+                        continue;
                     }
-                    next = { ...next, inputResponses, requestState: result.requestState };
+                    if (uploaded)
+                        throw new Error(`${label}: the outcome is unknown; the tool may have run (${error?.message ?? error}).`, { cause: error });
+                    throw error;
                 }
-            });
-            if (isInputRequiredResult(result))
-                return result;
-            // The server validates arguments; the client checks the output against the contract it was compiled against.
-            if (!result.isError && tool?.definition.outputSchema) {
-                validate(tool.output ??= validator(tool.definition.outputSchema), result.structuredContent, `structured output from ${name}.${request.name}`);
-            }
-            // isError tells ToolResult's success variant from its error variant.
-            return { ...result, resultType: "complete" };
-        };
-        const listTools = (options) => session(options, client => client.listTools(undefined, patient(options)));
-        for (const tool of contract?.tools ?? [])
-            if (!reserved.has(tool.name)) {
-                tools[tool.name] = async (input, options) => {
-                    const result = await callTool({ name: tool.name, arguments: input }, options);
-                    if (result.resultType === "input_required" || result.isError)
-                        throw new ToolCallError(name, tool.name, result);
-                    return tool.outputSchema ? result.structuredContent : result;
-                };
-            }
-        const resources = Object.create(null);
-        for (const resource of contract?.resources ?? []) {
-            let valid;
-            const parse = (result) => {
-                // Contracted resources are JSON in their first text content.
-                const [content] = result.contents;
-                if (!content || !("text" in content))
-                    throw new Error(`Invalid contents from ${name} ${resource.uri}: no text content`);
-                const value = JSON.parse(content.text);
-                valid ??= validator(resource.outputSchema);
-                validate(valid, value, `contents from ${name} ${resource.uri}`);
-                return value;
-            };
-            const read = async (options) => parse(await session(options, client => client.readResource({ uri: resource.uri }, patient(options))));
-            const watch = async (onChange, { signal } = {}) => {
-                const resolved = current();
-                if (!resolved?.endpoint)
-                    throw new Error(`Watching ${name} ${resource.uri} requires an endpoint binding.`);
-                // An abort ends the wait between attempts early instead of failing it.
-                for (let established = false; !signal?.aborted; await sleep(1000, signal)) {
-                    const current = connect(resolved);
-                    let failure;
-                    try {
-                        await untilAborted(current.ready, signal);
-                        const { client } = current;
-                        if (!client.getServerCapabilities()?.resources?.subscribe)
-                            throw new Error(`${name} does not advertise resource subscriptions.`);
-                        let reads = Promise.resolve();
-                        const refresh = () => (reads = reads.then(async () => onChange(parse(await client.readResource({ uri: resource.uri }, patient({ signal, cacheMode: "bypass" })))))
-                            .catch(error => { failure ??= error; return current.close(); }));
-                        client.setNotificationHandler("notifications/resources/updated", ({ params }) => { if (params.uri === resource.uri)
-                            void refresh(); });
-                        const subscription = await client.listen({ resourceSubscriptions: [resource.uri] }, { signal });
-                        if (!subscription.honoredFilter.resourceSubscriptions?.includes(resource.uri))
-                            throw new Error(`${name} did not accept a subscription to ${resource.uri}.`);
-                        established = true;
-                        await refresh();
-                        await subscription.closed;
-                    }
-                    catch (error) {
-                        failure ??= error;
-                    }
-                    finally {
-                        await current.close();
-                    }
-                    if (signal?.aborted)
-                        return;
-                    if (failure && !established)
-                        throw failure;
+                // A server may keep asking, so answering stops after ten rounds, the MCP clients' own limit, and the last question reaches the caller.
+                if (!elicit || !isInputRequiredResult(result) || round++ === 10)
+                    return connection ? downloads(result, connection) : result;
+                const inputResponses = {};
+                for (const [key, question] of Object.entries(result.inputRequests ?? {})) {
+                    // Every client declares elicitation alone, so it answers nothing else and such a question reaches the caller.
+                    if (question.method !== "elicitation/create")
+                        return result;
+                    inputResponses[key] = await elicit(question.params);
                 }
-            };
-            resources[resource.uri] = Object.freeze({ read, watch });
-        }
-        // MCP Events, the draft extension: https://github.com/modelcontextprotocol/experimental-ext-triggers-events/blob/main/docs/design-sketch-proposal.md
-        // Its requests go over the runtime's own connection, which a hosted session does not have.
-        const connected = (options, run) => session(options, (_, connection) => {
-            if (!connection)
-                throw new Error(`MCP Events of ${name} require an endpoint binding.`);
-            return run(connection.client);
-        });
-        const list = (options) => connected(options, async (client) => {
-            const events = [];
-            for (let cursor;;) {
-                const page = await client.request({ method: "events/list", params: { ...(cursor && { cursor }) } }, anything, patient(options));
-                events.push(...page.events ?? []);
-                if (!(cursor = page.nextCursor))
-                    return events;
+                next = { ...next, inputResponses, requestState: result.requestState };
             }
         });
-        const subscribe = async (event, args = {}, { signal, onGap, maxAgeMs, ...options } = {}) => {
-            const resolved = current();
-            if (!resolved?.endpoint)
-                throw new Error(`Subscribing to ${name} ${event} requires an endpoint binding.`);
-            const offered = (await list(signal && { signal })).find(type => type.name === event)?.delivery;
-            if (!offered)
-                throw new Error(`${name} has no event ${event}.`);
-            // Push hears of an event at once, and poll works wherever a request does. Webhook delivery is not supported.
-            const delivery = options.delivery ?? ["push", "poll"].find(mode => offered.includes(mode));
-            // The sketch's NoCompatibleDeliveryMode: none of the modes the server offers is one this client uses.
-            if (!delivery || !offered.includes(delivery))
-                throw Object.assign(new Error(`${name} does not deliver ${event} by ${delivery ?? "poll or push"}.`), { name: "NoCompatibleDeliveryMode" });
-            const cancelled = new AbortController();
-            const ended = signal ? AbortSignal.any([signal, cancelled.signal]) : cancelled.signal;
-            let cursor = options.cursor ?? null;
-            const queue = [];
-            const seen = new Set();
-            let wake = () => { };
-            let done = false;
-            let failure;
-            // An absent cursor is a null one, and a null one is never resumed from.
-            const reach = (next, truncated) => {
-                cursor = next ?? null;
-                if (truncated)
-                    onGap?.();
-            };
-            // The client checks an event's data against the contract it was compiled against, as it does a tool's output.
-            const expected = contract?.events?.find(type => type.name === event)?.payloadSchema;
-            let valid;
-            const deliver = ({ cursor: _, _meta, ...occurrence }) => {
-                if (seen.has(occurrence.eventId))
-                    return;
-                seen.add(occurrence.eventId);
-                if (seen.size > 1024)
-                    seen.delete(seen.values().next().value);
-                if (expected)
-                    validate(valid ??= validator(expected), occurrence.data, `data of ${name} ${event}`);
-                queue.push(occurrence);
-                wake();
+        if (isInputRequiredResult(result))
+            return result;
+        if (!result.isError)
+            tool?.output?.(result.structuredContent);
+        // isError tells ToolResult's success variant from its error variant.
+        return { ...result, resultType: "complete" };
+    };
+    const listTools = (options) => link.session(options, client => client.listTools(undefined, patient(options)));
+    const tools = Object.create(null);
+    for (const tool of contract?.tools ?? [])
+        if (!reserved.has(tool.name)) {
+            tools[tool.name] = async (input, options) => {
+                const result = await callTool({ name: tool.name, arguments: input }, options);
+                if (result.resultType === "input_required" || result.isError)
+                    throw new ToolCallError(name, tool.name, result);
+                return tool.outputSchema ? result.structuredContent : result;
             };
-            const request = { name: event, arguments: args, ...(maxAgeMs !== undefined && { maxAgeMs }) };
-            let confirmed = false;
-            const established = Promise.withResolvers();
-            const confirm = () => { confirmed = true; established.resolve(); };
-            const poll = async () => {
-                while (!ended.aborted) {
-                    let wait = 1000;
-                    try {
-                        const result = await connected({ signal: ended }, client => client.request({ method: "events/poll", params: { ...request, cursor } }, anything, patient({ signal: ended })));
-                        try {
-                            for (const occurrence of result.events ?? [])
-                                deliver(occurrence);
-                        }
-                        catch (error) {
-                            failure = error;
-                            return cancelled.abort();
-                        }
-                        reach(result.cursor, result.truncated);
-                        confirm();
-                        // A server that asks for a tight loop is not obeyed.
-                        wait = result.hasMore ? 0 : Math.max(1000, result.nextPollMs ?? 0);
-                    }
-                    catch (error) {
-                        if (ended.aborted)
-                            return;
-                        if (!confirmed || refused(error))
-                            throw error;
-                    }
-                    await sleep(wait, ended);
+        }
+    // Generated clients narrow callTool to their contract's tools and outputs, which validation upholds.
+    return { callTool: callTool, listTools, tools: Object.freeze(tools) };
+}
+function resources(link, contract, expect) {
+    const { name } = link;
+    const resources = Object.create(null);
+    for (const resource of contract?.resources ?? []) {
+        const check = expect(resource.outputSchema, `contents from ${name} ${resource.uri}`);
+        const parse = (result) => {
+            const [content] = result.contents;
+            if (!content || !("text" in content))
+                throw new Error(`Invalid contents from ${name} ${resource.uri}: no text content`);
+            const value = JSON.parse(content.text);
+            check(value);
+            return value;
+        };
+        const read = async (options) => parse(await link.session(options, client => client.readResource({ uri: resource.uri }, patient(options))));
+        const watch = async (onChange, { signal } = {}) => {
+            const resolved = link.endpoint(`Watching ${name} ${resource.uri}`);
+            // An abort ends the wait between attempts early instead of failing it.
+            for (let established = false; !signal?.aborted; await sleep(1000, signal)) {
+                const current = link.connect(resolved);
+                let failure;
+                try {
+                    await untilAborted(current.ready, signal);
+                    const { client } = current;
+                    if (!client.getServerCapabilities()?.resources?.subscribe)
+                        throw new Error(`${name} does not advertise resource subscriptions.`);
+                    let reads = Promise.resolve();
+                    const refresh = () => (reads = reads.then(async () => onChange(parse(await client.readResource({ uri: resource.uri }, patient({ signal, cacheMode: "bypass" })))))
+                        .catch(error => { failure ??= error; return current.close(); }));
+                    client.setNotificationHandler("notifications/resources/updated", ({ params }) => { if (params.uri === resource.uri)
+                        void refresh(); });
+                    const subscription = await client.listen({ resourceSubscriptions: [resource.uri] }, { signal });
+                    if (!subscription.honoredFilter.resourceSubscriptions?.includes(resource.uri))
+                        throw new Error(`${name} did not accept a subscription to ${resource.uri}.`);
+                    established = true;
+                    await refresh();
+                    await subscription.closed;
                 }
-            };
-            const stream = async () => {
-                while (!ended.aborted) {
-                    let wait = 1000;
-                    const quiet = new AbortController();
-                    // The MCP client keeps waiting for the answer of a request whose stream has ended, so the end is watched for here.
-                    // Only the stream's own response is watched: a 2025 server answers its initialization as a stream too.
-                    const watched = async (input, init) => {
-                        const response = await (resolved.fetch ?? fetch)(input, init);
-                        const streaming = typeof init?.body === "string" && init.body.includes('"method":"events/stream"');
-                        if (!streaming || !response.body || !response.headers.get("content-type")?.startsWith("text/event-stream"))
-                            return response;
-                        const reader = response.body.getReader();
-                        const body = new ReadableStream({
-                            pull: controller => reader.read().then(({ done, value }) => {
-                                if (!done)
-                                    return controller.enqueue(value);
-                                controller.close();
-                                // The answer, when the stream ended with one, is handled first.
-                                setTimeout(() => quiet.abort());
-                            }, error => { controller.error(error); quiet.abort(); }),
-                            cancel: reason => reader.cancel(reason),
-                        });
-                        return new Response(body, response);
-                    };
-                    // Each stream has its own connection, so every event notification on it is this subscription's.
-                    const connection = connect({ ...resolved, fetch: watched });
-                    let timer;
-                    const heard = () => {
-                        clearTimeout(timer);
-                        timer = setTimeout(() => quiet.abort(), QUIET);
-                    };
-                    let terminated;
-                    try {
-                        await untilAborted(connection.ready, ended);
-                        const on = (method, handle) => connection.client.setNotificationHandler(`notifications/events/${method}`, { params: anything }, params => { heard(); handle(params); });
-                        on("active", ({ cursor: next, truncated }) => { reach(next, truncated); confirm(); });
-                        on("event", occurrence => {
-                            wait = 0;
-                            try {
-                                deliver(occurrence);
-                            }
-                            catch (error) {
-                                failure = error;
-                                return cancelled.abort();
-                            }
-                            reach(occurrence.cursor);
-                        });
-                        on("heartbeat", ({ cursor: next }) => reach(next));
-                        // The server recovers from an error by itself, and the stream stays open.
-                        on("error", () => { });
-                        on("terminated", ({ error }) => { terminated = error; quiet.abort(); });
-                        heard();
-                        await connection.client.request({ method: "events/stream", params: { ...request, cursor } }, anything, { signal: AbortSignal.any([ended, quiet.signal]), timeout: 2 ** 31 - 1 });
-                    }
-                    catch (error) {
-                        if (!terminated && !ended.aborted && (!confirmed || refused(error)))
-                            throw error;
-                    }
-                    finally {
-                        clearTimeout(timer);
-                        await connection.close();
-                    }
-                    if (terminated)
-                        throw Object.assign(new Error(`${name} ended the subscription to ${event}: ${terminated.message}`), { code: terminated.code, data: terminated.data });
-                    await sleep(wait, ended);
+                catch (error) {
+                    failure ??= error;
                 }
-            };
-            void (delivery === "push" ? stream() : poll())
-                .catch(error => { failure ??= error; })
-                .finally(() => { done = true; wake(); established.reject(failure ?? ended.reason); });
-            await established.promise;
-            return {
-                delivery,
-                get cursor() { return cursor; },
-                cancel: () => cancelled.abort(),
-                [Symbol.asyncIterator]: () => ({
-                    next: async () => {
-                        while (!queue.length && !done)
-                            await new Promise(resolve => { wake = resolve; });
-                        const value = queue.shift();
-                        if (value)
-                            return { value, done: false };
-                        if (failure)
-                            throw failure;
-                        return { value: undefined, done: true };
-                    },
-                    return: async () => { cancelled.abort(); return { value: undefined, done: true }; },
-                }),
-            };
+                finally {
+                    await current.close();
+                }
+                if (signal?.aborted)
+                    return;
+                if (failure && !established)
+                    throw failure;
+            }
         };
-        // Generated clients narrow callTool to their contract's tools and outputs, which validation upholds.
-        apps[name] = Object.freeze({ callTool: callTool, listTools, ext: Object.freeze({ events: Object.freeze({ list, subscribe: subscribe }) }), resources: Object.freeze(resources), close: async () => { await connection?.close(); }, tools: Object.freeze(tools) });
+        resources[resource.uri] = Object.freeze({ read, watch });
     }
-    return Object.freeze(apps);
+    return Object.freeze(resources);
 }
 //# sourceMappingURL=runtime.js.map