@sassoftware/sas-score-mcp-serverjs 0.4.1-20 → 0.4.1-21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sassoftware/sas-score-mcp-serverjs",
-  "version": "0.4.1-20",
+  "version": "0.4.1-21",
   "description": "A mcp server for SAS Viya",
   "author": "Deva Kumar <deva.kumar@sas.com>",
   "license": "Apache-2.0",

package/skills/sas-find-library-smart/SKILL.md

@@ -78,6 +78,23 @@ ELSE
 
 ---
 
+## Table Reference Format
+
+When users follow up to find or work with tables, they may provide a reference in dot notation (e.g., "find table cars in Public" or "maps.india"). 
+
+**Always parse table references as: `lib.table`**
+- First part (before dot) = **library name** → `lib` parameter
+- Second part (after dot) = **table name** → `name` or `table` parameter
+
+**Examples:**
+- "maps.india" → `lib: "maps"`, `name: "india"`
+- "Public.customers" → `lib: "Public"`, `name: "customers"`
+- "sashelp.cars" → `lib: "sashelp"`, `name: "cars"`
+
+This rule ensures consistent parsing when users reference tables in subsequent operations after finding a library.
+
+---
+
 ## Common patterns
 
 **Pattern 1 — Find library, server unspecified**

package/skills/sas-read-strategy/SKILL.md

@@ -36,6 +36,21 @@ Use `sas-score-find-table` with intelligent server detection:
 
 ---
 
+## Table Reference Format
+
+When a user provides a table reference in dot notation (e.g., "read maps.india" or "find table cars.Public"):
+
+**Always parse as: `lib.table`**
+- First part (before dot) = **library name** → `lib` parameter
+- Second part (after dot) = **table name** → `name` or `table` parameter
+
+**Examples:**
+- "maps.india" → `lib: "maps"`, `name: "india"`
+- "Public.customers" → `lib: "Public"`, `name: "customers"`
+- "sashelp.cars" → `lib: "sashelp"`, `name: "cars"`
+
+---
+
 ## Determine the read strategy
 
 Ask yourself: does the user already have the data in hand?

package/skills/sas-score-workflow/SKILL.md

@@ -1,11 +1,11 @@
-gi ---
+---
 name: sas-score-workflow
 description: >
-  Guide the full model scoring workflow: validate model familiarity, route to appropriate scoring tool 
-  based on model type, invoke scoring with scenario data, and present merged results. Use this skill 
-  when the user wants to run predictions on data (already fetched or user-supplied). Supports generic 
-  syntax: "score with model <name>.<type> scenario =<params>" where type is job|jobdef|mas|scr|sas.
-  Trigger phrases: "score these records", "predict using model", "run model on", "score with model X.mas".
+  MANDATORY routing logic for all scoring requests. Extract model.type suffix, route to correct tool 
+  (run-job|run-jobdef|model-score|scr-score|run-program). Complete routing decision BEFORE invoking 
+  any tool. Handles both MAS models and alternative scoring engines (jobs, jobdefs, SCR, SAS programs).
+  Trigger phrases: "score with model X.job", "score X.jobdef scenario", "score with model X.mas", 
+  "score with model X.scr", any request with "score" + model name containing a dot (.) + type suffix.
 ---
 
 # SAS Score Workflow
@@ -35,6 +35,91 @@ If no type is specified (bare model name), assume `.mas` (MAS model).
 
 ---
 
