toolnexus 0.20.0 → 0.22.0

package/dist/index.d.ts

@@ -14,5 +14,13 @@ export * from "./adapters.js";
 export * from "./translate.js";
 export * from "./toolkit.js";
 export * from "./client.js";
+export * from "./store.js";
 export * from "./classifier.js";
 export * as agents from "./agents/index.js";
+export * as judge from "./judge.js";
+export * from "./batteries.js";
+export { State, context, questionMap, ask, gate, decide, applyGate, applyPolicy, answersOf, staticClassifier, Tape, DEFAULT_BANDS, type NamedQuestion, type Band, type Bands, type Answers, type Rule, type GateOutcome, type Policy, } from "./judge.js";
+export * from "./promptcache.js";
+export * from "./tooltiers.js";
+export * from "./models.js";
+export * from "./builtin_extras.js";

package/dist/index.js

@@ -14,5 +14,16 @@ export * from "./adapters.js";
 export * from "./translate.js";
 export * from "./toolkit.js";
 export * from "./client.js";
+export * from "./store.js";
 export * from "./classifier.js";
 export * as agents from "./agents/index.js";
+// Simple judgments (§8B, add-judge-adapters). `judge.noul/choice/score` are the NAMED builders
+// (the bare `noul/choice/score` above stay the §8B wire builders); the rest is also top-level.
+export * as judge from "./judge.js";
+// Judge batteries (§8B "Batteries", add-judge-batteries): eight `*Classifier` values + latestUserText.
+export * from "./batteries.js";
+export { State, context, questionMap, ask, gate, decide, applyGate, applyPolicy, answersOf, staticClassifier, Tape, DEFAULT_BANDS, } from "./judge.js";
+export * from "./promptcache.js";
+export * from "./tooltiers.js";
+export * from "./models.js";
+export * from "./builtin_extras.js";

