@ffschrattenecker/tm1-mcp-server 6.0.0 → 7.0.0

package/dist/connections.js

@@ -0,0 +1,262 @@
+// Named TM1 connections served by ONE server process.
+//
+// Before v7 every TM1 connection was its own server: one `.env` per folder
+// under ~/.tm1/mcp-servers/, one process, one full copy of the tool list. With
+// N connections a client carried N × ~113 tool names in context every turn,
+// spawned N processes and held N sessions + keepalives open. The registry keeps
+// the same folders as the source of truth (they are also what the tm1-api
+// skill reads) but serves them all from one tool list: every tool takes a
+// `connection` argument, and each connection's TM1Client is built on first use.
+//
+// Selection:
+//   TM1_CONNECTIONS_DIR set          → discover that folder
+//   TM1_BASE_URL set (and no dir)    → legacy single connection "default"
+//   neither                          → discover ~/.tm1/mcp-servers
+// TM1_CONNECTIONS (comma-separated) narrows discovery to the named folders.
+//
+// Per connection, only the folder's own `.env` decides mode and version. Mode
+// defaults to readonly: a connection-level key (TM1_MODE, TM1_BASE_URL, …) in
+// the server's own environment is NOT inherited, so a TM1_MODE=readwrite in
+// the launching shell cannot silently arm every connection.
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parse as parseDotenv } from "dotenv";
+import pino from "pino";
+import { connectionIdOf, loadConfig } from "./config.js";
+import { SessionManager } from "./session-manager.js";
+import { TM1Client } from "./tm1-client.js";
+import { TM1Error, TM1ErrorCode } from "./types.js";
+/** Settings that belong to the server process, not to one TM1 connection. */
+const SERVER_LEVEL_KEYS = new Set([
+    "TM1_LOG_LEVEL",
+    "TM1_LOG_FILE",
+    "TM1_RESPONSE_MODE",
+    "TM1_MAX_RESPONSE_CHARS",
+    "TM1_CONNECTIONS_DIR",
+    "TM1_CONNECTIONS",
+]);
+function isServerLevelKey(key) {
+    return SERVER_LEVEL_KEYS.has(key) || key.startsWith("TM1_MCP_");
+}
+export class ConnectionRegistry {
+    logger;
+    entries = new Map();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /** Discover connections from the environment (see the header comment). */
+    static fromEnvironment(env, logger) {
+        const registry = new ConnectionRegistry(logger);
+        const explicitDir = env.TM1_CONNECTIONS_DIR;
+        if (!explicitDir && env.TM1_BASE_URL) {
+            registry.addConfig("default", loadConfig(env));
+            return registry;
+        }
+        const dir = explicitDir || join(homedir(), ".tm1", "mcp-servers");
+        registry.discover(dir, env);
+        if (registry.entries.size === 0) {
+            throw new Error(`No TM1 connections found. Set TM1_BASE_URL (single connection) or ` +
+                `create <name>/.env folders under ${dir} (or point TM1_CONNECTIONS_DIR at them).`);
+        }
+        // Folders exist but none is usable: fail at startup with every reason,
+        // rather than serve tools whose `connection` enum is empty.
+        if (registry.usableNames.length === 0) {
+            const reasons = registry
+                .status()
+                .map((c) => `  ${c.name}: ${c.configError}`)
+                .join("\n");
+            throw new Error(`No usable TM1 connection under ${dir}:\n${reasons}`);
+        }
+        return registry;
+    }
+    /** Wrap one prebuilt client (tests, embedders). */
+    static single(client, logger = pino({ level: "silent" })) {
+        return ConnectionRegistry.of([{ name: "default", client }], logger);
+    }
+    /**
+     * Prebuilt clients under explicit names. The owner keeps the clients'
+     * lifecycle: disconnectAll() leaves them alone. Mode defaults to readwrite
+     * because the registration-time gate (TM1_MODE via withAnnotations) already
+     * decided what an embedder may call.
+     */
+    static of(clients, logger = pino({ level: "silent" })) {
+        const registry = new ConnectionRegistry(logger);
+        for (const { name, client, mode } of clients) {
+            registry.entries.set(name, {
+                info: {
+                    name,
+                    version: client.version,
+                    mode: mode ?? "readwrite",
+                    connectionId: client.connectionId,
+                },
+                client,
+            });
+        }
+        return registry;
+    }
+    addConfig(name, config, dir) {
+        this.entries.set(name, {
+            info: {
+                name,
+                dir,
+                mode: config.mode,
+                environment: config.environment,
+                modeReason: config.modeReason,
+                version: config.version,
+                tm1Version: config.tm1Version,
+                baseUrl: config.baseUrl,
+                connectionId: connectionIdOf(config),
+            },
+            config,
+        });
+    }
+    discover(dir, env) {
+        if (!existsSync(dir))
+            return;
+        const only = env.TM1_CONNECTIONS
+            ? new Set(env.TM1_CONNECTIONS.split(",")
+                .map((s) => s.trim())
+                .filter(Boolean))
+            : undefined;
+        // Server-level settings and non-TM1 variables (PATH, proxies) carry over;
+        // connection-level TM1_* keys come from the folder only.
+        const base = {};
+        for (const [key, value] of Object.entries(env)) {
+            if (!key.startsWith("TM1_") || isServerLevelKey(key))
+                base[key] = value;
+        }
+        const names = readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isDirectory() && existsSync(join(dir, d.name, ".env")))
+            .map((d) => d.name)
+            .filter((name) => !only || only.has(name))
+            .sort((a, b) => a.localeCompare(b));
+        for (const name of names) {
+            const folder = join(dir, name);
+            try {
+                const fileEnv = parseDotenv(readFileSync(join(folder, ".env")));
+                const connEnv = { ...base };
+                for (const [key, value] of Object.entries(fileEnv)) {
+                    // The folder may not override server-level settings: one folder's
+                    // TM1_MCP_TRANSPORT must not reconfigure the whole process.
+                    if (!isServerLevelKey(key))
+                        connEnv[key] = value;
+                }
+                this.addConfig(name, loadConfig(connEnv), folder);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                this.logger.warn({ connection: name, err: message }, "skipping connection");
+                this.entries.set(name, {
+                    info: { name, dir: folder, configError: message },
+                });
+            }
+        }
+    }
+    /** Every connection name, including ones whose config failed to load. */
+    get names() {
+        return [...this.entries.keys()];
+    }
+    /** Connections that can actually be used. */
+    get usableNames() {
+        return [...this.entries.values()]
+            .filter((e) => e.config || e.client)
+            .map((e) => e.info.name);
+    }
+    /** True when tools should not expose a `connection` argument at all. */
+    get isSingle() {
+        return this.usableNames.length === 1;
+    }
+    get anyReadwrite() {
+        return [...this.entries.values()].some((e) => e.info.mode === "readwrite");
+    }
+    hasVersion(version) {
+        return [...this.entries.values()].some((e) => e.info.version === version);
+    }
+    /** A client exists and is not mid-login. Never triggers a login itself. */
+    isConnected(name) {
+        const entry = this.entries.get(name);
+        return entry?.client !== undefined && entry.connecting === undefined;
+    }
+    info(name) {
+        return this.entries.get(name)?.info;
+    }
+    status() {
+        return [...this.entries.values()].map((e) => ({
+            ...e.info,
+            connected: e.client !== undefined && e.connecting === undefined && !e.lastError,
+            lastError: e.lastError,
+        }));
+    }
+    /** Resolve a connection name (optional when there is only one). */
+    entryFor(name) {
+        if (name === undefined) {
+            if (this.isSingle)
+                return this.entries.get(this.usableNames[0]);
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: `connection is required. One of: ${this.names.join(", ")}.`,
+            });
+        }
+        const entry = this.entries.get(name);
+        if (!entry) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: `Unknown connection "${name}". One of: ${this.names.join(", ")}.`,
+            });
+        }
+        if (entry.info.configError) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: `Connection "${name}" is misconfigured: ${entry.info.configError}`,
+            });
+        }
+        return entry;
+    }
+    /**
+     * The client for a connection, built and logged in on first use. A failed
+     * login does not poison the entry: the client's own request path retries
+     * authentication, so the next call gets a fresh attempt.
+     */
+    async get(name) {
+        const entry = this.entryFor(name);
+        if (!entry.client) {
+            const config = entry.config;
+            const logger = this.logger.child({ connection: entry.info.name });
+            const sessionManager = new SessionManager(config, logger);
+            entry.client = new TM1Client(config, sessionManager, logger);
+            entry.connecting = entry.client
+                .connect()
+                .then(() => {
+                entry.lastError = undefined;
+            })
+                .catch((err) => {
+                entry.lastError = err instanceof Error ? err.message : String(err);
+                logger.warn({ err }, "initial TM1 connection failed — will retry on request");
+            })
+                .finally(() => {
+                entry.connecting = undefined;
+            });
+        }
+        if (entry.connecting)
+            await entry.connecting;
+        return entry.client;
+    }
+    /** Connection metadata for a resolved call (mode/version gates). */
+    resolveInfo(name) {
+        return this.entryFor(name).info;
+    }
+    async disconnectAll() {
+        await Promise.all([...this.entries.values()].map(async (e) => {
+            if (!e.client || !e.config)
+                return; // prebuilt clients are the owner's
+            try {
+                await e.client.disconnect();
+            }
+            catch (err) {
+                this.logger.error({ err, connection: e.info.name }, "disconnect failed");
+            }
+        }));
+    }
+}
+//# sourceMappingURL=connections.js.map