+## ⚠️ MANDATORY: ROUTING DECISION (DO THIS FIRST)
+
+**CRITICAL: This decision must be completed BEFORE invoking ANY scoring tool.**
+
+When a user requests scoring with a model name (e.g., `score a=10,b=20 with model simplejob.job`):
+
+### Step 1: Extract the Type Suffix
+Check if the model name contains a dot:
+- **YES** (e.g., `simplejob.job`) → Split on the last dot to extract type: `job`
+- **NO** (e.g., `churn`) → Assume type is `.mas` (default MAS model)
+
+### Step 2: Validate the Type
+Confirm the extracted type is one of: `job`, `jobdef`, `mas`, `scr`, `sas`
+- **VALID** → Proceed to Step 3
+- **INVALID** (e.g., `.xyz`) → Assume `.mas` and treat entire input as model name
+
+### Step 3: Strip the Type Suffix
+Remove the `.type` from the model name:
+- `simplejob.job` → base name: `simplejob`
+- `churn.mas` → base name: `churn`
+- `fraud_detector.jobdef` → base name: `fraud_detector`
+
+### Step 4: Route to the Correct Tool
+Invoke the tool that matches the type:
+- **`.job`** → `sas-score-run-job`
+- **`.jobdef`** → `sas-score-run-jobdef`
+- **`.mas`** → `sas-score-model-score`
+- **`.scr`** → `sas-score-scr-score`
+- **`.sas`** → `sas-score-run-sas-program`
+
+### Step 5: Invoke with Correct Parameters
+Pass the base name (without type) to the routed tool.
+
+---
+
+## Routing Decision Tree
+
+```
+User request: "score a=10,b=20 with model simplejob.job"
+       ↓
+[Extract model reference] → "simplejob.job"
+       ↓
+[Split on last dot] → base="simplejob", type="job"
+       ↓
+[Validate type] → "job" ∈ [job, jobdef, mas, scr, sas]? YES
+       ↓
+[Route by type]
+   └─ type="job" → call sas-score-run-job()
+       ↓
+[Invoke tool] → sas-score-run-job({ name: "simplejob", scenario: {a: "10", b: "20"} })
+       ↓
+[Return results]
+```
+
+---
+
+## ❌ Anti-Patterns (DO NOT DO THIS)
+
+These mistakes cause incorrect routing:
+
+| Request | Wrong Tool Called | Why It's Wrong | Correct Tool |
+|---------|-------------------|----------------|---------------|
+| `score simplejob.job scenario =a=10,b=20` | `deva-score` | `.job` suffix ignored; generic scorer used | `sas-score-run-job` |
+| `score churn.mas where age=45` | `run-job` | Type mismatch; treated as job instead of MAS | `sas-score-model-score` |
+| `score fraud.jobdef using amount=500` | `model-score` | Wrong tool for jobdef type | `sas-score-run-jobdef` |
+| `score model.scr with scenario` | `run-jobdef` | SCR endpoint ignored | `sas-score-scr-score` |
+| `score code.sas using x=1` | `model-score` | SAS program treated as MAS model | `sas-score-run-sas-program` |
+
+---
+
+## ✅ Checkpoint Verification
+
+Before invoking ANY tool, verify all checkpoints:
+
+- [ ] **Did I extract the type correctly?** (Check: is it one of the 5 types: `job`, `jobdef`, `mas`, `scr`, `sas`?)
+- [ ] **Did I strip the type suffix from the model name?** (Pass base name only: `simplejob`, not `simplejob.job`)
+- [ ] **Does the routing match the type?** (e.g., `.job` → `run-job`, `.mas` → `model-score`)
+- [ ] **Am I using the correct parameter name?** (e.g., `name:` for jobs/jobdefs, `model:` for MAS, `url:` for SCR)
+- [ ] **Is the scenario parsed correctly?** (e.g., `{ a: "10", b: "20" }` from `a=10,b=20`)
+- [ ] **Have I considered if this is the default MAS case?** (If no type, assume `.mas` and use `model-score`)
+
+⚠️ **All checkboxes must be ✓ before invoking the tool.**
+
+---
+
 ## Type-Based Routing
 
 ### Parse and Strip Model Type
@@ -296,6 +381,8 @@ Merge the scoring output back with the input records and present as a table wher
 | Scoring error / invalid inputs | Return structured error, suggest `model-info` to check required inputs and data types |
 | Empty read result | Tell user, ask if they want to adjust the query/filter before scoring |
 | Missing input fields | Ask which table columns map to the required model inputs |
+| **Type routing error (wrong tool called)** | **Check: did I complete the MANDATORY routing decision? Did I extract the type correctly? Did I route to the right tool based on type?** |
+| **Type suffix not recognized** | **Assume `.mas` (default MAS model) and treat entire input as model name** |
 
 ---
 

package/src/toolSet/findTable.js

@@ -47,8 +47,8 @@ Returns { tables: [] } if not found; { tables: [name, ...] } if found. Never hal
     name: 'find-table',
     description: description,
     inputSchema: z.object({
-      name: z.string(),
       lib: z.string(),
+      name: z.string(),
       server: z.string() 
     }),
     

package/.claude/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/.claude/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

package/.claude/sas-find-library-smart/SKILL.md

