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

package/src/toolSet/listJobdefs.js

@@ -7,37 +7,71 @@ import _listJobdefs from '../toolHelpers/_listJobdefs.js';
 function listJobdefs(_appContext) {
 
   let description = `
-list-jobdefs — enumerate SAS Viya job definitions (jobdefs) assets.
+  ## list-jobdefs — enumerate SAS Viya job definitions assets(jobdefs)
 
-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)
+  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)
 
-PARAMETERS
-- limit: number (default: 10) — number of jobdefs per page
-- start: number (default: 1) — 1-based page offset
-- where: string (default: '') — optional filter expression
 
-ROUTING RULES
-- list jobdefs → { start: 1, limit: 10 }
-- show me 25 jobdefs → { start: 1, limit: 25 }
-- next jobdefs → { start: previousStart + previousLimit, limit: previousLimit }
+  Purpose
+  Page through jobdef assets deployed/registered in SAS Viya.
 
-EXAMPLES
-- list jobdefs → { start: 1, limit: 10 }
-- list 25 jobdefs → { start: 1, limit: 25 }
-- next jobdefs → { start: 11, limit: 10 }
+  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.
 
-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)
+  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.
 
-PAGINATION
-If returned length === limit, hint: next start = start + limit. Empty result with start > 1 means paged past end.
+  Pagination Examples
+  - First page: { start:1, limit:10 }
+  - Next page:  { start:11, limit:10 }
 
-ERRORS
-Surface backend error directly; never fabricate jobdef names.
+  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 }
   `;
 
   let spec = {

package/src/toolSet/listJobs.js

@@ -5,39 +5,87 @@
 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.
+  ## 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.
 
-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)
+  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.
 
-PARAMETERS
-- limit: number (default: 10) — number of jobs per page
-- start: number (default: 1) — 1-based page offset
-- where: string (default: '') — optional filter expression
+  Pagination Examples
+  - First page: { start:1, limit:10 }
+  - Next page:  { start:11, limit:10 }
 
-ROUTING RULES
-- list jobs → { start: 1, limit: 10 }
-- show me 25 jobs → { start: 1, limit: 25 }
-- next jobs → { start: previousStart + previousLimit, limit: previousLimit }
+  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.
 
-EXAMPLES
-- list jobs → { start: 1, limit: 10 }
-- list 25 jobs → { start: 1, limit: 25 }
-- next jobs → { start: 11, limit: 10 }
+  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)
 
-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)
+  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.
 
-PAGINATION
-If returned length === limit, hint: next start = start + limit. Empty result with start > 1 means paged past end.
+  Usage Tips
+  - Increase limit for fewer round trips; keep reasonable to avoid large payloads.
+  - Combine with findJob for confirmation before execution.
 
-ERRORS
-Surface backend error directly; never fabricate job names.
+  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 }
   `;
 
   let spec = {

package/src/toolSet/listLibraries.js

@@ -5,50 +5,60 @@
 import { z } from 'zod';
 import _listLibrary from '../toolHelpers/_listLibrary.js';
 function listLibraries(_appContext) {
+ 
   let description = `
-list-libraries — enumerate CAS or SAS libraries.
+  ## 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.
 
-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.
+  Parameters
+  - server (cas|sas, default 'cas')
+  - limit (integer > 0, default 10)
+  - start (1-based offset, default 1)
+  - where (optional filter expression, default '')
 
-PARAMETERS
-- server: 'cas' | 'sas' | 'all' (default: 'all')
-- limit: integer > 0 (default: 10)
-- start: 1-based offset (default: 1)
-- where: optional filter expression (default: '')
+  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.
 
-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' }
+  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.
 
-EXAMPLES
-- "list libraries"              → { server: 'all', start: 1, limit: 10 }
-- "list libs     "              → { server: 'all', start: 1, limit: 10 }
+  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.
 
-- "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?"
+  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?"
 
-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
+  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)
 
-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.
+  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.
 
-ERRORS
-Return structured error with a message field. Never hallucinate library names.
-`;
+  Rationale
+  Concise, signal-rich description increases probability this spec is selected for generic library enumeration intents.
+  `;
 
 
   // Canonical kebab-case tool name; legacy aliases preserved for compatibility