package/dist/judge.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Simple judgments (SPEC.md §8B "Simple judgments — ask / gate", change `add-judge-adapters`).
+ * A thin layer over any `Classifier`: named question builders, a role-carrying `State`,
+ * `ask` (answers by name with bands) and `gate` / `Policy` (rules that escalate instead of
+ * deciding when unsure). The wire is unchanged — the builders produce exactly the §8B
+ * `evaluate(state, questions)` inputs.
+ *
+ * A gate never authorises; it only declines to decide.
+ */
+import { Classifier, Decision, type DecisionAnswer, type NoulCriteria, type Question, type RecordedDecision } from "./classifier.js";
+import type { Request } from "./types.js";
+/** One named question of an ordered question list. */
+export interface NamedQuestion {
+    name: string;
+    question: Question;
+}
+/** `noul` question with a name. Name the state field it judges in `instructions`. */
+export declare function noul(name: string, instructions: string, criteria?: NoulCriteria): NamedQuestion;
+/** `choice` question with a name; `options` maps option -> what picking it MEANS. */
+export declare function choice(name: string, instructions: string, options: Record<string, string>): NamedQuestion;
+/** `score` question with a name; `levels` is the ordered rubric. */
+export declare function score(name: string, instructions: string, levels: string[]): NamedQuestion;
+/** Ordered list -> the §8B questions map. A duplicate name is an error naming it. */
+export declare function questionMap(questions: readonly NamedQuestion[]): Record<string, Question>;
+/** `role` next to the data's fields; a non-object value goes under `data`. */
+export declare function State(role: string, data: unknown): Record<string, unknown>;
+/** Sugar: `{context, message, ...extra}`. */
+export declare function context(ctx: string, message: string, extra?: Record<string, unknown>): Record<string, unknown>;
+export type Band = "yes" | "no" | "uncertain";
+export interface Bands {
+    low: number;
+    high: number;
+}
+/** Default cut-points; exclusive on the confident side. */
+export declare const DEFAULT_BANDS: Readonly<Bands>;
+/** One answer from `ask`: the §8B answer plus `band` (noul) or `sure` (choice/score). */
+export type Answer = DecisionAnswer & {
+    /** noul only. */
+    band?: Band;
+    /** choice / score only. */
+    sure?: boolean;
+    /** The one number: noul probability, score value, or choice confidence. */
+    value(): number;
+    /** The picked option of a choice answer ("" otherwise). JS keeps §8B's `choice` string FIELD on a
+     * choice answer (a method of the same name would shadow it), so this is `pick()`. */
+    pick(): string;
+};
+export type Answers = Record<string, Answer>;
+/** Band / sure every answer of a decision. */
+export declare function answersOf(decision: Decision, bands?: Bands): Answers;
+/** Evaluate once; answers by name, each with a band (noul) or `sure` (choice/score). */
+export declare function ask(classifier: Classifier, state: unknown, questions: readonly NamedQuestion[], bands?: Bands): Promise<Answers>;
+export interface Rule {
+    question: string;
+    below?: number;
+    at_least?: number;
+    is?: string;
+    action: string;
+    target?: string;
+}
+export interface GateOutcome {
+    action: string;
+    target: string;
+    escalated: boolean;
+    /** Present iff escalated: a §10 `input` Request. */
+    request?: Request;
+    answers: Answers;
+}
+export interface Policy {
+    rules: Rule[];
+    /** The no-rule-fired action; empty escalates with reason "no rule fired". */
+    default?: string;
+    bands?: Bands;
+    /** Skip a rule whose answer is uncertain instead of escalating on it. */
+    skipUncertain?: boolean;
+}
+/** Pure half of `gate`: first-match rules; an unsure or missing answer on rule i escalates and wins. */
+export declare function applyGate(answers: Answers, rules: readonly Rule[]): GateOutcome;
+/** Pure half of a `Policy`. */
+export declare function applyPolicy(answers: Answers, policy: Policy): GateOutcome;
+/** Ask, then apply rules; no rule fired -> empty action (use a `Policy` for a declared default). */
+export declare function gate(classifier: Classifier, state: unknown, questions: readonly NamedQuestion[], rules: readonly Rule[], bands?: Bands): Promise<GateOutcome>;
+/** Ask, then apply a `Policy` (rules, default, bands, skipUncertain). */
+export declare function decide(classifier: Classifier, state: unknown, questions: readonly NamedQuestion[], policy: Policy): Promise<GateOutcome>;
+/** One-line `static` classifier from recorded decisions. */
+export declare function staticClassifier(decisions: RecordedDecision[] | RecordedDecision, model?: string): Classifier;
+/**
+ * Records live decisions keyed by a caller-given call name, and replays them with no network.
+ * `tape.classifier(name)` returns a Classifier: recording (live given) or replaying (no live).
+ */
+export declare class Tape {
+    private readonly live?;
+    readonly entries: Record<string, RecordedDecision>;
+    constructor(live?: Classifier | undefined, entries?: Record<string, RecordedDecision>);
+    /** A replay-only tape from saved entries. */
+    static replay(entries: Record<string, RecordedDecision>): Tape;
+    classifier(name: string): Classifier;
+}

package/dist/judge.js