package/dist/http-transport.d.ts

@@ -1,8 +1,8 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type pino from "pino";
-import type { TM1Config } from "./config.js";
+import type { ServerSettings } from "./config.js";
 export declare function startHttpTransport(buildServer: () => {
     server: McpServer;
     dispose: () => void;
-}, config: TM1Config, logger: pino.Logger): Promise<() => Promise<void>>;
+}, config: ServerSettings, logger: pino.Logger): Promise<() => Promise<void>>;
 //# sourceMappingURL=http-transport.d.ts.map

package/dist/index.js

@@ -2,12 +2,12 @@
 import "./load-env.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { loadConfig } from "./config.js";
+import { loadServerSettings } from "./config.js";
+import { ConnectionRegistry } from "./connections.js";
+import { serverInstructions } from "./server-instructions.js";
 import { createLogger } from "./logger.js";
-import { SessionManager } from "./session-manager.js";
-import { TM1Client } from "./tm1-client.js";
 import { registerAllPrompts } from "./prompts/index.js";
-import { registerAllResources } from "./resources/index.js";
+import { registerAllResources, stateResourceUris } from "./resources/index.js";
 import { SubscriptionRegistry } from "./resources/subscriptions.js";
 import { installPaginatedListHandler } from "./resources/list-handler.js";
 import { registerAllTools } from "./tools/index.js";
