@ffschrattenecker/tm1-mcp-server 6.1.1 → 7.0.0

package/dist/resources/subscriptions.js

@@ -14,19 +14,24 @@
 // resources/unsubscribe, notifications/resources/updated).
 import { SubscribeRequestSchema, UnsubscribeRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { tm1Events } from "../lib/tm1-events.js";
-// URIs whose contents are sensitive to *any* mutation. The server-state
-// resource aggregates counts across cubes/dims/processes/chores/clients —
-// almost any non-safe call can change it.
-const STATE_SENSITIVE_URIS = new Set(["tm1://server/state"]);
+// The server-state resource aggregates counts across cubes/dims/processes/
+// chores/clients — almost any non-safe call can change it. With several
+// connections there is one such resource per connection; stateUris maps each
+// to the connectionId whose mutations affect it.
+const SINGLE_STATE_URIS = new Map([
+    ["tm1://server/state", ""],
+]);
 export class SubscriptionRegistry {
     server;
     logger;
+    stateUris;
     // URIs the client has asked us to push updates for.
     subscribed = new Set();
     mutationListener;
-    constructor(server, logger) {
+    constructor(server, logger, stateUris = SINGLE_STATE_URIS) {
         this.server = server;
         this.logger = logger;
+        this.stateUris = stateUris;
     }
     /** Install subscribe/unsubscribe request handlers + mutation listener. */
     install() {
@@ -62,13 +67,17 @@ export class SubscriptionRegistry {
     size() {
         return this.subscribed.size;
     }
-    onMutation(_e) {
+    onMutation(e) {
         // Iterate subscribed URIs and notify those affected by this mutation.
         // Currently only the aggregate state resource is mutation-sensitive;
         // future entries can branch on e.path / e.method for finer-grained
         // notifications (e.g. tm1://process/{name}/code on /Processes mutations).
         for (const uri of this.subscribed) {
-            if (!STATE_SENSITIVE_URIS.has(uri))
+            const target = this.stateUris.get(uri);
+            if (target === undefined)
+                continue;
+            // An empty target or an untagged event matches any connection.
+            if (target && e.connectionId && target !== e.connectionId)
                 continue;
             // Fire-and-forget; missing transport (server not connected) throws.
             this.server.server.sendResourceUpdated({ uri }).catch((err) => {

package/dist/server-instructions.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectionRegistry } from "./connections.js";
+export declare function serverInstructions(registry: ConnectionRegistry): string;
+//# sourceMappingURL=server-instructions.d.ts.map

package/dist/server-instructions.js

@@ -0,0 +1,12 @@
+// Sent once per session (MCP `instructions`), so every sentence here is paid
+// for by every conversation — keep it to what a model cannot infer from the
+// tool list itself.
+export function serverInstructions(registry) {
+    const lines = ["TM1 / IBM Planning Analytics server."];
+    if (!registry.isSingle) {
+        lines.push("Every tool except tm1_list_connections takes a `connection`; if the target is unclear, call tm1_list_connections and ask. Never write to a connection the user did not name.");
+    }
+    lines.push("Keep results small: filter by name, use projections (fields, include* flags, compact) and countOnly before paging.");
+    return lines.join(" ");
+}
+//# sourceMappingURL=server-instructions.js.map

package/dist/tm1-client/http.d.ts

@@ -1,5 +1,5 @@
 import type pino from "pino";
-import type { TM1Config } from "../config.js";
+import { type TM1Config } from "../config.js";
 import type { SessionManager } from "../session-manager.js";
 import { TM1Error } from "../types.js";
 export interface RequestOptions {

package/dist/tm1-client/http.js

@@ -1,3 +1,4 @@
+import { connectionIdOf } from "../config.js";
 import { createConnectionProfile, } from "./connection/profile.js";
 import { TM1Error, TM1ErrorCode } from "../types.js";
 import { PRODUCT, VERSION } from "../version.js";
@@ -110,13 +111,21 @@ export class TM1HttpClient {
                     }
                     const retryResult = await this.handleResponse(retryResponse, path);
                     if (!isSafeMethod) {
-                        tm1Events.emit("mutation", { method, path });
+                        tm1Events.emit("mutation", {
+                            method,
+                            path,
+                            connectionId: connectionIdOf(this.config),
+                        });
                     }
                     return retryResult;
                 }
                 const result = await this.handleResponse(response, path);
                 if (!isSafeMethod) {
-                    tm1Events.emit("mutation", { method, path });
+                    tm1Events.emit("mutation", {
+                        method,
+                        path,
+                        connectionId: connectionIdOf(this.config),
+                    });
                 }
                 return result;
             }
@@ -191,7 +200,11 @@ export class TM1HttpClient {
         }
         const text = await response.text();
         if (!isSafeHttpMethod(method)) {
-            tm1Events.emit("mutation", { method, path });
+            tm1Events.emit("mutation", {
+                method,
+                path,
+                connectionId: connectionIdOf(this.config),
+            });
         }
         return text;
     }
@@ -225,7 +238,11 @@ export class TM1HttpClient {
             throw this.classifyHttpError(response.status, path, errBody || undefined);
         }
         if (!isSafeHttpMethod(method)) {
-            tm1Events.emit("mutation", { method, path });
+            tm1Events.emit("mutation", {
+                method,
+                path,
+                connectionId: connectionIdOf(this.config),
+            });
         }
     }
     /**

package/dist/tm1-client/services/process-service.d.ts

@@ -12,6 +12,12 @@ export interface ProcessVariableLayout {
 export interface ProcessListOpts extends NameFilterOpts {
     /** Set to slice server-side. Only legal when every active filter is in NameFilterOpts. */
     page?: PageOpts;
+    /**
+     * Select Name only; every process comes back with `parameters: []`. TM1
+     * then serializes no parameter blocks at all — for callers that only need
+     * names (counts, existence checks, listings) this is the cheap query.
+     */
+    namesOnly?: boolean;
 }
 export declare class ProcessService {
     private readonly http;
@@ -29,7 +35,7 @@ export declare class ProcessService {
      * Name-only when v11 rejects the inline Parameters select.
      * GET /api/v1/Processes?$select=Name,Parameters
      */
-    list(): Promise<Process[]>;
+    list(opts?: Pick<ProcessListOpts, "namesOnly">): Promise<Process[]>;
     /**
      * Paged variant: with `page` set the slice happens server-side
      * (`$orderby=Name&$top&$skip&$count=true`) and the return carries the

package/dist/tm1-client/services/process-service.js

@@ -85,6 +85,12 @@ export class ProcessService {
         // — TM1 v11 rejects $expand=Parameters with a syntax error. Use $select
         // instead, which returns Parameters inline. Param.Type comes back as the
         // already-decoded string "Numeric" / "String" (not the legacy int code).
+        const namesOnly = async () => {
+            const response = await this.http.request("GET", `/api/v1/Processes?$select=Name${query}`);
+            return wrap(response.value.map((p) => ({ name: p.Name, parameters: [] })), readCount(response));
+        };
+        if (opts.namesOnly)
+            return namesOnly();
         try {
             const response = await this.http.request("GET", `/api/v1/Processes?$select=Name,Parameters${query}`);
             return wrap(response.value.map((p) => ({
@@ -99,11 +105,7 @@ export class ProcessService {
         }
         catch (e) {
             rethrowIfSystemic(e);
-            const response = await this.http.request("GET", `/api/v1/Processes?$select=Name${query}`);
-            return wrap(response.value.map((p) => ({
-                name: p.Name,
-                parameters: [],
-            })), readCount(response));
+            return namesOnly();
         }
     }
     /**

package/dist/tm1-client.d.ts

@@ -1,5 +1,5 @@
 import type pino from "pino";
-import type { TM1Config } from "./config.js";
+import { type TM1Config } from "./config.js";
 import type { SessionManager } from "./session-manager.js";
 import { BatchService } from "./tm1-client/services/batch-service.js";
 import { CubeService } from "./tm1-client/services/cube-service.js";

package/dist/tm1-client.js

@@ -1,3 +1,4 @@
+import { connectionIdOf } from "./config.js";
 import { TM1HttpClient } from "./tm1-client/http.js";
 import { BatchService } from "./tm1-client/services/batch-service.js";
 import { CubeService } from "./tm1-client/services/cube-service.js";
@@ -95,17 +96,7 @@ export class TM1Client {
      * process backups) apart: host and port, plus the v12 instance/database.
      */
     get connectionId() {
-        let host;
-        try {
-            const url = new URL(this.config.baseUrl);
-            host = url.port ? `${url.hostname}_${url.port}` : url.hostname;
-        }
-        catch {
-            host = this.config.baseUrl;
-        }
-        return [host, this.config.instance, this.config.database]
-            .filter((part) => Boolean(part))
-            .join("_");
+        return connectionIdOf(this.config);
     }
     /**
      * Authenticate and start the keep-alive timer.

package/dist/tools/analysis/audit-naming.js

@@ -240,7 +240,7 @@ export const registerAuditNaming = defineTool({
         // ── Processes + (optional) variables ───────────────────────────────
         let processNames = [];
         if (want("processes") || want("processVariables")) {
-            const procs = await tm1Client.processes.list();
+            const procs = await tm1Client.processes.list({ namesOnly: true });
             processNames = (includeControl ? procs : procs.filter((p) => !isControlName(p.name))).map((p) => p.name);
         }
         if (want("processes")) {

package/dist/tools/analysis/invalidate-callgraph-cache.js

@@ -7,8 +7,9 @@ export const registerInvalidateCallgraphCache = defineTool({
     description: "Drop the in-memory ReferenceIndex cache used by tm1_analyze_callgraph / tm1_analyze_object_usage / tm1_analyze_chore_graph. Rarely needed: every successful mutating call through this server already drops it. Use it only after changes made outside this server (Workspace, TI, another client). The next analysis call rebuilds the index (single bulk fetch). Touches no TM1 object, so it is available in readonly mode.",
     annotations: READ_ONLY,
     output: InvalidateCallgraphCacheResultSchema,
-    // Takes no arguments: the cache is process-wide.
+    // Takes no arguments and no connection: the cache is process-wide.
     input: {},
+    connectionless: true,
     handler: () => {
         try {
             const before = getCallgraphCacheStats();

package/dist/tools/analysis/trace-data-flow.js

@@ -13,7 +13,7 @@ const FLOW_MAX_ITEMS = 500;
 export const registerTraceDataFlow = defineTool({
     name: "tm1_trace_data_flow",
     description: [
-        "Trace data flow into and out of a cube in one call, instead of analyze_object_usage + N× get_process_code.",
+        "Trace data flow into and out of a cube in one call, instead of analyze_object_usage + N× get_process.",
         "downstream: processes that READ the cube and which cubes they WRITE to (where the data flows next).",
         "upstream: processes that WRITE the cube and where they SOURCE data (read cubes + datasource).",
         "Combines code-level CellGet/CellPut/DB access with each process's datasource, so view-sourced reads",

package/dist/tools/confirm.js

@@ -27,7 +27,7 @@ import { TM1Error, TM1ErrorCode } from "../types.js";
 export const CONFIRM_SCHEMA = {
     confirm: z
         .string()
-        .describe("Safety check: repeat the target identifier verbatim (e.g. cube/dimension/process name) to confirm this irreversible action. Mismatched values reject the call."),
+        .describe("Repeat the target name verbatim to confirm this irreversible action; a mismatch rejects the call."),
 };
 // For a destructive tool with a dryRun: a dry run needs no confirm, so the
 // field is optional in the schema and required at runtime on the real call.

package/dist/tools/define-tool.d.ts

@@ -1,10 +1,18 @@
 import type { McpServer, ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { ZodObject, ZodRawShape, ZodTypeAny } from "zod";
+import { type ZodObject, type ZodRawShape, type ZodTypeAny } from "zod";
 import type { TM1Client } from "../tm1-client.js";
+import { ConnectionRegistry } from "../connections.js";
 import type { Tm1ToolAnnotations } from "./annotations.js";
+/**
+ * Where a tool gets its client from: the multi-connection registry in
+ * production, or one prebuilt client (unit tests, embedders), which is wrapped
+ * as a single-connection registry.
+ */
+export type ClientSource = TM1Client | ConnectionRegistry;
 /** Registrar shape expected by the REGISTRARS array in ./index.ts. */
-export type ToolRegistrar = (server: McpServer, tm1Client: TM1Client) => void;
-export interface ToolSpec<I extends ZodRawShape> {
+export type ToolRegistrar = (server: McpServer, source: ClientSource) => void;
+export declare function asRegistry(source: ClientSource): ConnectionRegistry;
+interface ToolSpecBase<I extends ZodRawShape> {
     /** Wire name, `tm1_*`. */
     name: string;
     /**
@@ -24,19 +32,34 @@ export interface ToolSpec<I extends ZodRawShape> {
     /** MCP behavior hints — one of the presets in ./annotations.js. */
     annotations: Tm1ToolAnnotations;
     /**
-     * Registration gate for tools that exist on one TM1 generation only (v11
-     * threads vs v12 jobs, v11-only save_data). Returning false skips the tool
-     * entirely — it never appears in tools/list. This is deliberately separate
-     * from the `requiresVersion` annotation, which is a client-facing HINT and
-     * is also carried by tools that stay registered on both generations.
+     * Gate for tools that exist on one TM1 generation only (v11 threads vs v12
+     * jobs, v11-only save_data). The tool is registered only when at least one
+     * connection runs that version, and a call against a connection on the other
+     * version is refused. This is deliberately separate from the
+     * `requiresVersion` annotation, which is a client-facing HINT and is also
+     * carried by tools that stay registered on both generations.
      */
-    enabled?: (tm1Client: TM1Client) => boolean;
+    version?: 11 | 12;
+}
+/** A tool that acts on one TM1 connection — every tool but a handful. */
+interface ConnectionToolSpec<I extends ZodRawShape> extends ToolSpecBase<I> {
+    connectionless?: false;
     /**
-     * Handler. Receives the parsed args, the shared TM1 client, and the SDK's
-     * per-call extra (abort signal, request metadata).
+     * Handler. Receives the parsed args, the client of the connection the call
+     * targets, and the SDK's per-call extra (abort signal, request metadata).
      */
     handler: (args: Parameters<ToolCallback<I>>[0], tm1Client: TM1Client, extra: Parameters<ToolCallback<I>>[1]) => ReturnType<ToolCallback<I>>;
 }
+/**
+ * A tool about the connections themselves (tm1_list_connections): it takes no
+ * `connection` argument and gets the registry instead of a client, so calling
+ * it never logs in anywhere.
+ */
+interface ConnectionlessToolSpec<I extends ZodRawShape> extends ToolSpecBase<I> {
+    connectionless: true;
+    handler: (args: Parameters<ToolCallback<I>>[0], registry: ConnectionRegistry, extra: Parameters<ToolCallback<I>>[1]) => ReturnType<ToolCallback<I>>;
+}
+export type ToolSpec<I extends ZodRawShape> = ConnectionToolSpec<I> | ConnectionlessToolSpec<I>;
 /** What ./with-annotations.ts needs at registration time. */
 export interface ResolvedSpec {
     name: string;
@@ -48,4 +71,5 @@ export declare function specFor(name: string): ResolvedSpec | undefined;
 /** Every spec defined so far. Used by the lint gates and by tests. */
 export declare function allSpecs(): ReadonlyMap<string, ResolvedSpec>;
 export declare function defineTool<I extends ZodRawShape>(spec: ToolSpec<I>): ToolRegistrar;
+export {};
 //# sourceMappingURL=define-tool.d.ts.map

package/dist/tools/define-tool.js

@@ -1,5 +1,13 @@
+import { z } from "zod";
+import { ConnectionRegistry } from "../connections.js";
+import { TM1Error, TM1ErrorCode } from "../types.js";
 import { asOutputSchema } from "./schemas/output-schema.js";
 import { markdownCapable } from "./schemas/markdown-capable.js";
+export function asRegistry(source) {
+    return source instanceof ConnectionRegistry
+        ? source
+        : ConnectionRegistry.single(source);
+}
 // Populated at module-load time, when a tool file's top-level defineTool()
 // call runs. That is strictly before registerAllTools() executes, because the
 // import graph resolves first — so the Proxy always finds the spec.
@@ -36,14 +44,53 @@ export function defineTool(spec) {
         // `outputSchema: undefined` for an optional property.
         ...(outputSchema === undefined ? {} : { outputSchema }),
     });
-    return (server, tm1Client) => {
-        if (spec.enabled && !spec.enabled(tm1Client))
+    return (server, source) => {
+        const registry = asRegistry(source);
+        if (spec.connectionless) {
+            const handler = spec.handler;
+            const cb = ((args, extra) => handler(args, registry, extra));
+            server.tool(spec.name, description, spec.input, cb);
+            return;
+        }
+        const handler = spec.handler;
+        if (spec.version !== undefined && !registry.hasVersion(spec.version)) {
             return;
+        }
+        // One connection: the input shape is exactly what the tool declares. More
+        // than one: every tool takes a `connection` naming the target.
+        const input = registry.isSingle
+            ? spec.input
+            : {
+                ...spec.input,
+                connection: z
+                    .enum(registry.usableNames)
+                    .describe("Target TM1 connection."),
+            };
         // ToolCallback<I> is a conditional type over an unresolved generic, so TS
         // cannot check the lambda against it — the cast asserts what the
         // ToolSpec.handler signature already pins down (same args, same return).
-        const cb = ((args, extra) => spec.handler(args, tm1Client, extra));
-        server.tool(spec.name, description, spec.input, cb);
+        const cb = (async (args, extra) => {
+            const { connection, ...rest } = args;
+            const info = registry.resolveInfo(connection);
+            if (!spec.annotations.readOnlyHint && info.mode === "readonly") {
+                throw new TM1Error({
+                    code: TM1ErrorCode.PERMISSION_DENIED,
+                    message: `${spec.name} changes TM1, but connection "${info.name}" is readonly.`,
+                    hint: info.modeReason ??
+                        "Set TM1_MODE=readwrite in that connection's .env to allow writes.",
+                });
+            }
+            if (spec.version !== undefined && info.version !== spec.version) {
+                throw new TM1Error({
+                    code: TM1ErrorCode.UNSUPPORTED_OPERATION,
+                    message: `${spec.name} needs TM1 v${spec.version}; connection "${info.name}" is v${info.version}.`,
+                    hint: `Pick a v${spec.version} connection, or use the v${info.version} equivalent.`,
+                });
+            }
+            const tm1Client = await registry.get(connection);
+            return handler(rest, tm1Client, extra);
+        });
+        server.tool(spec.name, description, input, cb);
     };
 }
 //# sourceMappingURL=define-tool.js.map

package/dist/tools/index.d.ts

@@ -1,4 +1,4 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { TM1Client } from "../tm1-client.js";
-export declare function registerAllTools(server: McpServer, tm1Client: TM1Client): void;
+import type { ClientSource } from "./define-tool.js";
+export declare function registerAllTools(server: McpServer, source: ClientSource): void;
 //# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -20,11 +20,7 @@ import { registerTraceFeeders } from "./celldata/trace-feeders.js";
 import { registerTraceCellCalculation } from "./celldata/trace-cell-calculation.js";
 // TI development tools (process CRUD, execution, code, params, datasource)
 import { registerExecuteProcess } from "./ti-development/execute-process.js";
-import { registerGetProcessParameters } from "./ti-development/get-process-parameters.js";
-import { registerGetProcessCode } from "./ti-development/get-process-code.js";
 import { registerGetProcess } from "./ti-development/get-process.js";
-import { registerGetProcessDatasource } from "./ti-development/get-process-datasource.js";
-import { registerGetProcessVariables } from "./ti-development/get-process-variables.js";
 import { registerDeleteProcess } from "./ti-development/delete-process.js";
 import { registerCopyProcess } from "./ti-development/copy-process.js";
 import { registerCompileProcess } from "./ti-development/compile-process.js";
@@ -84,6 +80,7 @@ import { registerCreateChore } from "./scheduling/create-chore.js";
 import { registerUpdateChore } from "./scheduling/update-chore.js";
 import { registerDeleteChore } from "./scheduling/delete-chore.js";
 // Operations tools
+import { registerListConnections } from "./operations/list-connections.js";
 import { registerGetMessageLog } from "./operations/get-message-log.js";
 import { registerGetThreads } from "./operations/get-threads.js";
 import { registerGetJobs } from "./operations/get-jobs.js";
@@ -150,14 +147,10 @@ const REGISTRARS = [
     registerTraceFeeders,
     registerTraceCellCalculation,
     registerCheckWritableCoords,
-    // TI development — writes go through registerUpsertProcess (bundled),
-    // reads remain atomic for inspection without pulling full process code.
+    // TI development — writes go through registerUpsertProcess and reads
+    // through registerGetProcess (include-flags pick the parts).
     registerExecuteProcess,
-    registerGetProcessParameters,
-    registerGetProcessCode,
     registerGetProcess,
-    registerGetProcessDatasource,
-    registerGetProcessVariables,
     registerDeleteProcess,
     registerCopyProcess,
     registerCompileProcess,
@@ -216,6 +209,7 @@ const REGISTRARS = [
     registerUpdateChore,
     registerDeleteChore,
     // Operations
+    registerListConnections,
     registerGetMessageLog,
     registerGetThreads,
     registerGetJobs,
@@ -256,8 +250,8 @@ const REGISTRARS = [
     registerAssignClientGroup,
     registerRemoveClientGroup,
 ];
-export function registerAllTools(server, tm1Client) {
+export function registerAllTools(server, source) {
     for (const register of REGISTRARS)
-        register(server, tm1Client);
+        register(server, source);
 }
 //# sourceMappingURL=index.js.map

package/dist/tools/metadata/list-cubes.js

@@ -11,7 +11,7 @@ export const registerListCubes = defineTool({
     name: "tm1_list_cubes",
     description: [
         "List cubes in the TM1 server. Control cubes ('}'-prefixed) excluded unless includeControl=true.",
-        "Combinable name filters (nameExact/nameContains/nameRegex) and projection toggles (includeDimensions, includeRules) trim payload on wide models.",
+        "Returns names; includeDimensions / includeRules add each cube's dimensions[] / hasRules. Combinable name filters: nameExact/nameContains/nameRegex.",
         "Paginated (default 50/page).",
     ],
     annotations: READ_ONLY,
@@ -27,8 +27,8 @@ export const registerListCubes = defineTool({
         includeDimensions: z
             .boolean()
             .optional()
-            .default(true)
-            .describe("Include the dimensions[] array per cube (default: true). Set false for compact output on wide cubes."),
+            .default(false)
+            .describe("Include the dimensions[] array per cube."),
         includeRules: z
             .boolean()
             .optional()

package/dist/tools/metadata/list-processes.js

@@ -10,8 +10,8 @@ import { pageShapeFor } from "../schemas/common.js";
 export const registerListProcesses = defineTool({
     name: "tm1_list_processes",
     description: [
-        "List TurboIntegrator processes (with parameters) in the TM1 server. Control processes ('}'-prefixed) excluded unless includeControl=true.",
-        "Name filters (nameContains/nameRegex/nameNotContains/excludePattern) and fields=['name'] projection trim payload on large models.",
+        "List TurboIntegrator process names in the TM1 server; fields=['name','parameters'] adds each process's parameters. Control processes ('}'-prefixed) excluded unless includeControl=true.",
+        "Name filters: nameContains/nameRegex/nameNotContains/excludePattern.",
         "Paginated (default 50/page).",
     ],
     annotations: READ_ONLY,
@@ -43,14 +43,17 @@ export const registerListProcesses = defineTool({
         fields: z
             .array(z.enum(["name", "parameters"]))
             .optional()
-            .describe("Projection. Default: all fields. Use ['name'] to skip parameters[] and shrink payload ~10x."),
+            .describe("Projection. Default ['name']; include 'parameters' for parameter lists (~10x larger)."),
     },
     handler: async ({ limit, offset, fetchAll, format, includeControl, nameContains, nameRegex, nameNotContains, excludePattern, fields, }, tm1Client) => {
-        const project = (list) => fields && !fields.includes("parameters")
-            ? list.map((p) => ({ name: p.name }))
-            : list;
+        // Names only unless parameters are asked for: listing is how a model
+        // orients, and the parameter blocks are ~10x the bytes of the names.
+        const withParameters = fields?.includes("parameters") ?? false;
+        const project = (list) => withParameters ? list : list.map((p) => ({ name: p.name }));
         const fullScan = async () => {
-            let processes = await tm1Client.processes.list();
+            let processes = await tm1Client.processes.list({
+                namesOnly: !withParameters,
+            });
             if (!includeControl)
                 processes = processes.filter((p) => !p.name.startsWith("}"));
             if (nameContains) {
@@ -79,6 +82,7 @@ export const registerListProcesses = defineTool({
         let page;
         if (canPushDown) {
             const { items, total } = await tm1Client.processes.list({
+                namesOnly: !withParameters,
                 includeControl,
                 ...(nameContains ? { nameContains } : {}),
                 ...(nameNotContains ? { nameNotContains } : {}),

package/dist/tools/model-building/unload-cube.js

@@ -10,7 +10,7 @@ export const registerUnloadCube = defineTool({
     // v11 only. v12 answers tm1.Unload with "Demand load, loading and unloading
     // of cubes is no longer supported." — the feature is gone, with no successor
     // endpoint, so the tool is withheld rather than offered and refused.
-    enabled: (tm1Client) => tm1Client.version === 11,
+    version: 11,
     output: MutationResultSchema,
     input: {
         cubeName: z.string().describe("Name of the cube to unload"),

package/dist/tools/operations/get-audit-log.js

@@ -11,7 +11,7 @@ export const registerGetAuditLog = defineTool({
     annotations: withVersion(READ_ONLY, "v11"),
     // v12 deprecated AuditLogEntry/AuditLogEntries in 12.0.0 and serves an empty
     // collection with no successor endpoint, so the tool can only mislead there.
-    enabled: (tm1Client) => tm1Client.version === 11,
+    version: 11,
     output: {
         count: z.number().int(),
         entries: z.array(AuditLogEntrySchema),

package/dist/tools/operations/get-jobs.js

@@ -11,7 +11,7 @@ const registerListJobs = defineTool({
     name: "tm1_list_jobs",
     description: "List active jobs (Activity) on a TM1 v12 database — the running tasks that replaced v11 threads. Paginated (default 50/page). (v12 only)",
     annotations: READ_ONLY,
-    enabled: (tm1Client) => tm1Client.version === 12,
+    version: 12,
     output: pageShapeFor(JobSchema),
     input: { ...PAGINATION_SCHEMA, ...FORMAT_SCHEMA },
     handler: async ({ limit, offset, fetchAll, format }, tm1Client) => {
@@ -34,7 +34,7 @@ const registerCancelJob = defineTool({
         "(v12 only)",
     ],
     annotations: DESTRUCTIVE,
-    enabled: (tm1Client) => tm1Client.version === 12,
+    version: 12,
     output: MutationResultSchema,
     input: {
         jobId: z.string().describe("Job ID to cancel"),

package/dist/tools/operations/get-message-log.js

@@ -10,7 +10,7 @@ export const registerGetMessageLog = defineTool({
     // v12 deprecated MessageLogEntry/MessageLogEntries (and the MessageLog /
     // TailMessageLog functions) in 12.0.0; all of them serve empty with no
     // successor endpoint.
-    enabled: (tm1Client) => tm1Client.version === 11,
+    version: 11,
     output: {
         count: z.number().int(),
         entries: z.array(MessageLogEntrySchema),

package/dist/tools/operations/get-server-state.js

@@ -47,7 +47,7 @@ export const registerGetServerState = defineTool({
             tm1Client.server.getInfo(),
             tm1Client.cubes.list(),
             tm1Client.dimensions.list(),
-            tm1Client.processes.list(),
+            tm1Client.processes.list({ namesOnly: true }),
             tm1Client.chores.list(),
             tm1Client.security.listClients(),
         ]);

package/dist/tools/operations/get-threads.js

@@ -9,7 +9,7 @@ const registerListThreads = defineTool({
     name: "tm1_list_threads",
     description: "List active threads on the TM1 server (running processes, chores, MDX queries, etc.). Paginated (default 50/page). (v11 only)",
     annotations: READ_ONLY,
-    enabled: (tm1Client) => tm1Client.version === 11,
+    version: 11,
     output: pageShapeFor(ThreadSchema),
     input: { ...PAGINATION_SCHEMA, ...FORMAT_SCHEMA },
     handler: async ({ limit, offset, fetchAll, format }, tm1Client) => {
@@ -33,7 +33,7 @@ const registerCancelThread = defineTool({
         "(v11 only)",
     ],
     annotations: DESTRUCTIVE,
-    enabled: (tm1Client) => tm1Client.version === 11,
+    version: 11,
     output: MutationResultSchema,
     input: {
         id: z.number().int().describe("Thread ID to cancel"),

package/dist/tools/operations/get-transaction-log.js

@@ -10,7 +10,7 @@ export const registerGetTransactionLog = defineTool({
     // v12 deprecated TransactionLogEntry/TransactionLogEntries (and the
     // TransactionLog / TailTransactionLog functions) in 12.0.0; all of them serve
     // empty with no successor endpoint.
-    enabled: (tm1Client) => tm1Client.version === 11,
+    version: 11,
     output: {
         count: z.number().int(),
         coverage: z

package/dist/tools/operations/list-connections.d.ts

@@ -0,0 +1,2 @@
+export declare const registerListConnections: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=list-connections.d.ts.map