@@ -0,0 +1,199 @@
+/**
+ * Simple judgments (SPEC.md §8B "Simple judgments — ask / gate", change `add-judge-adapters`).
+ * A thin layer over any `Classifier`: named question builders, a role-carrying `State`,
+ * `ask` (answers by name with bands) and `gate` / `Policy` (rules that escalate instead of
+ * deciding when unsure). The wire is unchanged — the builders produce exactly the §8B
+ * `evaluate(state, questions)` inputs.
+ *
+ * A gate never authorises; it only declines to decide.
+ */
+import { Classifier, noul as noulQ, choice as choiceQ, score as scoreQ, } from "./classifier.js";
+/** `noul` question with a name. Name the state field it judges in `instructions`. */
+export function noul(name, instructions, criteria) {
+    return { name, question: noulQ(instructions, criteria) };
+}
+/** `choice` question with a name; `options` maps option -> what picking it MEANS. */
+export function choice(name, instructions, options) {
+    return { name, question: choiceQ(instructions, options) };
+}
+/** `score` question with a name; `levels` is the ordered rubric. */
+export function score(name, instructions, levels) {
+    return { name, question: scoreQ(instructions, levels) };
+}
+/** Ordered list -> the §8B questions map. A duplicate name is an error naming it. */
+export function questionMap(questions) {
+    const out = {};
+    for (const { name, question } of questions) {
+        if (Object.prototype.hasOwnProperty.call(out, name))
+            throw new Error(`duplicate question name ${JSON.stringify(name)}`);
+        out[name] = question;
+    }
+    return out;
+}
+// ---------------------------------------------------------------- state
+/** `role` next to the data's fields; a non-object value goes under `data`. */
+export function State(role, data) {
+    if (data !== null && typeof data === "object" && !Array.isArray(data))
+        return { role, ...data };
+    return { role, data };
+}
+/** Sugar: `{context, message, ...extra}`. */
+export function context(ctx, message, extra = {}) {
+    return { context: ctx, message, ...extra };
+}
+/** Default cut-points; exclusive on the confident side. */
+export const DEFAULT_BANDS = Object.freeze({ low: 0.3, high: 0.7 });
+function noulBand(p, b) {
+    return p < b.low ? "no" : p > b.high ? "yes" : "uncertain";
+}
+function wrap(a, b) {
+    const extra = a.type === "noul"
+        ? { band: noulBand(a.noul, b) }
+        : { sure: a.confidence > b.high && !(a.type === "choice" && a.nearUniform) };
+    const value = () => (a.type === "noul" ? a.noul : a.type === "score" ? a.score : a.confidence);
+    const pick = () => (a.type === "choice" ? a.choice : "");
+    const out = { ...a, ...extra };
+    Object.defineProperty(out, "value", { value, enumerable: false });
+    Object.defineProperty(out, "pick", { value: pick, enumerable: false });
+    return out;
+}
+/** Band / sure every answer of a decision. */
+export function answersOf(decision, bands = DEFAULT_BANDS) {
+    return Object.fromEntries(Object.entries(decision.answers).map(([k, a]) => [k, wrap(a, bands)]));
+}
+/** Evaluate once; answers by name, each with a band (noul) or `sure` (choice/score). */
+export async function ask(classifier, state, questions, bands = DEFAULT_BANDS) {
+    return answersOf(await classifier.evaluate(state, questionMap(questions)), bands);
+}
+function unsure(a) {
+    return a.type === "noul" ? a.band === "uncertain" : !a.sure;
+}
+function escalate(answers, id, question, reason, prompt) {
+    return {
+        action: "needs_input",
+        target: "",
+        escalated: true,
+        answers,
+        request: { id, kind: "input", prompt, data: { question, reason, answers } },
+    };
+}
+function applyRules(answers, rules, skipUncertain) {
+    for (const [i, r] of rules.entries()) {
+        const a = answers[r.question];
+        if (!a || unsure(a)) {
+            if (a && skipUncertain)
+                continue;
+            const reason = `${a ? "uncertain" : "missing"} answer "${r.question}"`;
+            return escalate(answers, `gate:${i}:${r.question}`, r.question, reason, `Classifier is unsure about "${r.question}" (${reason}). Decide rule ${i} (${r.action}).`);
+        }
+        const key = JSON.stringify(r.question);
+        let fired = false;
+        let misfit = "";
+        if (r.is !== undefined) {
+            if (a.type === "choice")
+                fired = a.choice === r.is;
+            else
+                misfit = `is-rule on ${a.type} answer ${key}`;
+        }
+        else if (a.type === "choice") {
+            misfit = `numeric rule on choice answer ${key}`;
+        }
+        else {
+            const v = a.type === "noul" ? a.noul : a.score;
+            if (r.below !== undefined)
+                fired = v < r.below;
+            else if (r.at_least !== undefined)
+                fired = v >= r.at_least;
+            else
+                misfit = `rule on ${key} has no below / at_least / is`;
+        }
+        // A rule that does not fit its answer escalates; it is never skipped.
+        if (misfit)
+            return escalate(answers, `gate:${i}:${r.question}`, r.question, misfit, `Rule ${i} (${r.action}) does not fit its answer (${misfit}). Decide.`);
+        if (fired)
+            return { action: r.action, target: r.target ?? "", escalated: false, answers };
+    }
+    return undefined;
+}
+/** Pure half of `gate`: first-match rules; an unsure or missing answer on rule i escalates and wins. */
+export function applyGate(answers, rules) {
+    return applyRules(answers, rules, false) ?? { action: "", target: "", escalated: false, answers };
+}
+/** Pure half of a `Policy`. */
+export function applyPolicy(answers, policy) {
+    const hit = applyRules(answers, policy.rules, policy.skipUncertain ?? false);
+    if (hit)
+        return hit;
+    if (policy.default)
+        return { action: policy.default, target: "", escalated: false, answers };
+    return escalate(answers, "gate:default", "", "no rule fired", "No rule fired. Decide the action.");
+}
+/** Ask, then apply rules; no rule fired -> empty action (use a `Policy` for a declared default). */
+export async function gate(classifier, state, questions, rules, bands = DEFAULT_BANDS) {
+    return applyGate(await ask(classifier, state, questions, bands), rules);
+}
+/** Ask, then apply a `Policy` (rules, default, bands, skipUncertain). */
+export async function decide(classifier, state, questions, policy) {
+    return applyPolicy(await ask(classifier, state, questions, policy.bands ?? DEFAULT_BANDS), policy);
+}
+// ---------------------------------------------------------------- static + tape
+/** One-line `static` classifier from recorded decisions. */
+export function staticClassifier(decisions, model) {
+    return new Classifier({ style: "static", decisions: Array.isArray(decisions) ? decisions : [decisions], model });
+}
+/** The recorded-body form of a Decision, decodable by `static`. */
+function toRaw(d) {
+    const answers = {};
+    for (const [k, a] of Object.entries(d.answers)) {
+        if (a.type === "choice") {
+            const { nearUniform: _derived, ...rest } = a;
+            answers[k] = rest;
+        }
+        else
+            answers[k] = { ...a };
+    }
+    const usage = { input_tokens: d.usage.inputTokens, output_tokens: d.usage.outputTokens };
+    if (d.usage.cost !== undefined)
+        usage.cost = d.usage.cost;
+    return { model: d.model, answers, usage, calibrated: d.calibrated };
+}
+/**
+ * Records live decisions keyed by a caller-given call name, and replays them with no network.
+ * `tape.classifier(name)` returns a Classifier: recording (live given) or replaying (no live).
+ */
+export class Tape {
+    live;
+    entries;
+    constructor(live, entries = {}) {
+        this.live = live;
+        this.entries = { ...entries };
+    }
+    /** A replay-only tape from saved entries. */
+    static replay(entries) {
+        return new Tape(undefined, entries);
+    }
+    classifier(name) {
+        const live = this.live;
+        if (live) {
+            return new Classifier({
+                style: "custom",
+                evaluate: async (state, questions, signal) => {
+                    const d = await live.evaluate(state, questions, signal);
+                    this.entries[name] = { state, questions, response: toRaw(d) };
+                    return d;
+                },
+            });
+        }
+        // Replay: resolved when evaluated (a miss fails then, naming the key, and sends nothing).
+        return new Classifier({
+            style: "custom",
+            evaluate: async (state, questions, signal) => {
+                const rec = this.entries[name];
+                if (!rec)
+                    throw new Error(`tape: no recorded decision for call "${name}"`);
+                const raw = rec.response;
+                return staticClassifier(rec, raw?.model).evaluate(state, questions, signal);
+            },
+        });
+    }
+}