@@ -1,154 +0,0 @@
----
-name: sas-find-library-smart
-description: >
-  Find a SAS Viya library (libref or caslib) with intelligent server detection. Automatically checks 
-  CAS first, then SAS if not found. Use this skill when the user needs to verify a library exists,
-  before accessing tables within it. Trigger phrases include: "find library", "does library exist",
-  "check if library", "locate library", "is there a library named", "verify library", or any request 
-  to confirm a library's availability across servers.
----
-
-# Smart Library Lookup (Find Library)
-
-Intelligently locates a SAS Viya library by checking CAS first, then SAS if the library is not found 
-in CAS. Provides the user with clear information about library availability and location.
-
-**If the user specifies the server explicitly** (e.g., "find library Public in cas"):
-- Use the specified server: `server: "cas"` or `server: "sas"`
-- Proceed directly to finding the library
-
-**If the server is NOT specified:**
-1. **First attempt**: Check CAS (`server: "cas"`)
-2. **If not found in CAS**: Check SAS with uppercase library name (`server: "sas"`)
-3. **If not found in either**:
-   - Inform user: *"The library '<lib>' was not found in CAS or SAS servers. Please verify the library name."*
-   - Suggest: *"Would you like to list available libraries?"* (suggest `sas-score-list-libraries`)
-4. **If found**:
-   - Inform user which server contains the library: *"Found library '<lib>' in CAS"* or *"Found library '<lib>' in SAS"*
-   - Offer next steps: *"Would you like to list tables in this library?"* (suggest `sas-score-list-tables`)
-
----
-
-## Using sas-score-find-library
-
-**When:**
-- User wants to verify a library exists
-- User needs to determine which server contains a library
-- User wants to check library availability before accessing it
-- User wants to explore available libraries (before querying)
-
-**How:**
-```
-sas-score-find-library({
-  name: "libraryname",          // required
-  server: "cas" or "sas"        // optional; determined by server check if not specified
-})
-```
-
-**Rules:**
-- Always determine the correct server first (cas → sas → neither)
-- **For SAS server: always uppercase the library name** (e.g., "public" → "PUBLIC")
-- If library name is missing, ask: *"Which library name would you like to find?"*
-- Return the server where the library was found
-- If not found in either server, clearly inform the user and offer to list available libraries
-- Do not proceed with table access until library existence is confirmed
-
----
-
-## Smart server detection logic
-
-```
-IF server specified by user
-  → IF server is "sas"
-      → uppercase lib
-  → use that server, call sas-score-find-library
-ELSE
-  → TRY sas-score-find-library(lib, server="cas")
-    IF library found
-      → success, inform user: library found in CAS
-    ELSE
-      → uppercase lib
-      → TRY sas-score-find-library(lib.toUpperCase(), server="sas")
-        IF library found
-          → success, inform user: library found in SAS
-        ELSE
-          → inform user library not found in either server
-          → offer to list available libraries
-```
-
----
-
-## Common patterns
-
-**Pattern 1 — Find library, server unspecified**
-> "Find library Public"
-
-1. Try CAS: `sas-score-find-library({ name: "Public", server: "cas" })`
-2. If not found, try SAS with uppercase: `sas-score-find-library({ name: "PUBLIC", server: "sas" })`
-3. If found in CAS → *"Found library 'Public' in CAS. Would you like to list tables in it?"*
-4. If found in SAS → *"Found library 'PUBLIC' in SAS. Would you like to list tables in it?"*
-5. If not found → *"The library 'Public' was not found in CAS or SAS. Would you like to list available libraries?"*
-
-**Pattern 2 — Find library with explicit server (CAS)**
-> "Find library MyData in cas"
-
-1. Skip server detection
-2. Call: `sas-score-find-library({ name: "MyData", server: "cas" })`
-3. Result → *"Found library 'MyData' in CAS"* or *"Library 'MyData' not found in CAS"*
-
-**Pattern 3 — Find library with explicit server (SAS)**
-> "Does library SASHELP exist in sas"
-
-1. Skip server detection
-2. Uppercase lib: `sas-score-find-library({ name: "SASHELP", server: "sas" })`
-3. Result → *"Found library 'SASHELP' in SAS"* or *"Library 'SASHELP' not found in SAS"*
-
-**Pattern 4 — Library not found, offer next steps**
-> "Check if library staging exists"
-
-1. Try CAS: `sas-score-find-library({ name: "staging", server: "cas" })` → not found
-2. Try SAS: `sas-score-find-library({ name: "STAGING", server: "sas" })` → not found
-3. Respond:
-   - *"The library 'staging' was not found in CAS or SAS."*
-   - *"Would you like to:"*
-     - *"List all available libraries? (use `sas-score-list-libraries`))"*
-     - *"Check a different library name?"*
-
-**Pattern 5 — Library found, follow-up action**
-> "Verify library samples exists"
-
-1. Try CAS: `sas-score-find-library({ name: "samples", server: "cas" })` → found
-2. Respond:
-   - *"Found library 'samples' in CAS."*
-   - *"Would you like to list tables in this library? (use `sas-score-list-tables`))"*
-
----
-
-## Output presentation
-
-**When library is found:**
-```
-✓ Found library '<lib>' in <SERVER>
-
-Would you like to:
-• List tables in this library (use sas-list-tables-smart skill)
-• Read data from a specific table (use sas-read-strategy skill)
-```
-
-**When library is not found:**
-```
-✗ Library '<lib>' not found in either CAS or SAS
-
-Suggestions:
-• Check the spelling of the library name
-• List available libraries (use list-libraries tool)
-• Try a different library name
-```
-
----
-
-## Integration with other skills
-
-- **After finding library → List tables**: Use `sas-list-tables-smart` skill to browse available tables
-- **After finding library → Read data**: Use `sas-read-strategy` skill to retrieve data from tables
-- **Library not found → Explore**: Use `sas-score-list-libraries` tool to see all available libraries