@acid-cat/core-ts 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,610 +1,8 @@
-// src/app.ts
-import { canonicalText } from "@acid-cat/catalog";
-var defineCapability = (capability) => capability;
-var capabilitiesFor = () => (capability) => capability;
-var defineApp = (app) => app;
-function catalogOf(app, options) {
-  const types = {};
-  const toJson = (schema, where) => {
-    const { $schema: _, $defs, ...json2 } = options.toJsonSchema(schema);
-    for (const [name, definition] of Object.entries($defs ?? {})) {
-      const existing = types[name];
-      if (existing !== void 0 && JSON.stringify(existing) !== JSON.stringify(definition)) {
-        throw new Error(`${where}: two different schemas have the name ${name}. Give each one its own name.`);
-      }
-      types[name] = definition;
-    }
-    return json2;
-  };
-  const capabilities = {};
-  for (const capability of app.capabilities) {
-    if (capability.id in capabilities) throw new Error(`The capability ${capability.id} is declared two times.`);
-    const failures = Object.fromEntries(
-      Object.entries(capability.failures ?? {}).map(([tag, schema]) => [tag, toJson(schema, capability.id)])
-    );
-    capabilities[capability.id] = {
-      description: capability.description,
-      audience: capability.audience,
-      ...capability.input === void 0 ? {} : { input: toJson(capability.input, capability.id) },
-      ...capability.output === void 0 ? {} : { output: toJson(capability.output, capability.id) },
-      ...Object.keys(failures).length === 0 ? {} : { failures },
-      ...capability.readOnly === true ? { readOnly: true } : {},
-      ...capability.state === void 0 ? {} : { state: toJson(capability.state.schema, capability.id) }
-    };
-  }
-  return {
-    acidcat: "0.1",
-    ...app.title === void 0 ? {} : { title: app.title },
-    ...app.description === void 0 ? {} : { description: app.description },
-    targets: Object.fromEntries(
-      Object.entries(app.targets).map(([name, target]) => [
-        name,
-        {
-          bindings: target.bindings,
-          ...target.description === void 0 ? {} : { description: target.description },
-          ...target.options === void 0 ? {} : { options: target.options }
-        }
-      ])
-    ),
-    ...Object.keys(types).length === 0 ? {} : { $defs: types },
-    capabilities
-  };
-}
-var renderCatalog = (app, options) => canonicalText(catalogOf(app, options));
-
-// src/session.ts
-import { AVAILABLE, CallFailureError, callFailure, isCallFailure, viewOf } from "@acid-cat/spec-ts";
-var always = { getSnapshot: () => AVAILABLE, subscribe: () => ({ unsubscribe() {
-} }) };
-function createSession(app, options) {
-  const view = viewOf(catalogOf(app, { toJsonSchema: options.toJsonSchema }), options.target);
-  const lifetime = new AbortController();
-  const running = /* @__PURE__ */ new Set();
-  const listeners = /* @__PURE__ */ new Set();
-  const subscriptions = [];
-  const onDefect = options.onDefect ?? ((id, cause) => console.error(`A capability failed with a defect: ${id}`, cause));
-  const served = /* @__PURE__ */ new Map();
-  for (const capability of app.capabilities) {
-    if (!(capability.id in view.capabilities)) continue;
-    const availability = capability.availability?.(options.context) ?? always;
-    subscriptions.push(availability.subscribe(() => listeners.forEach((listener) => listener())));
-    served.set(capability.id, { capability, availability });
-  }
-  async function call(id, input, trusted, signal) {
-    if (lifetime.signal.aborted || signal?.aborted) return callFailure("cancelled", "The call was cancelled.");
-    const entry = served.get(id);
-    if (entry === void 0) return callFailure("unknown-capability", `There is no capability ${id}.`);
-    const availability = entry.availability.getSnapshot();
-    if (!availability.available) return callFailure("unavailable", availability.reason);
-    const { capability } = entry;
-    let decoded = input ?? {};
-    if (!trusted && capability.input !== void 0) {
-      const validated = await capability.input["~standard"].validate(input);
-      if (validated.issues !== void 0) {
-        const message = validated.issues.map((issue) => `${(issue.path ?? []).map((key) => typeof key === "object" ? String(key.key) : String(key)).join(".") || "input"}: ${issue.message}`).join("; ");
-        return callFailure("invalid-input", message);
-      }
-      decoded = validated.value;
-    }
-    const controller = new AbortController();
-    const abort = () => controller.abort();
-    lifetime.signal.addEventListener("abort", abort);
-    signal?.addEventListener("abort", abort);
-    const cancelled = new Promise(
-      (resolve2) => controller.signal.addEventListener("abort", () => resolve2(callFailure("cancelled", "The call was cancelled.")))
-    );
-    if (lifetime.signal.aborted || signal?.aborted) controller.abort();
-    const work = Promise.resolve().then(() => capability.run(decoded, { signal: controller.signal, context: options.context })).then((result) => checkResult(capability, result)).catch((cause) => {
-      onDefect(id, cause);
-      return callFailure("internal", "The capability failed.");
-    });
-    const outcome = Promise.race([work, cancelled]);
-    running.add(outcome);
-    try {
-      return await outcome;
-    } finally {
-      running.delete(outcome);
-      lifetime.signal.removeEventListener("abort", abort);
-      signal?.removeEventListener("abort", abort);
-    }
-  }
-  const handles = /* @__PURE__ */ new Map();
-  for (const [id, { capability, availability }] of served) {
-    const reject = async (outcome) => {
-      const settled = await outcome;
-      if (isCallFailure(settled)) throw new CallFailureError(settled);
-      return settled;
-    };
-    const state = capability.state?.source(options.context);
-    handles.set(id, {
-      id,
-      description: capability.description,
-      audience: capability.audience,
-      availability,
-      ...state === void 0 ? {} : { snapshot: detached(state) },
-      execute: (input, callOptions) => reject(call(id, input, true, callOptions?.signal)),
-      invokeExternal: (input, callOptions) => reject(call(id, input, false, callOptions?.signal))
-    });
-  }
-  return {
-    target: options.target,
-    view,
-    handles,
-    signal: lifetime.signal,
-    invoke: (id, input, callOptions) => call(id, input, false, callOptions?.signal),
-    onChange(listener) {
-      listeners.add(listener);
-      return { unsubscribe: () => listeners.delete(listener) };
-    },
-    async dispose() {
-      lifetime.abort();
-      subscriptions.forEach((subscription) => subscription.unsubscribe());
-      await Promise.allSettled([...running]);
-    }
-  };
-}
-function detached(source) {
-  return {
-    getSnapshot: () => structuredClone(source.getSnapshot()),
-    subscribe: (listener) => source.subscribe((value) => listener(structuredClone(value)))
-  };
-}
-async function checkResult(capability, result) {
-  if (result.ok) {
-    if (capability.output === void 0) return { ok: true, value: result.value ?? null };
-    const checked2 = await capability.output["~standard"].validate(result.value);
-    if (checked2.issues !== void 0) throw new Error(`The output does not agree with its schema: ${checked2.issues[0]?.message}`);
-    return { ok: true, value: checked2.value };
-  }
-  const tag = result.error._tag;
-  const schema = tag === void 0 ? void 0 : capability.failures?.[tag];
-  if (schema === void 0) throw new Error(`The failure ${String(tag)} is not in failures.`);
-  const checked = await schema["~standard"].validate(result.error);
-  if (checked.issues !== void 0) throw new Error(`The failure ${tag} does not agree with its schema: ${checked.issues[0]?.message}`);
-  return { ok: false, error: { _tag: tag, ...checked.value } };
-}
-
-// src/mcp.ts
-import { bundle, MCP_PROTOCOL_VERSION, MCP_REJECTIONS, MCP_UNKNOWN_TOOL, mcpToolResult, readBounded, screenRequest } from "@acid-cat/spec-ts";
-function mcpHandler(app, options) {
-  const maximumBytes = options.maximumBytes ?? 1048576;
-  return async (request) => {
-    const screened = screenRequest(request, {
-      methods: ["POST"],
-      allowedOrigins: options.allowedOrigins,
-      mediaType: "application/json",
-      maximumBytes
-    });
-    if (screened !== void 0) return rejection(screened);
-    const body = await readBounded(request, maximumBytes);
-    if ("rejection" in body) return rejection(body.rejection);
-    let message;
-    try {
-      message = JSON.parse(body.text);
-    } catch {
-      return rejection("not-utf8");
-    }
-    const version = request.headers.get("MCP-Protocol-Version");
-    const id = message.id ?? null;
-    if (version === null) return error(400, id, -32020, "MCP-Protocol-Version header is required");
-    if (version !== MCP_PROTOCOL_VERSION) {
-      return error(400, id, -32022, `Unsupported protocol version ${version}`, { supported: [MCP_PROTOCOL_VERSION] });
-    }
-    if (message.id === void 0) return new Response(null, { status: 200, headers: { "Content-Type": "application/json" } });
-    const metaVersion = message.params?._meta?.["io.modelcontextprotocol/protocolVersion"];
-    if (metaVersion === void 0) return error(400, id, -32602, "Required request metadata is missing");
-    if (metaVersion !== version) return error(400, id, -32020, "MCP-Protocol-Version header does not match request metadata");
-    const session = createSession(app, {
-      target: options.target ?? "mcp",
-      context: options.context,
-      toJsonSchema: options.toJsonSchema
-    });
-    try {
-      return await answer(session, message, options, request.signal);
-    } finally {
-      await session.dispose();
-    }
-  };
-}
-async function answer(session, message, options, signal) {
-  const id = message.id ?? null;
-  const complete = (result, list = false) => reply(id, {
-    _meta: { "io.modelcontextprotocol/serverInfo": { name: options.name, version: options.version } },
-    resultType: "complete",
-    ...list ? { ttlMs: 0, cacheScope: "private" } : {},
-    ...result
-  });
-  switch (message.method) {
-    case "server/discover":
-      return complete({ supportedVersions: [MCP_PROTOCOL_VERSION], capabilities: { tools: { listChanged: false } } }, true);
-    case "tools/list":
-      return complete({ tools: listTools(session) }, true);
-    case "tools/call": {
-      const name = message.params?.name ?? "";
-      const handle = session.handles.get(name);
-      if (handle === void 0 || !handle.availability.getSnapshot().available) {
-        return error(200, id, MCP_UNKNOWN_TOOL, `Tool '${name}' not found`);
-      }
-      const outcome = await session.invoke(name, message.params?.arguments ?? {}, { signal });
-      return complete(mcpToolResult(outcome, hasObjectOutput(session, name)));
-    }
-    default:
-      return error(404, id, -32601, `Method not found: ${message.method}`);
-  }
-}
-function listTools(session) {
-  const types = session.view.$defs ?? {};
-  return [...session.handles.values()].filter((handle) => handle.availability.getSnapshot().available).map((handle) => {
-    const capability = session.view.capabilities[handle.id];
-    const output = capability.output === void 0 ? void 0 : bundle(capability.output, types);
-    return {
-      name: handle.id,
-      description: capability.description,
-      inputSchema: bundle(capability.input ?? { type: "object" }, types),
-      ...output?.type === "object" ? { outputSchema: output } : {},
-      annotations: { readOnlyHint: capability.readOnly === true }
-    };
-  });
-}
-function hasObjectOutput(session, id) {
-  const output = session.view.capabilities[id]?.output;
-  return output !== void 0 && bundle(output, session.view.$defs ?? {}).type === "object";
-}
-function reply(id, result) {
-  return new Response(JSON.stringify({ jsonrpc: "2.0", id, result }), { status: 200, headers: { "Content-Type": "application/json" } });
-}
-function error(status, id, code, message, data) {
-  const body = { jsonrpc: "2.0", id, error: { code, message, ...data === void 0 ? {} : { data } } };
-  return new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
-}
-function rejection(reason) {
-  const { status, code } = MCP_REJECTIONS[reason];
-  const headers = new Headers({ "Cache-Control": "no-store" });
-  if (reason === "method") headers.set("Allow", "POST");
-  if (code === void 0) return new Response(null, { status, headers });
-  headers.set("Content-Type", "application/json");
-  return new Response(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code, message: messages[reason] } }), { status, headers });
-}
-var messages = {
-  method: "Use POST.",
-  origin: "This origin is not allowed.",
-  "media-type": "Use application/json.",
-  "too-large": "The request body is too large.",
-  "not-utf8": "The request body is not UTF-8 JSON."
-};
-
-// src/http.ts
-import { callFailure as callFailure2, httpStatus, isCallFailure as isCallFailure2, readBounded as readBounded2, screenRequest as screenRequest2 } from "@acid-cat/spec-ts";
-function httpHandler(app, options) {
-  const maximumBytes = options.maximumBytes ?? 1048576;
-  return async (request) => {
-    const screened = screenRequest2(request, {
-      methods: ["GET", "POST"],
-      allowedOrigins: options.allowedOrigins,
-      mediaType: "application/json",
-      maximumBytes
-    });
-    if (screened !== void 0) return rejection2(screened);
-    const path = new URL(request.url).pathname.slice((options.base ?? "").length);
-    const session = createSession(app, { target: options.target ?? "api", context: options.context, toJsonSchema: options.toJsonSchema });
-    try {
-      if (request.method === "GET" && path === "/capabilities") {
-        return json(
-          200,
-          [...session.handles.values()].map((handle) => ({ id: handle.id, ...handle.availability.getSnapshot() }))
-        );
-      }
-      if (request.method === "GET" && path === "/catalog" && options.serveCatalog !== false) return json(200, session.view);
-      const id = request.method === "POST" && path.startsWith("/capabilities/") ? path.slice("/capabilities/".length) : void 0;
-      if (id === void 0) return json(404, callFailure2("unknown-capability", "There is no such route."));
-      const body = await readBounded2(request, maximumBytes);
-      if ("rejection" in body) return rejection2(body.rejection);
-      let input;
-      try {
-        input = body.text === "" ? {} : JSON.parse(body.text);
-      } catch {
-        return json(422, callFailure2("invalid-input", "The request body is not JSON."));
-      }
-      const outcome = await session.invoke(decodeURIComponent(id), input, { signal: request.signal });
-      return json(httpStatus(outcome), isCallFailure2(outcome) ? { kind: outcome.kind, message: outcome.message } : outcome);
-    } finally {
-      await session.dispose();
-    }
-  };
-}
-var json = (status, body) => new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json" } });
-var statuses = {
-  method: 405,
-  origin: 403,
-  "media-type": 415,
-  "too-large": 413,
-  "not-utf8": 400
-};
-function rejection2(reason) {
-  const headers = new Headers({ "Cache-Control": "no-store" });
-  if (reason === "method") headers.set("Allow", "GET, POST");
-  return new Response(null, { status: statuses[reason], headers });
-}
-
-// src/cli.ts
-import { bundle as bundle2, CLI_EXIT_CODES, cliExitCode, commandPath, isCallFailure as isCallFailure3, REFERENCE } from "@acid-cat/spec-ts";
-var UsageError = class extends Error {
-  exitCode;
-  constructor(message, exitCode) {
-    super(message);
-    this.exitCode = exitCode;
-  }
-};
-function main(app, options) {
-  const interrupt = new AbortController();
-  process.once("SIGINT", () => interrupt.abort());
-  void runCli(app, options, process.argv.slice(2), {
-    stdout: (text) => process.stdout.write(`${text}
-`),
-    stderr: (text) => process.stderr.write(`${text}
-`),
-    signal: interrupt.signal
-  }).then((code) => {
-    process.exitCode = code;
-  });
-}
-async function runCli(app, options, args, io) {
-  const session = createSession(app, { target: options.target ?? "cli", context: options.context, toJsonSchema: options.toJsonSchema });
-  const types = session.view.$defs ?? {};
-  const commands = Object.keys(session.view.capabilities).map((id) => ({ id, path: commandPath(id) }));
-  for (const { path } of commands) {
-    if (path[0] === "call" || path[0] === "list") throw new Error(`The command ${path.join(" ")} has the same name as a command of the command line.`);
-  }
-  const print = (outcome) => {
-    if (isCallFailure3(outcome)) io.stderr(JSON.stringify({ kind: outcome.kind, message: outcome.message }));
-    else io.stdout(JSON.stringify(outcome.ok ? outcome.value : outcome.error, null, 2));
-    return cliExitCode(outcome);
-  };
-  try {
-    const [first, ...rest] = args;
-    if (first === void 0 || first === "--help" || first === "-h") {
-      io.stdout(help(options.name, commands.map(({ path }) => path.join(" "))));
-      return CLI_EXIT_CODES.value;
-    }
-    if (first === "--version" || first === "-v") {
-      io.stdout(options.version);
-      return CLI_EXIT_CODES.value;
-    }
-    if (first === "list") {
-      io.stdout(
-        JSON.stringify(
-          [...session.handles.values()].map((handle) => ({
-            id: handle.id,
-            description: handle.description,
-            ...handle.availability.getSnapshot(),
-            usage: `${options.name} ${commandPath(handle.id).join(" ")}`
-          })),
-          null,
-          2
-        )
-      );
-      return CLI_EXIT_CODES.value;
-    }
-    if (first === "call") {
-      const [id, text = "{}"] = rest;
-      if (id === void 0) throw new UsageError("Give the id of a capability.", CLI_EXIT_CODES["invalid-input"]);
-      let input;
-      try {
-        input = JSON.parse(text);
-      } catch {
-        return print({ kind: "invalid-input", message: "The input is not JSON." });
-      }
-      return print(await session.invoke(id, input, { signal: io.signal }));
-    }
-    const match = commands.filter(({ path }) => path.every((word, index) => args[index] === word)).sort((a, b) => b.path.length - a.path.length)[0];
-    if (match === void 0) throw new UsageError(`There is no command ${args.filter((arg) => !arg.startsWith("-")).join(" ")}.`, CLI_EXIT_CODES["unknown-capability"]);
-    const capability = session.view.capabilities[match.id];
-    const schema = bundle2(capability.input ?? { type: "object" }, types);
-    const flagArgs = args.slice(match.path.length);
-    if (flagArgs.includes("--help") || flagArgs.includes("-h")) {
-      io.stdout(usage(options.name, match.path, capability.description, schema));
-      return CLI_EXIT_CODES.value;
-    }
-    return print(await session.invoke(match.id, parseFlags(flagArgs, schema), { signal: io.signal }));
-  } catch (error2) {
-    if (!(error2 instanceof UsageError)) throw error2;
-    io.stderr(error2.message);
-    return error2.exitCode;
-  } finally {
-    await session.dispose();
-  }
-}
-function parseFlags(args, schema) {
-  const properties = schema.properties ?? {};
-  const definitions = schema.$defs ?? {};
-  const input = {};
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (!arg.startsWith("--")) throw new UsageError(`Unexpected argument ${arg}.`, CLI_EXIT_CODES["invalid-input"]);
-    const [name, inline] = arg.slice(2).split(/=(.*)/s, 2);
-    const property = properties[name];
-    if (property === void 0) throw new UsageError(`Unknown flag --${name}.`, CLI_EXIT_CODES["invalid-input"]);
-    const type = resolve(property, definitions);
-    if (type.type === "boolean") {
-      input[name] = inline === void 0 ? true : inline === "true";
-      continue;
-    }
-    const text = inline ?? args[index += 1];
-    if (text === void 0) throw new UsageError(`The flag --${name} needs a value.`, CLI_EXIT_CODES["invalid-input"]);
-    input[name] = valueOf(name, text, type);
-  }
-  for (const name of schema.required ?? []) {
-    if (!(name in input)) throw new UsageError(`The flag --${name} is required.`, CLI_EXIT_CODES["invalid-input"]);
-  }
-  return input;
-}
-function valueOf(name, text, type) {
-  if (Array.isArray(type.enum) && type.enum.every((value) => typeof value === "string")) {
-    if (!type.enum.includes(text)) throw new UsageError(`The flag --${name} must be one of: ${type.enum.join(", ")}.`, CLI_EXIT_CODES["invalid-input"]);
-    return text;
-  }
-  if (type.type === "integer" || type.type === "number") {
-    const number = Number(text);
-    if (text.trim() === "" || !Number.isFinite(number) || type.type === "integer" && !Number.isInteger(number)) {
-      throw new UsageError(`The flag --${name} must be a ${type.type}.`, CLI_EXIT_CODES["invalid-input"]);
-    }
-    return number;
-  }
-  if (type.type === "string") return text;
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new UsageError(`The flag --${name} must be JSON.`, CLI_EXIT_CODES["invalid-input"]);
-  }
-}
-function resolve(property, definitions) {
-  const name = typeof property.$ref === "string" ? REFERENCE.exec(property.$ref)?.[1] : void 0;
-  return name === void 0 ? property : definitions[name] ?? property;
-}
-function help(name, paths) {
-  return [
-    `Usage: ${name} <command> [flags]`,
-    "",
-    "Commands:",
-    ...paths.map((path) => `  ${path}`),
-    "  call <id> [input]",
-    "  list"
-  ].join("\n");
-}
-function usage(name, path, description, schema) {
-  const properties = Object.keys(schema.properties ?? {});
-  const required = new Set(schema.required ?? []);
-  const flags = properties.map((property) => required.has(property) ? `--${property} <value>` : `[--${property} <value>]`);
-  return [`Usage: ${name} ${[...path, ...flags].join(" ")}`, "", description].join("\n");
-}
-
-// src/webmcp.ts
-import { bundle as bundle3, CallFailureError as CallFailureError2, isCallFailure as isCallFailure4 } from "@acid-cat/spec-ts";
-function findHost() {
-  const scope = globalThis;
-  for (const candidate of [scope.document?.modelContext, scope.navigator?.modelContext]) {
-    if (typeof candidate?.registerTool === "function") return candidate;
-  }
-  return void 0;
-}
-function installWebMcp(session, options = {}) {
-  const host = options.host ?? findHost();
-  if (host === void 0) return void 0;
-  let status = { phase: "loading", message: null };
-  const listeners = /* @__PURE__ */ new Set();
-  const setStatus = (next) => {
-    status = next;
-    listeners.forEach((listener) => listener(next));
-  };
-  const lifetime = new AbortController();
-  const registered = /* @__PURE__ */ new Map();
-  const calls = /* @__PURE__ */ new Set();
-  const types = session.view.$defs ?? {};
-  let running = false;
-  let dirty = false;
-  const toolFor = (id) => {
-    const capability = session.view.capabilities[id];
-    return {
-      name: id,
-      description: capability.description,
-      inputSchema: bundle3(capability.input ?? { type: "object" }, types),
-      execute: (input, callOptions) => {
-        const signal = AbortSignal.any([lifetime.signal, ...callOptions?.signal ? [callOptions.signal] : []]);
-        const call = session.invoke(id, input, { signal }).then((outcome) => {
-          if (isCallFailure4(outcome)) throw new CallFailureError2(outcome);
-          return outcome;
-        });
-        calls.add(call);
-        void call.finally(() => calls.delete(call)).catch(() => void 0);
-        return call;
-      }
-    };
-  };
-  async function pass() {
-    const wanted = new Set([...session.handles.values()].filter((handle) => handle.availability.getSnapshot().available).map((handle) => handle.id));
-    const added = /* @__PURE__ */ new Map();
-    try {
-      for (const id of wanted) {
-        if (registered.has(id)) continue;
-        const controller = new AbortController();
-        added.set(id, controller);
-        await host.registerTool(toolFor(id), { signal: AbortSignal.any([controller.signal, lifetime.signal]) });
-      }
-    } catch (error2) {
-      for (const controller of added.values()) controller.abort();
-      throw error2;
-    }
-    for (const [id, controller] of added) registered.set(id, controller);
-    for (const [id, controller] of registered) {
-      if (!wanted.has(id)) {
-        controller.abort();
-        registered.delete(id);
-      }
-    }
-  }
-  async function reconcile() {
-    if (lifetime.signal.aborted) return;
-    if (running) {
-      dirty = true;
-      return;
-    }
-    running = true;
-    try {
-      do {
-        dirty = false;
-        setStatus({ phase: "reconciling", message: null });
-        try {
-          await pass();
-          setStatus({ phase: "ready", message: null });
-        } catch (error2) {
-          setStatus({ phase: "failed", message: error2 instanceof Error ? error2.message : "A tool could not be registered." });
-          dirty = false;
-        }
-      } while (dirty && !lifetime.signal.aborted);
-    } finally {
-      running = false;
-    }
-  }
-  const subscription = session.onChange(() => void reconcile());
-  void reconcile();
-  return {
-    status: {
-      getSnapshot: () => status,
-      subscribe(listener) {
-        listeners.add(listener);
-        return { unsubscribe: () => listeners.delete(listener) };
-      }
-    },
-    retry: () => void reconcile(),
-    async dispose() {
-      setStatus({ phase: "closing", message: null });
-      subscription.unsubscribe();
-      lifetime.abort();
-      registered.clear();
-      await Promise.allSettled([...calls]);
-      setStatus({ phase: "disposed", message: null });
-    }
-  };
-}
-
-// src/index.ts
-import { AVAILABLE as AVAILABLE2, CallFailureError as CallFailureError3, fail, ok, unavailable } from "@acid-cat/spec-ts";
-export {
-  AVAILABLE2 as AVAILABLE,
-  CallFailureError3 as CallFailureError,
-  capabilitiesFor,
-  catalogOf,
-  main as cliMain,
-  createSession,
-  defineApp,
-  defineCapability,
-  fail,
-  findHost,
-  httpHandler,
-  installWebMcp,
-  mcpHandler,
-  ok,
-  renderCatalog,
-  runCli,
-  unavailable
-};
+import { capabilitiesFor, catalogOf, defineApp, defineCapability, renderCatalog } from "./app.js";
+import { createSession } from "./session.js";
+import { mcpHandler } from "./mcp.js";
+import { httpHandler } from "./http.js";
+import { main, runCli } from "./cli.js";
+import { findHost, installWebMcp } from "./webmcp.js";
+import { AVAILABLE, CallFailureError, fail, ok, unavailable } from "@acid-cat/spec-ts";
+export { AVAILABLE, CallFailureError, capabilitiesFor, catalogOf, main as cliMain, createSession, defineApp, defineCapability, fail, findHost, httpHandler, installWebMcp, mcpHandler, ok, renderCatalog, runCli, unavailable };