package/dist/mcp.d.ts

@@ -1,5 +1,5 @@
 import type { ElicitRequest, ElicitResult } from "@modelcontextprotocol/sdk/types.js";
-import { type JSONSchema, type Tool, type McpStatus, type Request, type Answer } from "./types.js";
+import { type JSONSchema, type Tool, type ToolHints, type McpStatus, type Request, type Answer } from "./types.js";
 import { type ContentPart } from "./content.js";
 /** Map an MCP `elicitation/create` request onto a §10 `Request`. */
 export declare function elicitationToRequest(params: ElicitRequest["params"]): Request;
@@ -50,13 +50,44 @@ export interface McpSource {
     tools: Tool[];
     status: Record<string, McpStatus>;
     close(): Promise<void>;
+    /**
+     * `list_mcp_resources` and `read_mcp_resource` bound to this source's connected servers
+     * (SPEC §4C). Both read-only. Opt-in: register them on a toolkit. They stop working once the
+     * source is closed.
+     */
+    resourceTools(): Tool[];
 }
+/** One server's outcome, reported by `loadMcp`'s `onServer` the moment that server finishes. */
+export interface McpServerResult {
+    name: string;
+    status: McpStatus;
+    /** This server's converted tools (empty unless connected). Usable until the source closes. */
+    tools: Tool[];
+    /** Why the server failed (absent when connected or disabled). */
+    error?: Error;
+}
+/**
+ * MCP tool annotations → ToolHints (SPEC §4C). No hint fields at all ⇒ undefined (unknown).
+ * Defaults follow the MCP spec: readOnlyHint false, destructiveHint and openWorldHint true.
+ */
+export declare function mcpHints(a: {
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    openWorldHint?: boolean;
+} | undefined): ToolHints | undefined;
 /** Connect to every enabled server, list + convert tools. Failures are isolated.
  *  §2 Gap 3: an optional `signal` bounds each connect/list by the server timeout and aborts the
  *  whole load promptly on parent cancellation. */
 export declare function loadMcp(input: string | object, opts?: {
     waitFor?: (request: Request) => Promise<Answer>;
     signal?: AbortSignal;
+    /**
+     * Called once per server the moment it is connected, failed or found disabled (SPEC §4C),
+     * so a host can register a fast server's tools while a slow one is still connecting.
+     * Calls are serialized (an async callback is awaited before the next one runs); the load
+     * still resolves only after every server and every callback has finished.
+     */
+    onServer?: (result: McpServerResult) => void | Promise<void>;
 }): Promise<McpSource>;
 /** §2 Gap 6. One listed tool definition (original, unprefixed name). */
 export interface ToolInfo {

package/dist/mcp.js

@@ -59,12 +59,36 @@ export function parseMcpConfig(input) {
     const raw = typeof input === "string" ? JSON.parse(readFileSync(input, "utf8")) : input;
     const wrapped = raw.mcpServers ?? raw.servers ?? raw.mcp;
     if (wrapped !== undefined)
-        return wrapped;
+        return normalizeServers(wrapped);
     // Bare map of servers — but strip sibling top-level config keys (builtins/
     // agents/a2a/mcpServer) so they are not mistaken for MCP servers when no
     // wrapper key is present.
     const { builtins: _builtins, agents: _agents, a2a: _a2a, mcpServer: _mcpServer, ...servers } = raw;
-    return servers;
+    return normalizeServers(servers);
+}
+/**
+ * §2 `command` + `args`. A local server's `command` may be a non-empty string or a non-empty
+ * string array; an optional `args` string array is appended. The result is always the argv form
+ * (`command: string[]`, no `args`). Spawned with no shell. A remote server ignores `args`.
+ */
+function normalizeServers(servers) {
+    const out = {};
+    for (const [name, cfg] of Object.entries(servers ?? {})) {
+        if (cfg === null || typeof cfg !== "object" || isRemote(cfg)) {
+            out[name] = cfg;
+            continue;
+        }
+        const { args, command, ...rest } = cfg;
+        const head = typeof command === "string" ? [command] : Array.isArray(command) ? command : undefined;
+        if (!head || head.length === 0 || head[0] === "" || head.some((c) => typeof c !== "string")) {
+            throw new Error(`mcp server "${name}": invalid command`);
+        }
+        if (args !== undefined && (!Array.isArray(args) || args.some((a) => typeof a !== "string"))) {
+            throw new Error(`mcp server "${name}": invalid args`);
+        }
+        out[name] = { ...rest, command: [...head, ...(args ?? [])] };
+    }
+    return out;
 }
 /**
  * Expand ${ENV_VAR} in header values from process.env so tokens live in the
@@ -212,9 +236,14 @@ function convertTool(server, def, client, timeout) {
         description: def.description ?? "",
         inputSchema,
         source: "mcp",
+        ...(mcpHints(def.annotations) ? { hints: mcpHints(def.annotations) } : {}),
         async execute(args, ctx) {
             try {
-                const result = await client.callTool({ name: def.name, arguments: args ?? {} }, undefined, { resetTimeoutOnProgress: true, signal: ctx?.signal, timeout: ctx?.timeout ?? timeout });
+                const result = await client.callTool({ name: def.name, arguments: args ?? {} }, undefined, 
+                // The SDK only attaches `_meta.progressToken` when `onprogress` is supplied; without it
+                // `resetTimeoutOnProgress` never fires (add-mcp-progress-timeout). Notifications for a
+                // token that matches no in-flight request are dropped by the SDK, so they never reset.
+                { onprogress: () => { }, resetTimeoutOnProgress: true, signal: ctx?.signal, timeout: ctx?.timeout ?? timeout });
                 // Parts are collected BEFORE any branch returns: the isError and structuredContent
                 // short-circuits both read `content[]` on the way past, so neither reintroduces the
                 // silent drop this mapping exists to remove (§2).
@@ -235,6 +264,120 @@ function convertTool(server, def, client, timeout) {
         },
     };
 }
+/**
+ * MCP tool annotations → ToolHints (SPEC §4C). No hint fields at all ⇒ undefined (unknown).
+ * Defaults follow the MCP spec: readOnlyHint false, destructiveHint and openWorldHint true.
+ */
+export function mcpHints(a) {
+    if (!a || (a.readOnlyHint === undefined && a.destructiveHint === undefined && a.openWorldHint === undefined))
+        return undefined;
+    const h = { readOnly: a.readOnlyHint ?? false, destructive: a.destructiveHint ?? true, openWorld: a.openWorldHint ?? true };
+    if (h.readOnly)
+        h.destructive = false;
+    return h;
+}
+function resourceTools(servers) {
+    const ro = { readOnly: true, destructive: false, openWorld: false };
+    const names = () => [...servers.keys()].sort();
+    const conn = (server) => {
+        const c = servers.get(server);
+        if (!c)
+            throw new Error(`no connected MCP server "${server}" (connected: ${names().join(", ")})`);
+        return c;
+    };
+    const list = {
+        name: "list_mcp_resources",
+        description: "List the resources MCP servers offer (uri, name, description, mimeType). Optionally for one server.",
+        inputSchema: {
+            type: "object",
+            properties: { server: { type: "string", description: "Only this server (default: all)" } },
+            additionalProperties: false,
+        },
+        source: "mcp",
+        hints: ro,
+        async execute(args, ctx) {
+            let targets = names();
+            const s = typeof args?.server === "string" ? args.server : "";
+            if (s) {
+                try {
+                    conn(s);
+                }
+                catch (e) {
+                    return { output: `list_mcp_resources: ${e.message}`, isError: true };
+                }
+                targets = [s];
+            }
+            const lines = [];
+            const items = [];
+            for (const name of targets) {
+                const c = conn(name);
+                try {
+                    const res = await c.client.listResources({}, { timeout: c.timeout, signal: ctx?.signal });
+                    for (const r of res.resources ?? []) {
+                        let line = `${name} ${r.uri}`;
+                        if (r.name)
+                            line += ` — ${r.name}`;
+                        if (r.mimeType)
+                            line += ` (${r.mimeType})`;
+                        if (r.description)
+                            line += `: ${r.description}`;
+                        lines.push(line);
+                        items.push({ server: name, uri: r.uri, name: r.name ?? "", mimeType: r.mimeType ?? "", description: r.description ?? "" });
+                    }
+                }
+                catch (e) {
+                    lines.push(`${name}: error: ${e instanceof Error ? e.message : String(e)}`);
+                }
+            }
+            if (!lines.length)
+                return { output: "No resources.", isError: false, metadata: { count: 0 } };
+            return { output: lines.join("\n"), isError: false, metadata: { count: items.length, resources: items } };
+        },
+    };
+    const read = {
+        name: "read_mcp_resource",
+        description: "Read one MCP resource by server and uri. Text comes back as text; binary content is described, not inlined.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                server: { type: "string", description: "The MCP server name" },
+                uri: { type: "string", description: "The resource uri" },
+            },
+            required: ["server", "uri"],
+            additionalProperties: false,
+        },
+        source: "mcp",
+        hints: ro,
+        async execute(args, ctx) {
+            const server = typeof args?.server === "string" ? args.server : "";
+            const uri = typeof args?.uri === "string" ? args.uri : "";
+            let c;
+            try {
+                c = conn(server);
+            }
+            catch (e) {
+                return { output: `read_mcp_resource: ${e.message}`, isError: true };
+            }
+            if (!uri)
+                return { output: "read_mcp_resource: uri is required", isError: true };
+            try {
+                const res = await c.client.readResource({ uri }, { timeout: c.timeout, signal: ctx?.signal });
+                const parts = [];
+                for (const rc of res.contents ?? []) {
+                    if (typeof rc.text === "string")
+                        parts.push(rc.text);
+                    else if (typeof rc.blob === "string")
+                        parts.push(`[binary ${rc.mimeType ?? ""}, ${rc.blob.length} base64 chars]`);
+                }
+                return { output: parts.join("\n"), isError: false, metadata: { server, uri } };
+            }
+            catch (e) {
+                return { output: `read_mcp_resource: ${e instanceof Error ? e.message : String(e)}`, isError: true };
+            }
+        },
+    };
+    return [list, read];
+}
 /** Create a fresh (not-yet-connected) client, with the elicitation bridge attached if a waitFor
  *  exists. Separated from connect so the caller ALWAYS holds a closeable reference — even if the
  *  connect is later abandoned by a timeout/abort, `client.close()` still terminates any spawned
@@ -279,11 +422,28 @@ export async function loadMcp(input, opts) {
     const tools = [];
     const status = {};
     const clients = [];
+    const servers = new Map();
     const waitFor = opts?.waitFor;
     const signal = opts?.signal;
-    await Promise.all(Object.entries(config).map(async ([name, cfg]) => {
+    const onServer = opts?.onServer;
+    let reports = Promise.resolve();
+    let reportError;
+    const report = (r) => {
+        if (!onServer)
+            return;
+        reports = reports.then(async () => {
+            try {
+                await onServer(r);
+            }
+            catch (e) {
+                reportError ??= e;
+            }
+        });
+    };
+    const loading = Promise.all(Object.entries(config).map(async ([name, cfg]) => {
         if (!isEnabled(cfg)) {
             status[name] = "disabled";
+            report({ name, status: "disabled", tools: [] });
             return;
         }
         const timeout = cfg.timeout ?? DEFAULT_TIMEOUT;
@@ -294,10 +454,12 @@ export async function loadMcp(input, opts) {
             await raceTimeout(connectTransport(client, cfg), timeout, signal);
             const defs = await raceTimeout(paginateTools(client, timeout), timeout, signal);
             const kept = applyToolsFilter(name, defs, cfg.tools);
-            for (const def of kept)
-                tools.push(convertTool(name, def, client, timeout));
+            const converted = kept.map((def) => convertTool(name, def, client, timeout));
+            tools.push(...converted);
             clients.push(client);
+            servers.set(name, { client, timeout });
             status[name] = "connected";
+            report({ name, status: "connected", tools: converted });
         }
         catch (e) {
             status[name] = "failed";
@@ -306,15 +468,31 @@ export async function loadMcp(input, opts) {
             // within budget isolates just this server.
             if (signal?.aborted)
                 throw e;
+            report({ name, status: "failed", tools: [], error: e instanceof Error ? e : new Error(String(e)) });
             console.warn(`[toolnexus] MCP server "${name}" failed: ${e instanceof Error ? e.message : String(e)}`);
         }
     }));
+    try {
+        await loading;
+    }
+    catch (e) {
+        // Parent cancellation: close every client, including ones whose tools onServer handed out.
+        await reports;
+        await Promise.all(clients.map((c) => c.close().catch(() => { })));
+        throw e;
+    }
+    await reports;
+    if (reportError) {
+        await Promise.all(clients.map((c) => c.close().catch(() => { })));
+        throw reportError;
+    }
     return {
         tools,
         status,
         async close() {
             await Promise.all(clients.map((c) => c.close().catch(() => { })));
         },
+        resourceTools: () => resourceTools(servers),
     };
 }
 /**

package/dist/models.d.ts

@@ -0,0 +1,20 @@
+/**
+ * listModels (SPEC §4C): the models a provider offers, for model switching. One GET per page,
+ * no retries. Same key rules as the client (apiKey, apiKeyEnv, or the host's own env var).
+ */
+import { type ClientOptions } from "./client.js";
+/** One model a provider lists. */
+export interface ModelInfo {
+    id: string;
+    /** The provider's display name, when it gives one. */
+    name?: string;
+    /** Context window in tokens when the provider reports it (OpenRouter does). */
+    contextLength?: number;
+}
+/**
+ * List the models at `opts.baseUrl` in `opts.style`: openai `GET {base}/models`; anthropic
+ * `GET {base}/v1/models`, following `has_more`/`last_id`. Sorted by id.
+ */
+export declare function listModels(opts: Pick<ClientOptions, "baseUrl" | "style" | "apiKey" | "apiKeyEnv" | "headers" | "fetch">, ctx?: {
+    signal?: AbortSignal;
+}): Promise<ModelInfo[]>;