@@ -23,7 +23,7 @@ async function startStdioTransport(server, logger) {
         await transport.close();
     };
 }
-function buildMcpServer(tm1Client, config, logger) {
+function buildMcpServer(registry, settings, logger) {
     const server = new McpServer({
         name: NAME,
         version: VERSION,
@@ -34,21 +34,25 @@ function buildMcpServer(tm1Client, config, logger) {
             prompts: { listChanged: true },
             logging: {},
         },
+        instructions: serverInstructions(registry),
     });
     // Register all tools — wrap the server so each registration receives the
     // annotation hint from ANNOTATION_MAP without editing call sites. In readonly
     // mode the proxy silently drops write/destructive tools so they never appear
-    // in the tool listing — no autoApprove lists needed.
-    registerAllTools(withAnnotations(server, logger, config.mode, config.responseMode, config.maxResponseChars), tm1Client);
-    logger.debug(`All MCP tools registered (mode: ${config.mode})`);
+    // in the tool listing — no autoApprove lists needed. With several
+    // connections, write tools are listed when ANY connection is readwrite and
+    // refused per call against a readonly one (see defineTool).
+    const mode = registry.anyReadwrite ? "readwrite" : "readonly";
+    registerAllTools(withAnnotations(server, logger, mode, settings.responseMode, settings.maxResponseChars), registry);
+    logger.debug(`All MCP tools registered (mode: ${mode})`);
     // Register MCP Resources (URI-addressable read-only views over TM1 objects).
-    const resourceCatalog = registerAllResources(server, tm1Client);
+    const resourceCatalog = registerAllResources(server, registry);
     // R2-07: replace the SDK's default ListResourcesRequestSchema handler with a
     // cursor-aware override that paginates the combined static + template list.
     installPaginatedListHandler(server, resourceCatalog, logger);
     // R2-05: install subscribe/unsubscribe handlers and bridge HTTP-layer mutation
     // events to notifications/resources/updated for subscribers of tm1://server/state.
-    const subscriptions = new SubscriptionRegistry(server, logger);
+    const subscriptions = new SubscriptionRegistry(server, logger, stateResourceUris(registry));
     subscriptions.install();
     // Register MCP Prompts (parameterised workflow templates surfaced as slash-commands).
     registerAllPrompts(server);
@@ -61,24 +65,33 @@ function buildMcpServer(tm1Client, config, logger) {
     };
 }
 async function main() {
-    const config = loadConfig();
-    const logger = createLogger(config);
+    const settings = loadServerSettings();
+    const logger = createLogger(settings);
     logger.info("Starting TM1 MCP Server");
-    const sessionManager = new SessionManager(config, logger);
-    const tm1Client = new TM1Client(config, sessionManager, logger);
-    // Try to connect to TM1, but don't block MCP server startup.
-    // request() calls ensureSession() on every tool invocation, so a tool call
-    // will retry auth if the initial connect failed. Keeps Claude able to list
-    // tools and report a meaningful error instead of crashing the whole process.
-    try {
-        await tm1Client.connect();
-        logger.info("TM1 client connected");
-    }
-    catch (err) {
-        logger.warn({ err }, "Initial TM1 connection failed — server will retry on first tool call");
+    // One registry for every configured connection (see ./connections.ts).
+    // Clients are built lazily on first use, so startup costs no TM1 logins.
+    const registry = ConnectionRegistry.fromEnvironment(process.env, logger);
+    for (const c of registry.status()) {
+        if (c.configError) {
+            logger.warn({ connection: c.name, err: c.configError }, "connection unusable");
+        }
+        else {
+            logger.info({
+                connection: c.name,
+                mode: c.mode,
+                environment: c.environment,
+                version: c.tm1Version,
+            }, "connection configured");
+            if (c.modeReason) {
+                logger.warn({ connection: c.name }, `${c.modeReason} Write and destructive tools are refused on this connection.`);
+            }
+        }
     }
-    if (config.mode === "readonly") {
-        logger.info("TM1_MODE=readonly — write and destructive tools will not be registered");
+    // A single connection keeps the old behavior of logging in at startup, in
+    // the background: request() re-authenticates on every call anyway, so a
+    // failed login here only delays the error to the first tool call.
+    if (registry.isSingle) {
+        void registry.get(undefined);
     }
     // Branch on transport. stdio is the default for local MCP-client setups
     // (Claude Code, Claude Desktop) and gets one long-lived server. http
@@ -89,14 +102,14 @@ async function main() {
     // runs in shutdown(). http builds one per request and disposes each in the
     // transport's own teardown — nothing process-scoped is left for us here.
     let stdioDispose;
-    const httpCloser = config.transport === "http"
-        ? await startHttpTransport(() => buildMcpServer(tm1Client, config, logger), config, logger)
+    const httpCloser = settings.transport === "http"
+        ? await startHttpTransport(() => buildMcpServer(registry, settings, logger), settings, logger)
         : await (async () => {
-            const built = buildMcpServer(tm1Client, config, logger);
+            const built = buildMcpServer(registry, settings, logger);
             stdioDispose = built.dispose;
             return startStdioTransport(built.server, logger);
         })();
-    logger.info(`MCP server configured (mode: ${config.mode}, transport: ${config.transport})`);
+    logger.info(`MCP server configured (connections: ${registry.names.join(", ")}, transport: ${settings.transport})`);
     // Graceful shutdown — ensure TM1 session is always cleaned up.
     let shuttingDown = false;
     const shutdown = async (signal, exitCode = 0) => {
@@ -116,12 +129,7 @@ async function main() {
         catch (err) {
             logger.error({ err }, "Error closing transport");
         }
-        try {
-            await tm1Client.disconnect();
-        }
-        catch (err) {
-            logger.error({ err }, "Error during disconnect");
-        }
+        await registry.disconnectAll();
         process.exit(exitCode);
     };
     process.on("SIGINT", () => {
@@ -136,7 +144,7 @@ async function main() {
     // Parent process death — only meaningful on stdio (Claude spawns us as a
     // child). For http we ignore stdin events since the process lifecycle is
     // independent.
-    if (config.transport === "stdio") {
+    if (settings.transport === "stdio") {
         process.stdin.on("end", () => {
             logger.info("stdin ended (parent process gone), shutting down");
             void shutdown("stdin-end");

package/dist/lib/callgraph/tm1-adapter.d.ts

@@ -26,7 +26,10 @@ export declare function getCallgraphCacheStats(): Array<{
 }>;
 /**
  * Build a full ReferenceIndex from a connected TM1 server.
- * TTL-cached (60 s) per `includeControl` flag. Concurrent calls share one inflight promise.
+ * TTL-cached (60 s) per connection and `includeControl` flag — one server
+ * process serves several TM1 connections, so the key must name the connection
+ * or one server's index would be answered for another. Concurrent calls share
+ * one inflight promise.
  */
 export declare function buildIndexFromTM1(tm1Client: TM1Client, opts?: BuildIndexOpts): Promise<ReferenceIndex>;
 //# sourceMappingURL=tm1-adapter.d.ts.map

package/dist/lib/callgraph/tm1-adapter.js

@@ -71,11 +71,14 @@ export function getCallgraphCacheStats() {
 }
 /**
  * Build a full ReferenceIndex from a connected TM1 server.
- * TTL-cached (60 s) per `includeControl` flag. Concurrent calls share one inflight promise.
+ * TTL-cached (60 s) per connection and `includeControl` flag — one server
+ * process serves several TM1 connections, so the key must name the connection
+ * or one server's index would be answered for another. Concurrent calls share
+ * one inflight promise.
  */
 export async function buildIndexFromTM1(tm1Client, opts = {}) {
     const includeControl = opts.includeControl ?? false;
-    const key = `inc=${includeControl}`;
+    const key = `${tm1Client.connectionId}|inc=${includeControl}`;
     if (!opts.bypassCache) {
         const hit = cache.get(key);
         if (hit && Date.now() - hit.ts < CACHE_TTL_MS)

package/dist/lib/slim-json-schema.d.ts

@@ -14,7 +14,15 @@
  * (`properties` & friends), where the keys are user-chosen field names — a tool
  * with a field literally called `$schema` keeps its subschema.
  *
+ * Descriptions that restate the node's own `default` ("(default: false)",
+ * "Default: 50.") lose that phrase: the `default` keyword right next to it
+ * already says so. Only a phrase whose value equals the emitted default is
+ * removed, so a description documenting a default the schema does not carry
+ * (an optional field resolved in the handler) keeps it.
+ *
  * Pure: the input is never mutated, the result is a fresh deep clone.
  */
+/** Remove "(default: X)" / "Default: X." where X is the emitted default. */
+export declare function stripDefaultPhrase(description: string, defaultValue: unknown): string;
 export declare function slimJsonSchema(schema: unknown): unknown;
 //# sourceMappingURL=slim-json-schema.d.ts.map

package/dist/lib/slim-json-schema.js

@@ -14,6 +14,12 @@
  * (`properties` & friends), where the keys are user-chosen field names — a tool
  * with a field literally called `$schema` keeps its subschema.
  *
+ * Descriptions that restate the node's own `default` ("(default: false)",
+ * "Default: 50.") lose that phrase: the `default` keyword right next to it
+ * already says so. Only a phrase whose value equals the emitted default is
+ * removed, so a description documenting a default the schema does not carry
+ * (an optional field resolved in the handler) keeps it.
+ *
  * Pure: the input is never mutated, the result is a fresh deep clone.
  */
 // Zod serializes `.int()` to the JS safe-integer range; these two exact values
@@ -29,6 +35,25 @@ const NAME_KEYED_CONTAINERS = new Set([
     "$defs",
     "dependentSchemas",
 ]);
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Remove "(default: X)" / "Default: X." where X is the emitted default. */
+export function stripDefaultPhrase(description, defaultValue) {
+    if (typeof defaultValue !== "boolean" &&
+        typeof defaultValue !== "number" &&
+        typeof defaultValue !== "string") {
+        return description;
+    }
+    const value = escapeRegExp(String(defaultValue));
+    return (description
+        .replace(new RegExp(String.raw `\s*\(default:?\s*${value}\)`, "gi"), "")
+        .replace(new RegExp(String.raw `\s*\bDefault:?\s*${value}(?:[.;]|(?=\s)|$)`, "gi"), "")
+        .replace(/\s+([.,;])/g, "$1")
+        .trim()
+        // A phrase that opened the sentence leaves its trailing dash behind.
+        .replace(/^[—–-]\s*/, ""));
+}
 export function slimJsonSchema(schema) {
     return slimNode(schema, false);
 }
@@ -40,10 +65,19 @@ function slimNode(node, nameKeyed) {
     if (node === null || typeof node !== "object")
         return node;
     const out = {};
+    const defaultValue = nameKeyed
+        ? undefined
+        : node.default;
     for (const [key, value] of Object.entries(node)) {
         if (!nameKeyed) {
             if (key === "$schema")
                 continue;
+            if (key === "description" && typeof value === "string") {
+                const text = stripDefaultPhrase(value, defaultValue);
+                if (text)
+                    out[key] = text;
+                continue;
+            }
             if (key === "minimum" && value === SAFE_INT_MIN)
                 continue;
             if (key === "maximum" && value === SAFE_INT_MAX)

package/dist/lib/strip-comments.js

@@ -1,4 +1,4 @@
-// Pure helpers for tm1_get_process_code's stripComments mode. No I/O.
+// Pure helpers for tm1_get_process's stripComments mode. No I/O.
 //
 // TM1 TI code uses only `#` line comments (no block comments); `#` starts a
 // comment that runs to end of line. Grown models accumulate large blocks of

package/dist/lib/tm1-events.d.ts

@@ -2,6 +2,8 @@ import { EventEmitter } from "node:events";
 export interface Tm1MutationEvent {
     method: string;
     path: string;
+    /** connectionIdOf() of the connection that mutated; see config.ts. */
+    connectionId?: string;
 }
 interface Tm1Events {
     mutation: (e: Tm1MutationEvent) => void;

package/dist/prompts/index.js

@@ -72,8 +72,8 @@ export function registerAllPrompts(server) {
         `Diagnose why TI process **${processName}** failed. Follow this sequence:`,
         "",
         `1. **Error logs**: call \`tm1_diagnose_process_error(processName="${processName}", includeRelated=true, tail=80)\` — pulls newest logs + cascade siblings (sub-processes failing seconds apart).`,
-        `2. **Parameters**: call \`tm1_get_process_parameters(processName="${processName}")\` — verify the call site passed the right shape.`,
-        `3. **Source code**: call \`tm1_get_process_code(processName="${processName}")\` to inspect Prolog/Metadata/Data/Epilog.`,
+        `2. **Parameters**: call \`tm1_get_process(processName="${processName}", includeCode=false)\` — verify the call site passed the right shape.`,
+        `3. **Source code**: call \`tm1_get_process(processName="${processName}")\` to inspect Prolog/Metadata/Data/Epilog.`,
         `4. **Static refs**: call \`tm1_validate_process_refs(processName="${processName}")\` — surfaces unresolved cube/dimension references.`,
         `5. **Callgraph**: call \`tm1_analyze_callgraph(processName="${processName}", summary=true)\` — what does this process call, what calls it.`,
         `6. **Server log** (v11 only): \`tm1_get_message_log(filter="${processName}", top=50)\` for server-side correlation. Skip on v12 — the message log endpoint is deprecated there and the tool is not registered.`,

package/dist/resources/index.d.ts

@@ -1,5 +1,7 @@
 import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { TM1Client } from "../tm1-client.js";
+import { type ClientSource } from "../tools/define-tool.js";
 import type { ResourceCatalog } from "./list-handler.js";
-export declare function registerAllResources(server: McpServer, tm1: TM1Client): ResourceCatalog;
+export declare function registerAllResources(server: McpServer, source: ClientSource): ResourceCatalog;
+/** URIs of every connection's server-state resource, keyed by connectionId. */
+export declare function stateResourceUris(source: ClientSource): Map<string, string>;
 //# sourceMappingURL=index.d.ts.map