package/dist/mcp.d.ts

@@ -1,15 +1,22 @@
 import type { App, ToJsonSchema } from "./app.js";
-export interface McpOptions<Context> {
+import type { ContextOption } from "./context.js";
+/** The options of `mcpHandler`. Give `context` to share one context, or `createContext` to make one for each request. */
+export type McpOptions<Context> = McpSettings & ContextOption<Context>;
+export interface McpSettings {
     readonly name: string;
     readonly version: string;
+    /**
+     * Guidance for a model about the whole server, which `server/discover` gives as `instructions`. The default is the
+     * description of the application.
+     */
+    readonly instructions?: string | undefined;
     /** The origins that can call the server. A request with no `Origin` header is accepted. */
     readonly allowedOrigins: readonly string[];
-    readonly context: Context;
     readonly toJsonSchema: ToJsonSchema;
     /** The target that the server serves. The default is `"mcp"`. */
     readonly target?: string | undefined;
     /** The maximum size of a request body, in bytes. The default is 1 MiB. */
     readonly maximumBytes?: number | undefined;
 }
-/** A web request handler for the MCP server. Each request has its own session. */
+/** A web request handler for the MCP server. Each request has its own session, and with `createContext` its own context. */
 export declare function mcpHandler<Context>(app: App<Context>, options: McpOptions<Context>): (request: Request) => Promise<Response>;