@sassoftware/sas-score-mcp-serverjs 0.3.19 → 0.4.0

package/src/toolSet/findTable.js

@@ -9,68 +9,39 @@ import _listTables from '../toolHelpers/_listTables.js';
 
 function findTable(_appContext) {
   let description = `
-## find-table — locate a specific table in a CAS or SAS library
+find-table — locate a specific table in a CAS or SAS library.
 
-LLM Invocation Guidance (When to use)
-Use THIS tool when the user wants to find or verify a table in a specific library:
-- "find table iris in Public library in cas"
-- "find table cars in sashelp in sas server"
-- "does table customers exist in mylib?"
-- "is there a table named sales in the Samples library?"
-- "verify table orders exists in Public"
+USE when: find table, does table exist, is table in library, verify table exists, locate table
+DO NOT USE for: list tables (use list-tables), table schema/columns (use table-info), read table data (use read-table), find lib/job/model (use respective tools)
 
-Do NOT use this tool when the user wants:
-- find lib -> use find-library
-- find model -> use find-model
-- find job -> use find-job
-- find jobdef -> use find-jobdef
-- Columns or schema of a table (use table-info)
-- Reading data from a table (use read-table)
-- Listing all tables in a library (use list-tables)
+PARAMETERS
+- lib: string (required) — library name (e.g., 'Public', 'sashelp')
+- name: string (required) — table name to locate
+- server: 'cas' | 'sas' (default: 'cas') — target environment
 
-Purpose
-Locate a table contained in a specified library (caslib or libref) on a CAS or SAS server. Returns matching table names or empty array if not found.
+ROUTING RULES
+- "find table <name> in <lib>" → { lib: "<lib>", name: "<name>", server: "cas" }
+- "find table <name> in <lib> in sas" → { lib: "<lib>", name: "<name>", server: "sas" }
+- "does table <name> exist in <lib>" → { lib: "<lib>", name: "<name>", server: "cas" }
+- "find table" with missing lib → ask "Which library contains the table?"
+- "find table" with missing name → ask "Which table name would you like to find?"
+- "list tables in <lib>" → use list-tables instead
 
-Parameters
-- lib (string, required): The library to search in (e.g., 'Public', 'sashelp', or a caslib name)
-- name (string, required): Table name or substring to search for. Matching is case-insensitive.
-- server (string, default 'cas'): Either 'cas' or 'sas'. Defaults to 'cas' when omitted.
-
-Response Contract
-Returns a JSON object with:
-- tables: Array of matching table names (strings)
-- Empty array { tables: [] } when no matches found
-- Do not fabricate table names; only return actual matches
-
-Disambiguation & Clarification
-- Missing library: ask "Which library do you want to search in?"
-- Missing table name: ask "Which table name would you like to find?"
-- Server ambiguous: ask "Do you mean CAS or SAS?"
-- If user wants multiple tables: suggest "Use list-tables to see all tables in a library"
-
-Examples (→ mapped params)
-- "find table iris in Public library in cas" → { lib: "Public", name: "iris", server: "cas" }
-- "find table cars in sashelp in sas server" → { lib: "sashelp", name: "cars", server: "sas" }
+EXAMPLES
+- "find table iris in Public" → { lib: "Public", name: "iris", server: "cas" }
+- "find table cars in sashelp in sas" → { lib: "sashelp", name: "cars", server: "sas" }
 - "does customers exist in mylib" → { lib: "mylib", name: "customers", server: "cas" }
 - "verify table orders in Samples" → { lib: "Samples", name: "orders", server: "cas" }
 
-Negative Examples (should NOT call find-table)
-- "list tables in Public" (use list-tables instead)
-- "find library Public" (use find-library instead)
-- "what columns in cars table?" (use table-info instead)
-- "read data from customers" (use read-table instead)
-
-Usage Tips
-- Use this tool to verify table existence before reading or querying
-- For discovery of multiple tables, use list-tables instead
-- After finding a table, use table-info for schema or read-table for data
+NEGATIVE EXAMPLES (do not route here)
+- "list tables in Public" (use list-tables)
+- "find library Public" (use find-library)
+- "what columns in cars?" (use table-info)
+- "read data from customers" (use read-table)
 
-Related Tools
-- find-table → table-info → read-table (typical workflow)
-- list-tables — to discover all tables in a library
-- find-library — to verify library exists
-- table-info — to inspect table structure after finding it
-`;
+ERRORS
+Returns { tables: [] } if not found; { tables: [name, ...] } if found. Never hallucinate table names.
+  `;
   
   let spec = {
     name: 'find-table',

package/src/toolSet/getEnv.js

@@ -7,53 +7,35 @@ import {z} from 'zod';
 import _getEnv from '../toolHelpers/_getEnv.js';
 function getEnv(_appContext) {
     let description = `
-## get-env — retrieve a variable value from the runtime environment
+get-env — retrieve a variable value from the runtime environment.
 
-LLM Invocation Guidance (When to use)
-Use THIS tool when:
-- The user wants to access a specific environment variable or context value
-- "What is the value of [variable name]?"
-- "Get me the [variable] value"
-- "Show the current [variable]"
+USE when: what is the value of, get me, show current, what's the, retrieve environment variable
+DO NOT USE for: read table data (use read-table), model info (use model-info), find/run job (use find-job/run-job), set context (use set-context)
 
-Do NOT use this tool for:
-- Retrieving table data (use read-table)
-- Getting model information (use model-info)
-- Looking up job status (use find-job or run-job)
-- Setting environment variables (use set-context to set CAS/SAS contexts)
+PARAMETERS
+- name: string (required) — variable name to retrieve (case-sensitive)
 
-Purpose
-Retrieve the current value of a named variable from the runtime environment. This is useful for debugging, accessing context information, or verifying current configuration values.
+ROUTING RULES
+- "what is the value of <var>" → { name: "<var>" }
+- "get me <var>" → { name: "<var>" }
+- "show <var>" → { name: "<var>" }
+- "get" with no variable → ask "Which variable would you like to retrieve?"
+- "what context am I using" → use set-context instead (no params)
+- "set <var> to <value>" → use set-context or run-sas-program instead
 
-Parameters
-- name (string, required): The name of the variable to retrieve. Variable names are case-sensitive.
-
-Response Contract
-Returns a JSON object containing:
-- The requested variable name as a key
-- The current value of that variable
-- If the variable does not exist, returns null or an error message
-
-Disambiguation & Clarification
-- If variable name is missing: ask "Which variable would you like to retrieve?"
-- If user says "context" without specifying which variable: clarify "Do you mean the CAS context, SAS context, or a specific variable?"
-- Multiple variable request: handle one at a time or ask for clarification
-
-Examples (→ mapped params)
+EXAMPLES
 - "What's the value of myVar" → { name: "myVar" }
 - "Get me the configuration variable" → { name: "configuration" }
 - "Show the current server setting" → { name: "server" }
 
-Negative Examples (should NOT call get-env)
-- "Read all rows from the customers table" (use read-table instead)
-- "Get model details for myModel" (use model-info instead)
-- "Set the CAS server to finance-prod" (use set-context instead)
+NEGATIVE EXAMPLES (do not route here)
+- "Read rows from customers" (use read-table)
+- "Get model details for myModel" (use model-info)
+- "Set the CAS server to finance-prod" (use set-context)
 
-Related Tools
-- setContext — to set environment context values (CAS and SAS servers)
-- readTable — to retrieve table data
-- modelInfo — to retrieve model metadata
-`;
+ERRORS
+Returns variable name with current value, or null if not found. Return structured error with message field.
+    `;
   
     let spec = {
         name: 'get-env',

package/src/toolSet/listJobdefs.js

@@ -7,71 +7,37 @@ import _listJobdefs from '../toolHelpers/_listJobdefs.js';
 function listJobdefs(_appContext) {
 
   let description = `
-  ## list-jobdefs — enumerate SAS Viya job definitions assets(jobdefs)
+list-jobdefs — enumerate SAS Viya job definitions (jobdefs) assets.
 
-  LLM Invocation Guidance (When to use)
-  jobdef and jobdefs are used interchangeably here to refer to job definitions.
-  Use THIS tool when the user wants to browse or list many job definitions assets
-  - "list jobdefs"
-  - "show jobdefs"
-  - "list available jobdefs"
-  - "browse jobdefs"
-  - "next jobdefs" (after a previous page)
-  - "list 25 jobdefs" / "list jobdefs limit 25"
-  Do NOT use this tool for:
-  - Checking existence of ONE job (use find-job)
-  - Executing/running a job (use run-job)
-  - Running a job definition (use run-jobdef)
-  - Submitting SAS code (use run-sas-program)
+USE when: list jobdefs, show jobdefs, browse jobdefs, list available jobdefs, next page
+DO NOT USE for: find single jobdef (use find-jobdef), execute jobdef (use run-jobdef), find job (use find-job), sas code (use run-sas-program)
 
+PARAMETERS
+- limit: number (default: 10) — number of jobdefs per page
+- start: number (default: 1) — 1-based page offset
+- where: string (default: '') — optional filter expression
 
-  Purpose
-  Page through jobdef assets deployed/registered in SAS Viya.
+ROUTING RULES
+- list jobdefs → { start: 1, limit: 10 }
+- show me 25 jobdefs → { start: 1, limit: 25 }
+- next jobdefs → { start: previousStart + previousLimit, limit: previousLimit }
 
-  Parameters
-  - limit (number, default 10): Number of jobs to return.
-  - start (number, default 1): 1-based offset for paging.
-  - where (string, optional): Filter expression (future use / passthrough; empty string by default). If unsupported, it may be ignored gracefully.
+EXAMPLES
+- list jobdefs → { start: 1, limit: 10 }
+- list 25 jobdefs → { start: 1, limit: 25 }
+- next jobdefs → { start: 11, limit: 10 }
 
-  Response Contract
-  - Returns an array of jobdef names or objects (backend-dependent) inside structuredContent.
-  - If items.length === limit, caller may request next page using start + limit.
-  - Provide optional hint start = start + limit when page might continue.
+NEGATIVE EXAMPLES (do not route here)
+- find jobdef abc (use find-jobdef)
+- list jobs (use list-jobs)
+- run jobdef abc (use run-jobdef)
+- list models (use list-models)
 
-  Pagination Examples
-  - First page: { start:1, limit:10 }
-  - Next page:  { start:11, limit:10 }
+PAGINATION
+If returned length === limit, hint: next start = start + limit. Empty result with start > 1 means paged past end.
 
-  Disambiguation & Clarification
-  - Input only "list" → ask: "Specify asset to list? (Say 'Please specify what to listlist' to proceed)" unless prior context indicates job definition listing.
-  - Input contains "run"/"execute" plus job name → route to job/jobdef.
-
-  Negative Examples (should NOT call list-jobdefs)
-  - "list libraries" (use list-libraries)
-  - "list tables" (use list-tables)
-  - "list models" (use list-models)
-  - "list jobs" (use list-jobs)
-  - "find job abc" (findJob)
-  - "run job abc" (job)
-  - "job abc" (job)
-  - "find model xyz" (findModel)
-  - "list models" (listModels)
-  - "list tables in lib xyz" (listTables)
-  - "show me libraries" (listLibraries)
-  - "describe job abc" (findJob then possibly job for execution)
-
-  Error Handling
-  - On backend error: surface structured error payload (do not fabricate job names).
-  - Empty page (items.length === 0) with start > 1 may mean caller paged past end.
-
-  Usage Tips
-  - Increase limit for fewer round trips; keep reasonable to avoid large payloads.
-  - Combine with findJobdeffor confirmation before execution.
-
-  Examples (→ mapped params)
-  - "list jobdefs" → { start:1, limit:10 }
-  - "list 25 jobdefs" → { start:1, limit:25 }
-  - "next jobdefs" (after prior {start:1,limit:10}) → { start:11, limit:10 }
+ERRORS
+Surface backend error directly; never fabricate jobdef names.
   `;
 
   let spec = {

package/src/toolSet/listJobs.js

@@ -5,87 +5,39 @@
 import { z } from 'zod';
 import _listJobs from '../toolHelpers/_listJobs.js';
 function listJobs(_appContext) {
-  // LLM guidance object retained for potential future consumption; not exported directly.
-  let llmDescription = {
-    purpose: "Map natural language requests to listJobs parameters and return a machine-readable response.",
-    param_mapping: {
-      limit: "positive integer. if not specified, set limit to 10",
-      start: "1-indexed offset. if not specified, set start to 1",
-      where: "optional filter string, default '' (may be ignored)"
-    },
-    response_schema: "{ jobs: string[] , start?: number }",
-    behavior: "Return only JSON matching response_schema. If ambiguous, ask at most one clarifying question. If no results, return { jobs: [] }. Include start when a full page is returned.",
-    examples: [
-      { input: "list jobs", mapped_params: { start: 1, limit: 10 } },
-      { input: "show me jobs, 20 per page", mapped_params: { start: 1, limit: 20 } },
-      { input: "next jobs", note: "interpret as start = previousStart + previousLimit" }
-    ],
-    safety: "Surface backend errors directly; do not hallucinate job names."
-  };
 
   let description = `
-  ## list-jobs — enumerate SAS Viya job assets
-
-  LLM Invocation Guidance (When to use)
-  Use THIS tool when the user wants to browse or list many job definitions / job assets:
-  - "list jobs"
-  - "show jobs"
-  - "list available jobs"
-  - "browse jobs"
-  - "next jobs" (after a previous page)
-  - "list 25 jobs" / "list jobs limit 25"
-
-  Do NOT use this tool for:
-  - Checking existence of ONE job (use find-job)
-  - Executing/running a job (use run-job)
-  - Running a job definition (use run-jobdef)
-  - Submitting SAS code (use run-sas-program)
-
-
-  Purpose
-  Page through job assets deployed/registered in SAS Viya Job Execution service.
-
-  Parameters
-  - limit (number, default 10): Number of jobs to return.
-  - start (number, default 1): 1-based offset for paging.
-  - where (string, optional): Filter expression (future use / passthrough; empty string by default). If unsupported, it may be ignored gracefully.
+list-jobs — enumerate SAS Viya job assets.
 
-  Response Contract
-  - Returns an array of job names or objects (backend-dependent) inside structuredContent.
-  - If items.length === limit, caller may request next page using start + limit.
-  - Provide optional hint start = start + limit when page might continue.
+USE when: list jobs, show jobs, browse jobs, list available jobs, next page
+DO NOT USE for: find single job (use find-job), execute job (use run-job), run job def (use run-jobdef), sas code (use run-sas-program)
 
-  Pagination Examples
-  - First page: { start:1, limit:10 }
-  - Next page:  { start:11, limit:10 }
+PARAMETERS
+- limit: number (default: 10) — number of jobs per page
+- start: number (default: 1) — 1-based page offset
+- where: string (default: '') — optional filter expression
 
-  Disambiguation & Clarification
-  - Input only "list" → ask: "List jobs? (Say 'list jobs' to proceed)" unless prior context indicates jobs listing.
-  - "find job X" → route to findJob instead.
-  - Input contains "run"/"execute" plus job name → route to job/jobdef.
+ROUTING RULES
+- list jobs → { start: 1, limit: 10 }
+- show me 25 jobs → { start: 1, limit: 25 }
+- next jobs → { start: previousStart + previousLimit, limit: previousLimit }
 
-  Negative Examples (should NOT call list-jobs)
-  - "find job abc" (find-job)
-  - "run job abc" (run-job)
-  - "job abc" (run-job)
-  - "find model xyz" (find-model)
-  - "list models" (list-models)
-  - "list tables in lib xyz" (list-tables)
-  - "show me libraries" (list-libraries)
-  - "describe job abc" (find-job then possibly run-job for execution)
+EXAMPLES
+- list jobs → { start: 1, limit: 10 }
+- list 25 jobs → { start: 1, limit: 25 }
+- next jobs → { start: 11, limit: 10 }
 
-  Error Handling
-  - On backend error: surface structured error payload (do not fabricate job names).
-  - Empty page (items.length === 0) with start > 1 may mean caller paged past end.
+NEGATIVE EXAMPLES (do not route here)
+- find job abc (use find-job)
+- run job abc (use run-job)
+- list models (use list-models)
+- list tables in lib xyz (use list-tables)
 
-  Usage Tips
-  - Increase limit for fewer round trips; keep reasonable to avoid large payloads.
-  - Combine with findJob for confirmation before execution.
+PAGINATION
+If returned length === limit, hint: next start = start + limit. Empty result with start > 1 means paged past end.
 
-  Examples (→ mapped params)
-  - "list jobs" → { start:1, limit:10 }
-  - "list 25 jobs" → { start:1, limit:25 }
-  - "next jobs" (after prior {start:1,limit:10}) → { start:11, limit:10 }
+ERRORS
+Surface backend error directly; never fabricate job names.
   `;
 
   let spec = {

package/src/toolSet/listLibraries.js

@@ -5,60 +5,50 @@
 import { z } from 'zod';
 import _listLibrary from '../toolHelpers/_listLibrary.js';
 function listLibraries(_appContext) {
- 
   let description = `
-  ## list-libraries — enumerate CAS or SAS libraries
-
-  LLM Invocation Guidance (critical)
-  Use THIS tool when the user asks for: "list libs", "list libraries", "show cas libs", "show sas libs", "what libraries are available", "list caslib(s)", "enumerate libraries", "libraries in cas", "libraries in sas".
-  DO NOT use this tool when the user asks for: tables inside a specific library (choose listTables), columns/metadata of a table, job/program execution, models, or scoring.
-
-  Trigger Phrase → Parameter Mapping
-  - "cas libs" / "in cas" / "cas libraries" → { server: 'cas' }
-  - "sas libs" / "in sas" / "base sas libraries" → { server: 'sas' }
-  - "next" (after prior call) → { start: previous.start + previous.limit }
-  - "first 20 cas libs" → { server: 'cas', limit: 20 }
-  - If server unspecified: default to CAS.
+list-libraries — enumerate CAS or SAS libraries.
 
-  Parameters
-  - server (cas|sas, default 'cas')
-  - limit (integer > 0, default 10)
-  - start (1-based offset, default 1)
-  - where (optional filter expression, default '')
+USE when user asks to: list/show/enumerate libraries, caslibs, sas libs, or available libraries.
+DO NOT USE for: listing tables in a library (→ list-tables), column/table metadata, job execution, models, scoring.
 
-  Response Contract
-  Return JSON-like structure from helper; consumers may extract an array of library objects/names. If number of returned items === limit supply a pagination hint: start = start + limit.
+PARAMETERS
+- server: 'cas' | 'sas' | 'all' (default: 'all')
+- limit: integer > 0 (default: 10)
+- start: 1-based offset (default: 1)
+- where: optional filter expression (default: '')
 
-  Behavior Summary
-  - Pure listing; no side effects.
-  - If ambiguous short request like "list" or "libs" and no prior context: assume { server: 'cas' }.
-  - If user explicitly asks for ALL (e.g. "all cas libs") and count likely large, honor limit=50 unless user supplies a value; include note about paging.
+ROUTING RULES
+- "cas libs / cas libraries / in cas"         → { server: 'cas' }
+- "sas libs / sas libraries / in sas"         → { server: 'sas' }
+- "all libs / all libraries"                  → { server: 'all' }
+- "list tables in <libname>"                  → route to list-tables, NOT here
+- server unspecified                          → default { server: 'all' }
+- "all cas libs" with no limit specified      → { server: 'cas', limit: 50 } + paging note
+- "next" after prior call (start:S, limit:L) → { start: S + L, limit: L }
+- ambiguous "list" or "libs" with no context → assume { server: 'cas' }
 
-  Disambiguation Rules
-  - If user mentions a singular library name plus desire for tables ("list tables in SASHELP") choose listTables (not this tool).
-  - If user mixes "tables" and "libraries" ask for clarification unless clearly about libraries.
+EXAMPLES
+- "list libraries"              → { server: 'all', start: 1, limit: 10 }
+- "list libs     "              → { server: 'all', start: 1, limit: 10 }
 
-  Examples
-  - "list libraries" → { server: 'cas', start:1, limit:10 }
-  - "list libs" → { server: 'cas', start:1, limit:10 }
-  - "list sas libs" → { server: 'sas' }
-  - "show me 25 cas libraries" → { server:'cas', limit:25 }
-  - "next" (after prior call {start:1,limit:10}) → { start:11, limit:10 }
-  - "filter cas libs" (no criterion) → ask: "Provide a filter or continue without one?"
+- "list all libs"               → { server: 'all', start: 1, limit: 10 }
+- "list cas libraries"          → { server: 'cas', start: 1, limit: 10 }
+- "show me 25 sas libs"         → { server: 'sas', limit: 25, start: 1 }
+- "next" (prev: start:1,limit:10) → { server: <same>, start: 11, limit: 10 }
+- "filter cas libs" (no filter given) → ask: "What filter expression should I apply?"
 
-  Negative Examples (do not route here)
-  - "list tables in public" (route to list-tables)
-  - "list models, list tables, list jobs, list jobdef and similar request"
-  - "describe library" (likely list-tables or table-info depending on follow-up)
-  - "run program to make a lib" (run-sas-program tool)
+NEGATIVE EXAMPLES (do not route here)
+- "list tables in SASHELP"      → list-tables
+- "list models / jobs / jobdefs"→ respective tools
+- "run a program to create a lib" → run-sas-program
 
-  Error Handling
-  - On backend error: return structured error with message field; do not hallucinate libraries.
-  - Empty result set → return empty list plus (if start>1) a hint that paging may have exceeded available items.
+PAGINATION
+If returned item count === limit, hint: next start = start + limit.
+If start > 1 and result is empty, note paging may have exceeded available items.
 
-  Rationale
-  Concise, signal-rich description increases probability this spec is selected for generic library enumeration intents.
-  `;
+ERRORS
+Return structured error with a message field. Never hallucinate library names.
+`;
 
 
   // Canonical kebab-case tool name; legacy aliases preserved for compatibility
@@ -69,7 +59,7 @@ function listLibraries(_appContext) {
     aliases: ['listLibraries','list libraries','list_libraries'],
     description: description,
     schema: {
-      server: z.string().default('cas'),
+      server: z.string().default('all'),
       limit: z.number().default(10),
       start: z.number().default(1), // added default to match documentation
       where: z.string().default('')
@@ -78,7 +68,7 @@ function listLibraries(_appContext) {
     required: [],
     handler: async (params) => {
       // normalize server just in case caller sends 'CAS'/'SAS'
-      params.server = (params.server || 'cas').toLowerCase();
+      params.server = (params.server || 'all').toLowerCase();
       
       let r = await _listLibrary(params);
       return r;

package/src/toolSet/listModels.js

@@ -8,59 +8,32 @@ import _listModels from '../toolHelpers/_listModels.js';
 
 function listModels(_appContext) {
   let description = `
-  ## list-models — enumerate models published to MAS (Model Publish / Scoring service)
+list-models — enumerate models published to MAS.
 
-  LLM Invocation Guidance (When to use)
-  Use THIS tool when the user wants a collection of models, e.g.:
-  - "list models"
-  - "show models"
-  - "list available models"
-  - "browse models"
-  - "list 25 models" / "list models limit 25"
-  - "next models" (after a previous page)
+USE when: list models, show models, browse models, next page
+DO NOT USE for: find model, model metadata, score model, list jobs/tables/libraries
 
-  Do NOT use this tool for:
-  - Checking a single model's existence (use find-model)
-  - Getting model metadata / variables (use model-info)
-  - Scoring a model (use model-score)
-  - list libraries, tables, jobs, or jobdefs (use respective list/find tools)
-  - Looking up jobs, libraries, tables, or SCR endpoints (route to respective tools)
+PARAMETERS
+- limit: number (default: 10) — page size
+- start: number (default: 1) — 1-based offset
 
-  Purpose
-  Provide a paginated view of MAS-registered models so the caller can then drill into one via modelInfo or score it.
+ROUTING RULES
+- "list models" → { start:1, limit:10 }
+- "list 25 models" → { start:1, limit:25 }
+- "next models" → { start: start+limit, limit:10 }
 
-  Parameters
-  - limit (number, default 10): Number of models to return for this page.
-  - start (number, default 1): 1-based offset. For paging: start = start + limit.
+EXAMPLES
+- "list models" → { start:1, limit:10 }
+- "list 25 models" → { start:1, limit:25 }
 
-  Response Contract
-  - Returns an array of model entries (names or metadata objects). Empty array if no models.
-  - If returned length === limit, caller may request the next page.
+NEGATIVE EXAMPLES (do not route here)
+- "find model X" (use find-model)
+- "describe model X" (use model-info)
+- "score model X" (use model-score)
+- "list jobs" (use list-jobs)
 
-  Pagination Examples
-  - First page: { start:1, limit:10 }
-  - Next page: { start:11, limit:10 }
-
-  Disambiguation & Clarification
-  - Input only "list" → ask: "List models? (Say 'list models' to proceed)" unless prior context strongly indicates models.
-  - "find model X" → use find-model instead.
-  - "score model X" → use model-score.
-  - "describe model X" → use model-info.
-
-  Negative Examples (should NOT call list-models)
-  - "find model churn" (find-model)
-  - "model info customerRisk" (model-info)
-  - "score model sales_pred" (model-score)
-  - "list jobs" (list-jobs)
-
-  Usage Tips
-  - Combine with findModel for narrowing down after a broad list.
-  - Increase limit judiciously; very large pages can impact latency.
-
-  Examples (→ mapped params)
-  - "list models" → { start:1, limit:10 }
-  - "list 25 models" → { start:1, limit:25 }
-  - "next models" (after prior {start:1,limit:10}) → { start:11, limit:10 }
+ERRORS
+Returns empty array if no models found.
   `;
 
   let spec = {