@@ -59,7 +69,7 @@ Return structured error with a message field. Never hallucinate library names.
     aliases: ['listLibraries','list libraries','list_libraries'],
     description: description,
     schema: {
-      server: z.string().default('all'),
+      server: z.string().default('cas'),
       limit: z.number().default(10),
       start: z.number().default(1), // added default to match documentation
       where: z.string().default('')
@@ -68,7 +78,7 @@ Return structured error with a message field. Never hallucinate library names.
     required: [],
     handler: async (params) => {
       // normalize server just in case caller sends 'CAS'/'SAS'
-      params.server = (params.server || 'all').toLowerCase();
+      params.server = (params.server || 'cas').toLowerCase();
       
       let r = await _listLibrary(params);
       return r;

package/src/toolSet/listModels.js

@@ -8,32 +8,59 @@ import _listModels from '../toolHelpers/_listModels.js';
 
 function listModels(_appContext) {
   let description = `
-list-models — enumerate models published to MAS.
+  ## list-models — enumerate models published to MAS (Model Publish / Scoring service)
 
-USE when: list models, show models, browse models, next page
-DO NOT USE for: find model, model metadata, score model, list jobs/tables/libraries
+  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)
 
-PARAMETERS
-- limit: number (default: 10) — page size
-- start: number (default: 1) — 1-based offset
+  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)
 
-ROUTING RULES
-- "list models" → { start:1, limit:10 }
-- "list 25 models" → { start:1, limit:25 }
-- "next models" → { start: start+limit, limit:10 }
+  Purpose
+  Provide a paginated view of MAS-registered models so the caller can then drill into one via modelInfo or score it.
 
-EXAMPLES
-- "list models" → { start:1, limit:10 }
-- "list 25 models" → { start:1, limit:25 }
+  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.
 
-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)
+  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.
 
-ERRORS
-Returns empty array if no models found.
+  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 }
   `;
 
   let spec = {

package/src/toolSet/listTables.js

@@ -12,35 +12,64 @@ function listTables(_appContext) {
   const log = debug('tools');
 
     let description = `
-list-tables — enumerate tables within a library.
-
-USE when: list tables in <lib>, show tables in <lib>, next page
-DO NOT USE for: find table, list libraries, get table structure (use table-info), read data (use read-table)
-
-PARAMETERS
-- lib: string — library to inspect (required)
-- server: string (default: 'cas') — 'cas' or 'sas'
-- limit: number (default: 10) — page size
-- start: number (default: 1) — 1-based offset
-- where: string — optional filter expression
-
-ROUTING RULES
-- "list tables in Samples" → { lib: "Samples", start: 1, limit: 10 }
-- "list 25 tables in sashelp" → { lib: "sashelp", limit: 25, start: 1 }
-- "list cas tables in Public" → { lib: "Public", server: "cas", start: 1, limit: 10 }
-
-EXAMPLES
-- "list tables in Samples" → { lib: "Samples", start: 1, limit: 10 }
-- "show 25 tables in sashelp" → { lib: "sashelp", limit: 25, start: 1 }
-
-NEGATIVE EXAMPLES (do not route here)
-- "list libs" (use list-libraries)
-- "find lib Public" (use find-library)
-- "describe table cars" (use table-info)
-- "read table cars" (use read-table)
-
-ERRORS
-Returns empty array if no tables found.
+    ## list-tables — enumerate tables within a specific CAS or SAS library
+
+  LLM Invocation Guidance (When to use)
+  Use THIS tool when the user explicitly wants the tables inside ONE library:
+  - "list tables in Samples"
+  - "show tables in sashelp"
+  - "list cas tables in Public"
+  - "list 25 tables in Samples"
+  - "next tables" (after a prior listTables call)
+
+  Do NOT use this tool to list the following
+  - lib -> use list-libraries
+  - list models -> use list-models
+  - list jobs -> use list-jobs
+  - list jobdefs -> use list-jobdefs
+  - Finding whether a library exists (use find-library)
+  - Describing a single table's columns or metadata (use table-info)
+  - Reading table data rows (use read-table)
+  - Listing jobs/models (other specialized tools)
+
+  Purpose
+  Return the names (and possibly lightweight metadata) of tables contained in a specified library (CAS caslib or SAS libref).
+
+  Parameters
+  - lib (string, required): Library to inspect (e.g. "Samples", "sashelp").
+  - server (cas|sas, default 'cas'): Target environment; default when unspecified is CAS.
+  - limit (number, default 10): Page size.
+  - start (number, default 1): 1-based offset for pagination.
+  - where (string, optional): Filter expression (if supported by backend) or ignored safely.
+
+  Response Contract
+  - JSON: { tables: string[] [, start:number]? }
+  - tables array is empty when no matches.
+  - Include start = start + limit when length === limit (possible more pages).
+
+  Pagination Examples
+  - First page: { lib:'Samples', start:1, limit:10 }
+  - Next page:  { lib:'Samples', start:11, limit:10 }
+
+  Disambiguation & Clarification
+  - Missing library name → ask: "Which library do you want to list tables from?"
+  - Input only "list tables" → ask for the library unless prior context supplies one.
+  - If user mentions multiple libs ("tables in Public and Samples") → request a single library.
+
+  Negative Examples (should NOT call list-tables)
+  - "list libs" (list-libraries)
+  - "find lib Public" (find-library)
+  - "describe table cars" (table-info)
+  - "read table cars from sashelp" (read-table)
+
+  Usage Tips
+  - After listing, call table-info to inspect structure or read-table for sample data.
+  - Keep limit moderate; page for very large libraries.
+
+  Examples (→ mapped params)
+  - "list tables in samples" → { lib:"samples", start:1, limit:10 }
+  - "show 25 tables in sashelp" → { lib:"sashelp", limit:25, start:1 }
+  - "next tables" (after previous {start:1,limit:10}) → { start:11, limit:10, lib:<previousLib> }
   `;
     
   let spec = {

package/src/toolSet/makeTools.js

@@ -30,7 +30,6 @@ import findJobdef from './findJobdef.js';
 
 import sasQuery from './sasQuery.js';
 import setContext from './setContext.js';
-//import scoreSkill from './scoreSkill.js';
 
 function makeTools(_appContext) {
   // wrap all tools with 
@@ -65,8 +64,6 @@ function makeTools(_appContext) {
     findJobdef(_appContext),
     runJobdef(_appContext),
 
-    //scoreSkill(_appContext),
-
     devaScore(_appContext),
     setContext(_appContext)
     

package/src/toolSet/modelInfo.js

@@ -10,32 +10,63 @@ const log = debug('tools');
 
 function modelInfo(_appContext) {
   let description = `
-model-info — retrieve detailed metadata for a deployed model.
+## model-info — retrieve detailed metadata for a deployed model
 
-USE when: what inputs does model need, describe model, show variables for model, model inputs/outputs
-DO NOT USE for: find model, list models, score model, table/job operations
+LLM Invocation Guidance (When to use)
+Use THIS tool when:
+- User wants input/output variable information: "What inputs does model X need?"
+- User wants to understand model variables: "Describe model myModel"
+- User wants data types and roles: "Show me the variables for myModel"
+- User wants to prepare data for scoring: "What are the required inputs for model sales_forecast?"
 
-PARAMETERS
-- model: string — model name (required, exact match)
+Do NOT use this tool for:
+- Checking if a model exists (use find-model)
+- Listing available models (use list-models)
+- Scoring a model (use model-score)
+- Looking up tables or jobs (use respective find/list tools)
 
-ROUTING RULES
-- "what inputs does model X need?" → { model: "X" }
-- "describe model Y" → { model: "Y" }
-- "show variables for Z" → { model: "Z" }
+Purpose
+Retrieve detailed metadata for a model deployed to MAS (Model Aggregation Service). This includes input variable names, data types, roles/usage, ranges, and output variable information. Use this before scoring to understand what data the model requires.
 
-EXAMPLES
+Parameters
+- model (string, required): The name of the model as published to MAS. Must be exact match.
+
+Response Contract
+Returns a JSON object containing model metadata, typically including:
+- name: The model name
+- inputs: Array of input variable objects with:
+  - name: Variable name
+  - type: Data type (numeric, character, etc.)
+  - role: Role in model (input, key, etc.)
+  - allowed_values or range: Optional constraints
+- outputs: Array of output/prediction objects with:
+  - name: Prediction/output variable name
+  - type: Data type
+  - possible_values: For classification models, the class labels
+- model_type: Type of model (regression, classification, etc.)
+- description: Optional model description
+
+Disambiguation & Clarification
+- If model name is missing: ask "Which model would you like to see information for?"
+- If user says "variables" without specifying model: ask "Which model would you like the variables for?"
+- Multiple model requests: handle one at a time
+
+Examples (→ mapped params)
 - "What inputs does model churnRisk need?" → { model: "churnRisk" }
 - "Describe model creditScore" → { model: "creditScore" }
-- "Show variables for myModel" → { model: "myModel" }
+- "Show the variables for myModel" → { model: "myModel" }
+- "What are the outputs of model sales_forecast?" → { model: "sales_forecast" }
 
-NEGATIVE EXAMPLES (do not route here)
-- "list models" (use list-models)
-- "find model X" (use find-model)
-- "score with model X" (use model-score)
+Negative Examples (should NOT call model-info)
+- "List all available models" (use list-models instead)
+- "Find model cancer" (use find-model instead)
+- "Score this customer with model churnRisk" (use model-score instead)
 
-ERRORS
-Returns model metadata: inputs (name, type, role), outputs (name, type, possible_values), model_type, description.
-  `;
+Related Tools
+- list-models → find-model → model-info → model-score (typical workflow)
+- find-model — to check if a specific model exists
+- model-score — to score data using the model
+`;
 
   let spec = {
     name: 'model-info',