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

package/src/toolSet/sasQuery.js

@@ -5,38 +5,85 @@
 import {z} from 'zod';
 import _jobSubmit from '../toolHelpers/_jobSubmit.js';
 
+
 function sasQuery() {
  
     let description = `
-sas-query — convert natural language questions into SQL queries and execute them.
+## sas-query — convert natural language questions into SQL queries and execute them
+
+LLM Invocation Guidance (When to use)
+Use THIS tool when:
+- User asks a natural language question about table data: "how many customers by region?"
+- User wants aggregated analytics: "show total sales by year"
+- User needs complex filtering: "find all orders over $1000 from last month"
+- User requests joined data: "show products with their category names"
+- User wants statistical summaries: "average, min, max salary by department"
+- User asks for specific calculations: "percentage of customers by state"
+
+Do NOT use this tool for:
+- Reading raw table data without filtering (use read-table)
+- Getting table structure or column info (use table-info)
+- Running pre-written SAS programs (use run-sas-program)
+- Running jobs or job definitions (use run-job or run-jobdef)
+- Executing macros (use run-macro)
+- Simple table reads with no aggregation (use read-table)
+
+Purpose
+Convert natural language queries into SAS PROC SQL SELECT statements and execute them to retrieve analyzed data. The LLM generates the SQL from the natural language query, and this tool executes it against the specified table.
+
+Parameters
+- table (string, required): Table name in lib.table format (e.g., "Public.cars", "sashelp.class")
+- query (string, required): Natural language description of what data you want
+- sql (string, optional): Pre-generated SQL SELECT statement (LLM should generate this from the query)
+- job (string, default 'program'): Job name to execute the query (default is 'program')
+
+Behavior & Processing
+- LLM converts the natural language query into a valid SAS PROC SQL SELECT statement
+- Do not add semicolons to the end of SQL statements
+- SQL reference: https://go.documentation.sas.com/doc/en/pgmsascdc/v_067/sqlproc/n0w2pkrm208upln11i9r4ogwyvow.htm
+- Tool executes the generated SQL against the specified table
+- Returns data in JSON format
 
-USE when: how many/count/total/average by, aggregated analytics, complex filtering, statistical summaries
-DO NOT USE for: raw reads without filtering (use read-table), table structure (use table-info), SAS programs (use run-sas-program), jobs/jobdefs
+Response Contract
+Returns a JSON object containing:
+- rows: Array of row objects with query results
+- columns: Column metadata from the query result
+- log: Execution log if available
+- If error: structured error message
+- If more than 10 rows: only first 10 displayed (ask user if they want more)
 
-PARAMETERS
-- table: string — table in lib.table format (required), e.g. "Public.cars" or "sashelp.class"
-- query: string — natural language question (required)
-- sql: string — pre-generated SQL SELECT (optional, LLM generates)
-- job: string (default: 'program') — job name to execute
+Disambiguation & Clarification
+- If table missing: ask "Which table should I query (format: lib.tablename)?"
+- If query too vague: ask "Can you be more specific about what data or calculation you want?"
+- If table format unclear: ask "Please specify table as library.tablename (e.g., Public.cars)"
+- If ambiguous calculation: ask for clarification on what to aggregate or filter
 
-ROUTING RULES
-- "how many cars by make in sashelp.cars" → { table: "sashelp.cars", query: "how many cars by make", sql: "SELECT make, COUNT(*) FROM sashelp.cars GROUP BY make" }
-- "average salary by department in Public.employees" → { table: "Public.employees", query: "average salary by department", sql: "SELECT department, AVG(salary) FROM Public.employees GROUP BY department" }
+Examples (→ mapped params)
+- "how many cars by make in sashelp.cars" → { table: "sashelp.cars", query: "how many cars by make", sql: "SELECT make, COUNT(*) AS count FROM sashelp.cars GROUP BY make" }
+- "average horsepower by origin" → { table: "sashelp.cars", query: "average horsepower by origin", sql: "SELECT origin, AVG(horsepower) AS avg_hp FROM sashelp.cars GROUP BY origin" }
+- "total sales over $1000 by region" → { table: "mylib.sales", query: "total sales over $1000 by region", sql: "SELECT region, SUM(amount) AS total FROM mylib.sales WHERE amount > 1000 GROUP BY region" }
+- "percentage of students by year in Public.students" → { table: "Public.students", query: "percentage by year", sql: "SELECT year, COUNT(*) * 100.0 / (SELECT COUNT(*) FROM Public.students) AS pct FROM Public.students GROUP BY year" }
 
-EXAMPLES
-- "how many cars by make in sashelp.cars" → { table: "sashelp.cars", query: "how many cars by make", sql: "SELECT make, COUNT(*) FROM sashelp.cars GROUP BY make" }
-- "total sales by region from mylib.sales" → { table: "mylib.sales", query: "total sales by region", sql: "SELECT region, SUM(amount) FROM mylib.sales GROUP BY region" }
+Negative Examples (should NOT call sas-query)
+- "read table cars from sashelp" (use read-table instead)
+- "show me 10 rows from customers" (use read-table instead)
+- "what columns are in the sales table?" (use table-info instead)
+- "run this SAS code: proc sql; select * from..." (use run-sas-program instead)
+- "execute job monthly_report" (use run-job instead)
+- "run macro summarize_data" (use run-macro instead)
 
-NEGATIVE EXAMPLES (do not route here)
-- "read table cars" (use read-table)
-- "show 10 rows" (use read-table)
-- "table structure" (use table-info)
-- "run SAS code" (use run-sas-program)
-- "run job/macro" (use run-job/run-macro)
+Usage Tips
+- Ensure table is specified in lib.tablename format
+- Be specific in natural language queries for better SQL generation
+- Use table-info first to understand column names and types
+- For simple reads without filtering/aggregation, prefer read-table
 
-ERRORS
-Returns rows array, columns metadata, log. Returns error if SQL invalid or table not found.
-  `;
+Related Tools
+- read-table — for simple data reading without SQL queries
+- table-info — to inspect table schema before querying
+- run-sas-program — for executing pre-written SAS/SQL code
+- find-table — to verify table exists before querying
+`;
 
 
     let spec = {

package/src/toolSet/scrInfo.js

@@ -15,7 +15,7 @@ Purpose
 Return the input/output schema and metadata for an SCR (Score Code Runtime) model.
 
 Inputs
-- url (string): The SCR model identifier. 
+- name (string): The SCR model identifier. 
 What it returns
 - A JSON object describing the model's interface, typically including:
   - Input variables (names, types, required/optional)
@@ -23,6 +23,7 @@ What it returns
   
 
 Usage notes
+- If no local mapping exists and \`name\` looks like a URL, the tool will attempt to fetch the schema from that URL.
 - Ensure network connectivity and credentials for the remote SCR service when needed.
 - Use scr-score to score data after inspecting the schema.
 
@@ -36,9 +37,9 @@ Examples
     aliases: ['scrInfo','scr info','scr_info'],
     description: description,
     schema: {
-      url: z.string(),
+      name: z.string(),
     },
-    required: ['url'],
+    required: ['name'],
     handler: async (params) => {
       let {url, _appContext} = params;
       if (url === null) {

package/src/toolSet/setContext.js

@@ -7,34 +7,60 @@ import {z} from 'zod';
 
 function setContext(_appContext) {
     let description = `
-set-context — set the CAS and SAS server contexts for subsequent tool calls.
+## set-context — set the CAS and SAS server contexts for subsequent tool calls
 
-USE when: switch to CAS server, change compute context, check current context, set both
-DO NOT USE for: get variables (use get-env), read data (use read-table), run programs (use run-sas-program)
+LLM Invocation Guidance (When to use)
+Use THIS tool when:
+- User wants to switch to a different CAS server: "Use the finance-cas-server"
+- User wants to change the compute context: "Switch to 'SAS Studio Compute Context'"
+- User wants to check current context: "What context am I using?"
+- User wants to set both: "Use finance-cas-server for CAS and my-compute for SAS"
 
-PARAMETERS
-- cas: string — CAS server name (optional), e.g. 'cas-shared-default', 'finance-cas-server'
-- sas: string — SAS compute context (optional), e.g. 'SAS Studio Compute Context', 'batch-compute'
+Do NOT use this tool for:
+- Retrieving variable values (use get-env)
+- Reading table data (use read-table)
+- Running programs or queries (use run-sas-program or sas-query)
+- Listing available servers or contexts (no tool for this; would require backend support)
 
-ROUTING RULES
-- "use finance-cas-server" → { cas: "finance-cas-server" }
-- "switch to SAS Studio Compute Context" → { sas: "SAS Studio Compute Context" }
-- "use finance-cas for CAS and batch-compute for SAS" → { cas: "finance-cas", sas: "batch-compute" }
-- "what context am I using" → { } (no params, returns current)
+Purpose
+Set the active CAS server and/or SAS compute context for all subsequent tool calls in this session. This allows switching between different server environments. If neither parameter is provided, the tool returns the current context values.
 
-EXAMPLES
-- "use finance-cas-server" → { cas: "finance-cas-server" }
-- "switch to batch-compute" → { sas: "batch-compute" }
-- "what's my current context" → { }
+Parameters
+- cas (string, optional): The name of the CAS server to use for subsequent CAS operations. Examples: 'cas-shared-default', 'finance-cas-server', 'analytics-cas'
+- sas (string, optional): The name of the SAS compute context to use for subsequent SAS operations. Examples: 'SAS Studio Compute Context', 'my-compute', 'batch-compute'
 
-NEGATIVE EXAMPLES (do not route here)
-- "read table cars" (use read-table)
-- "what's the value of X" (use get-env)
-- "run program" (use run-sas-program)
+Response Contract
+Returns a JSON object containing:
+- cas: The current/new CAS server name (string or null)
+- sas: The current/new SAS compute context name (string or null)
+- If no parameters provided, returns the current context values
+- If parameters provided, updates and returns the new context values
+- On error: error message if context cannot be set (e.g., invalid server name)
 
-ERRORS
-Returns current or updated context values {cas, sas}. Error if server not found or invalid name.
-  `;
+Disambiguation & Clarification
+- If user says "switch servers" without specifying which: ask "Which server would you like to use: CAS, SAS, or both?"
+- If user provides a server name that may not exist: proceed with setting it (the backend will validate)
+- If user says "reset context": ask "Should I reset the CAS context, SAS context, or both?"
+- If user only says "context": ask "Would you like to check the current context or set a new one?"
+
+Examples (→ mapped params)
+- "Use the finance-cas-server" → { cas: "finance-cas-server" }
+- "Switch to SAS Studio Compute Context" → { sas: "SAS Studio Compute Context" }
+- "Set CAS to prod-cas and SAS to batch-compute" → { cas: "prod-cas", sas: "batch-compute" }
+- "What's my current context?" → { } (no parameters returns current context)
+- "Show me the active CAS server" → { } (no parameters returns current context)
+
+Negative Examples (should NOT call set-context)
+- "Read 10 rows from the customers table" (use read-table instead)
+- "What's the value of myVariable?" (use get-env instead)
+- "Run this SAS program" (use run-sas-program instead)
+
+Related Tools
+- get-env — to retrieve individual environment variable values
+- read-table — to read data using the current context
+- run-sas-program — to execute SAS programs in the current context
+- sas-query — to execute SQL queries in the current context
+`;
   
     let spec = {
         name: 'set-context',

package/src/toolSet/tableInfo.js

@@ -9,34 +9,77 @@ import _tableInfo  from '../toolHelpers/_tableInfo.js';
 function tableInfo(_appContext) {
 
      let describe = `
-table-info — retrieve metadata about a table in a CAS or SAS library.
-
-USE when: what columns, describe structure, show schema, table statistics, column info
-DO NOT USE for: read data (use read-table), list tables (use list-tables), find table (use find-table), queries (use sas-query)
-
-PARAMETERS
-- table: string — table name (required)
-- lib: string — caslib or libref (required)
-- server: string (default: 'cas') — 'cas' or 'sas'
-
-ROUTING RULES
-- "what columns are in cars" → { table: "cars", lib: "<lib>", server: "cas" }
-- "describe table sales in Public" → { table: "sales", lib: "Public", server: "cas" }
-- "show schema for mylib.iris on sas" → { table: "iris", lib: "mylib", server: "sas" }
-
-EXAMPLES
-- "what columns in cars" → { table: "cars", lib: "<lib>", server: "cas" }
-- "describe structure of customers in Public" → { table: "customers", lib: "Public", server: "cas" }
-
-NEGATIVE EXAMPLES (do not route here)
-- "read table cars" (use read-table)
-- "list tables in Public" (use list-tables)
-- "does table exist" (use find-table)
-- "query table" (use sas-query)
-
-ERRORS
-Returns columns array (name, type, label, format, length) and tableInfo (rowCount, fileSize, created, modified).
-  `;
+## table-info — retrieve metadata about a table in a CAS or SAS library
+
+LLM Invocation Guidance (When to use)
+Use THIS tool when:
+- User wants table structure/schema: "what columns are in the cars table?"
+- User wants column metadata: "describe the structure of customers table"
+- User wants to see data types: "show me the schema for sales table in Public"
+- User wants table statistics: "how many rows in the orders table?"
+- User wants column information: "what are the columns in the iris table?"
+
+Do NOT use this tool for:
+- Reading actual data rows (use read-table)
+- Listing tables in a library (use list-tables)
+- Checking if a table exists (use find-table)
+- Running queries (use sas-query)
+- Reading sample data (use read-table)
+
+Purpose
+Return metadata about a table in a specified library (caslib or libref). This includes column names, data types, labels, formats, and table-level statistics such as row count, file size, and timestamps.
+
+Parameters
+- table (string, required): The name of the table to inspect.
+- lib (string, required): The caslib or libref containing the table.
+- server (string, default 'cas'): Target server, either 'cas' or 'sas'. Defaults to 'cas' when omitted.
+
+Response Contract
+Returns a JSON object containing:
+- columns: Array of column objects with:
+  - name: Column name (string)
+  - type: Data type (string) - e.g., 'numeric', 'character'
+  - label: Column label if defined (string)
+  - format: Display format if defined (string)
+  - length: Column length for character fields (number)
+- tableInfo: Table-level metadata including:
+  - rowCount: Number of rows (number)
+  - fileSize: File size if available (number)
+  - created: Creation timestamp if available (string)
+  - modified: Last modified timestamp if available (string)
+- Empty object if table not found or accessible
+
+Disambiguation & Clarification
+- Missing library: ask "Which library contains the table you want to inspect?"
+- Missing table: ask "Which table would you like information about?"
+- If user wants data: clarify "Do you want the table structure (use table-info) or actual data rows (use read-table)?"
+- Ambiguous lib.table format: parse and use as separate parameters
+
+Examples (→ mapped params)
+- "describe table cars in sashelp" → { table: "cars", lib: "sashelp", server: "sas" }
+- "what columns are in orders from Public" → { table: "orders", lib: "Public", server: "cas" }
+- "show schema for sales in mylib" → { table: "sales", lib: "mylib", server: "cas" }
+- "table info for iris in Samples" → { table: "iris", lib: "Samples", server: "cas" }
+- "how many rows in customers on cas" → { table: "customers", lib: <lib>, server: "cas" }
+
+Negative Examples (should NOT call table-info)
+- "read 10 rows from cars" (use read-table instead)
+- "list tables in sashelp" (use list-tables instead)
+- "does table cars exist in Public?" (use find-table instead)
+- "run query on customers table" (use sas-query instead)
+- "show me data from the sales table" (use read-table instead)
+
+Usage Tips
+- Use this tool to inspect schema and column types before scoring or reading data.
+- After inspecting structure, use read-table to fetch actual data.
+- Combine with find-table to verify existence before inspection.
+
+Related Tools
+- find-table → table-info → read-table (typical workflow)
+- list-tables — to discover tables before inspecting
+- read-table — to fetch actual data after inspecting structure
+- find-table — to verify a table exists before inspection
+`;
    
     let  specs = {
       name: 'table-info',

package/skills/mcp-tool-description-optimizer/SKILL.md

@@ -1,129 +0,0 @@
----
-name: mcp-tool-description-optimizer
-description: >
-  Optimize MCP (Model Context Protocol) tool descriptions for token efficiency and LLM routing accuracy.
-  Use this skill whenever a user shares a raw, verbose, or poorly structured MCP tool description and wants
-  it improved, rewritten, or reviewed. Trigger on phrases like: "optimize this tool description",
-  "rewrite my MCP tool description", "make this tool description more efficient", "clean up my tool spec",
-  "improve how Claude picks my tool", or when a user pastes a JavaScript/TypeScript tool description string
-  and asks for help with it. Also trigger when the user mentions token efficiency, tool routing,
-  or LLM disambiguation in the context of MCP servers.
----
-
-# MCP Tool Description Optimizer
-
-Rewrites verbose or poorly structured MCP tool descriptions into compact, signal-rich versions that
-improve LLM tool selection accuracy while reducing token usage.
-
-## Why this matters
-
-Claude and other LLMs select MCP tools based entirely on the `description` field. Descriptions that are
-too long, redundant, or badly structured waste context tokens and reduce routing precision.
-A well-optimized description:
-- States what the tool does and when to use it upfront
-- Eliminates redundancy (same info repeated across sections)
-- Uses a compact, scannable format (labeled blocks, not nested markdown)
-- Includes clear negative examples to prevent mis-routing
-- Keeps parameters terse — name, type, default, one-line purpose
-
----
-
-## Optimization Process
-
-### Step 1 — Analyze the input description
-
-Before rewriting, identify these problems in the original:
-
-| Problem | Example |
-|---|---|
-| **Redundancy** | Trigger phrases listed in 3+ places |
-| **Filler sections** | "Rationale", "Behavior Summary", "Response Contract" with no routing signal |
-| **Orphaned syntax** | Arrows (`→`) or bullets with no target |
-| **Overlong examples** | Long prose examples when one-liners suffice |
-| **Heavy markdown** | `##` headers for every minor point |
-| **Duplicated parameter docs** | Same param described in both a table and prose |
-
-Call out 2–4 of the most impactful issues before writing the new version.
-
-### Step 2 — Rewrite using the standard template
-
-Use this exact block structure for the output. Omit blocks that don't apply.
-
-```
-<tool-name> — <one-line purpose>.
-
-USE when: <comma-separated user intents or trigger phrases>
-DO NOT USE for: <comma-separated anti-patterns with → redirect where applicable>
-
-PARAMETERS
-- <name>: <type> (default: <val>) — <one-line purpose>
-...
-
-ROUTING RULES
-- "<trigger phrase>" → { param: value }
-- "<trigger phrase>" → { param: value }
-- <ambiguous case> → <ask for clarification | default behavior>
-
-EXAMPLES
-- "<user utterance>" → { param: value, ... }
-- "<user utterance>" → { param: value, ... }
-
-NEGATIVE EXAMPLES (do not route here)
-- "<user utterance>" → <correct tool>
-
-PAGINATION (include only if tool is paginated)
-If returned count === limit → hint: next start = start + limit.
-If start > 1 and result empty → note paging may exceed available items.
-
-ERRORS
-<One or two lines: return structure, hallucination policy>
-```
-
-### Step 3 — Apply these rules consistently
-
-**USE/DO NOT USE block**
-- Write as comma-separated inline list, not a bullet list
-- DO NOT USE entries should name the redirect tool in parentheses where known
-
-**ROUTING RULES block**
-- One rule per line; quote the trigger phrase; use `→ { }` for param mapping
-- Consolidate synonyms on one line: `"cas libs / cas libraries / in cas" → { server: 'cas' }`
-- List the default/fallback rule last
-
-**PARAMETERS block**
-- One line per param: `- name: type (default: val) — purpose`
-- Skip obvious params (e.g. don't explain what `limit` means if it's standard pagination)
-
-**EXAMPLES block**
-- Each example fits on one line
-- For "next page" examples, include the prior call's state inline: `"next" (prev: start:1, limit:10) → { start: 11, limit: 10 }`
-
-**NEGATIVE EXAMPLES block**
-- Only include when mis-routing is a real risk
-- Format: `"<utterance>" → <correct-tool-name>`
-
-**Tone**
-- Imperative, terse. No filler words ("Please note that...", "It is important to...")
-- Never include a "Rationale" or "Behavior Summary" section — if behavior matters, encode it as a rule
-
-### Step 4 — Validate before returning
-
-Check the rewritten description against this list:
-
-- [ ] No trigger phrase appears in more than one block
-- [ ] No orphaned `→` arrows or dangling bullets
-- [ ] Parameter defaults are stated explicitly
-- [ ] Negative examples cover the tool's most common mis-routing risks
-- [ ] Total length is ≤ 50% of the original (target: 30–40% reduction)
-
----
-
-## Output format
-
-Always return:
-
-1. **Analysis** — 2–4 bullet points naming the key issues found in the original
-2. **Rewritten description** — inside a JavaScript code block (matching the user's original code style)
-3. **Change summary** — a short table or bullet list of what changed and why
-
-See `references/examples.md` for before/after examples of real tool descriptions.

package/skills/mcp-tool-description-optimizer/references/examples.md

@@ -1,123 +0,0 @@
-# Before / After Examples
-
-## Example 1 — list-libraries (SAS Viya MCP)
-
-### BEFORE (~620 tokens)
-
-```
-## 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' }
-- "all libs" / "all libs" -> {server: 'all'}
-→ { server: 'all' }
-- "next" (after prior call) → { start: previous.start + previous.limit }
-- "first 20 cas libs" → { server: 'cas', limit: 20 }
-- If server unspecified: default to all.
-
-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.
-
-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.
-
-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 }
-- "list sas libs" → { server: 'sas' }
-- "list cas libraries" → { server: 'cas' }
-- "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 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)
-
-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.
-
-Rationale
-Concise, signal-rich description increases probability this spec is selected for generic library
-enumeration intents.
-```
-
-### AFTER (~210 tokens)
-
-```
-list-libraries — enumerate CAS or SAS libraries.
-
-USE when: list/show/enumerate libraries, caslibs, sas libs, available libraries
-DO NOT USE for: listing tables in a library (→ list-tables), column/table metadata, job execution, models, scoring
-
-PARAMETERS
-- server: 'cas' | 'sas' | 'all' (default: 'all')
-- limit: integer > 0 (default: 10)
-- start: 1-based offset (default: 1)
-- where: optional filter expression (default: '')
-
-ROUTING RULES
-- "cas libs / cas libraries / in cas"          → { server: 'cas' }
-- "sas libs / sas libraries / in sas"          → { server: 'sas' }
-- "all libs / all libraries"                   → { server: 'all' }
-- "all cas libs" with no limit given           → { server: 'cas', limit: 50 } + paging note
-- "next" after prior call (start:S, limit:L)   → { start: S + L, limit: L }
-- "filter cas libs" with no filter given       → ask: "What filter expression should I apply?"
-- server unspecified / ambiguous "list"/"libs" → { server: 'cas' }
-
-EXAMPLES
-- "list libraries"                → { 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 }
-
-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
-
-PAGINATION
-If returned count === limit → hint: next start = start + limit.
-If start > 1 and result empty → note paging may exceed available items.
-
-ERRORS
-Return structured error with message field. Never hallucinate library names.
-```
-
-**Token reduction: ~66%**
-
----
-
-## Key patterns illustrated
-
-- Trigger phrases consolidated from 3 blocks → 1 ROUTING RULES block
-- "Rationale", "Behavior Summary", "Response Contract" sections eliminated
-- Orphaned `→ { server: 'all' }` arrow removed
-- Parameter defaults made explicit inline
-- Examples trimmed to one line each
-- Negative examples now name the redirect tool explicitly