@sassoftware/sas-score-mcp-serverjs 1.0.1-14 → 1.0.1-16

package/.instructions/copilot-instructions.md

@@ -33,6 +33,9 @@ Before using SAS MCP tools, classify the request into one of these categories:
 
 If the request could belong to multiple categories, ask one clarifying question unless lightweight discovery can resolve it safely.
 
+## Viya server and library baseline
+Use `sas-find-resource-strategy` as the canonical source for default CAS/SAS library lists and server fallback rules. Reuse a table location once it has already been established in the conversation.
+
 ## Skill-first behavior
 Before invoking MCP tools, decide whether one or more SAS skills should be used.
 Prefer loading the most relevant SAS skill for the request category.
@@ -109,115 +112,34 @@ Prefer inspection and discovery over assumption.
 ---
 # Read TableWorkflow Enforcement (MANDATORY)
 
-For any request to read, fetch, or query a table (e.g., score a=1 with model abc", read maps.india", "get rows from lib.table", "show data from ..."), you MUST follow this workflow:
-
-Step 1. **Always use the sas-find-resource-strategy**
-
-- For tables:
-	- Use the `sas-find-resource-strategy` skill to locate the table and determine which server (CAS or SAS) contains it.
-	- Do not assume the server or skip this step, even if the library or table is commonly found in one server.
-	- If the table exists in both, ask the user which server to use.
-	- If the table is not found, inform the user and do not attempt to read.
-
-Step 2. **Only after confirming the table location:**
-	- Use the correct `sas-score-read-table` or `sas-score-sas-query` tool, specifying the server explicitly.
-
-3. **If you see a direct read-table/tool call without a prior find step:**
-	- Correct the workflow and restart from the find resource step.
+For any request to read, fetch, or query a table:
+1. Use `sas-find-resource-strategy` first to confirm the table and server.
+2. If the table location is already known from earlier context, reuse it.
+3. Then call `sas-score-read-table` or `sas-score-sas-query` with an explicit server.
+4. If a direct read/query call appears without a prior find step, restart from the find step.
 
-This workflow is mandatory for all table read requests. If you are unsure, always perform the find resource step before reading.
-
-See also: `./enforce-find-resource-strategy.md` for details and examples.
+See also: `./enforce-find-resource-strategy.md`.
 
 ---
 
 # Scoring workflow envforcement (MANDATORY)
 
-For any request to score with a model (e.g., "score with model abc", "run model abc.jobdef", "score with model abc.mas", "score with model abc.scr"), you MUST follow this workflow:
-Step 1. **Always use the sas-find-resource-strategy**
-
-- For models of type MAS, job, or jobdef:
-	- Use the `sas-find-resource-strategy` skill to verify the model exists before scoring, except for SCR models where the model existence check is not required before scoring.
-	- Do not assume the model exists or skip this step, even if the model name is commonly used.
-	- If a table is used as data source for scoring, use the `sas-find-resource-strategy` skill to locate the table and determine which server (CAS or SAS) contains it.
-		- Do not assume the server or skip this step, even if the library or table is commonly found in one server.
-		- If the table exists in both, ask the user which server to use.
-		- If the table is not found, inform the user and do not attempt to read.
-
-Step 2. **Only after confirming the table location:**
-	- Use the correct `sas-score-read-table` or `sas-score-sas-query` tool, specifying the server explicitly.
+For any request to score with a model:
+1. Use `sas-find-resource-strategy` first for MAS, job, or jobdef models. SCR models do not require a prior existence check.
+2. If table data is involved, resolve the table with `sas-find-resource-strategy` and reuse any previously known location.
+3. Then route to the correct scoring tool for the model type.
+4. If a direct read/query call appears without the find step, restart from the find step.
 
-3. **If you see a direct read-table/tool call without a prior find step:**
-	- Correct the workflow and restart from the find resource step.
-
-This workflow is mandatory for all score requests. If you are unsure, always perform the find resource step before scoring.
+This workflow is mandatory for all score requests.
 
 ---
-
-# Available Skills
-
-This repository provides specialized skills for SAS-focused workflows. Load the relevant skill for the user's request before using MCP tools.
-
-## sas-request-classifier
-**Purpose:** Classify ambiguous SAS or Viya requests before using MCP tools.
-
-**Use when:** Request mentions jobs, code, models, scoring, CAS tables, content, or resources and the correct SAS domain is not yet clear.
-
-**Trigger phrases:** "find my model", "run scoring", "open the table", or any ambiguous request using domain terms.
-
-## sas-find-resource-strategy
-**Purpose:** Unified find-only strategy to verify existence of libraries, tables, models, jobs, and jobdefs using find tools.
-
-**Use when:** User asks to find, verify, check existence of, or locate a resource.
-
-**Trigger phrases:** "find library", "find table", "find model", "find job", "find jobdef", "does X exist".
-
-## sas-list-resource-strategy
-**Purpose:** Unified list strategy to list libraries, tables, models, jobs, and jobdefs with normalized pagination.
-
-**Use when:** User asks to list, show, browse, or enumerate resources.
-
-**Rule:** Always pass non-null `start` and `limit`; default to `start: 1` and `limit: 10` when not provided.
-
-**Trigger phrases:** "list libraries", "list tables", "list models", "list jobs", "list jobdefs", "show resources".
-
-## sas-find-library-smart
-**Purpose:** Find a SAS Viya library (libref or caslib) with intelligent server detection. Automatically checks CAS first, then SAS if not found.
-
-**Use when:** User needs to verify a library exists, before accessing tables within it.
-
-**Trigger phrases:** "find library", "does library exist", "check if library", "locate library", "is there a library named", "verify library".
-
-## sas-list-tables-smart
-**Purpose:** List all tables in a SAS Viya library with intelligent server detection. When the server is not specified, automatically checks CAS first, then SAS if not found.
-
-**Use when:** User wants to browse or explore available tables.
-
-**Trigger phrases:** "list tables in", "show tables in", "what tables are in", "browse tables in", "tables in library", "enumerate tables".
-
-## sas-read-strategy
-**Purpose:** Guide the user in choosing the right data retrieval tool: `sas-score-read-table` (for raw row access with filters) or `sas-score-sas-query` (for analytical queries, aggregations, joins).
-
-**Use when:** User wants to fetch records from a SAS/CAS table.
-
-**Pre-check:** Use `sas-find-resource-strategy` to verify library/table existence first.
-
-**Trigger phrases:** "read records from", "get data where", "fetch rows from", "query the table", "give me the first N records", "aggregate by", "join tables".
-
-## sas-read-and-score-strategy
-**Purpose:** Guide the full read → score workflow in SAS Viya: reading records from a table and then scoring them with a MAS model.
-
-**Use when:** User wants to score records from a table, run a model against query results, predict outcomes for a set of rows, or any combination of fetching data and scoring it.
-
-**Pre-check:** Use `sas-find-resource-strategy` to verify library/table/model resources first.
-
-**Trigger phrases:** "score these records", "score results of my query", "run the model on this table", "predict for these customers", "fetch and score", "read and score", "score rows from", "run model on table data".
-
-## sas-score-workflow-strategy
-**Purpose:** Mandatory routing logic for all scoring requests. Extracts model.type suffix and routes to the correct tool (run-job|run-jobdef|model-score|scr-score|run-program). Handles both MAS models and alternative scoring engines.
-
-**Use when:** User requests scoring with a model name that may require routing to different execution engines.
-
-**Pre-check:** Use `sas-find-resource-strategy` to verify model/job/jobdef resources before execution.
-
-**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.
+## Available Skills
+
+- `sas-request-classifier` — classify ambiguous SAS/Viya requests
+- `sas-find-resource-strategy` — verify libraries, tables, jobs, jobdefs, and MAS models
+- `sas-list-resource-strategy` — list SAS/Viya resources with pagination
+- `sas-find-library-smart` — library lookup with CAS/SAS fallback
+- `sas-list-tables-smart` — list tables in a library
+- `sas-read-strategy` — choose read-table vs sas-query
+- `sas-read-and-score-strategy` — read data and score it
+- `sas-score-workflow-strategy` — route scoring by model type

package/.instructions/enforce-find-resource-strategy.md

@@ -2,34 +2,6 @@
 
 ## Table Read Workflow (Strict)
 
-When handling any request to read, fetch, or query a table (e.g., "read maps.india", "get rows from lib.table", "show data from ..."), you MUST:
+Use `sas-find-resource-strategy` before any table read or query, then call `sas-score-read-table` or `sas-score-sas-query` with an explicit server. If the table location is already known, reuse it.
 
-1. **Always use the find resource strategy first:**
-   - Use the `sas-find-resource-strategy` skill to locate the table and determine which server (CAS or SAS) contains it.
-   - Do not assume the server or skip this step, even if the library or table is commonly found in one server.
-   - If the table exists in both, ask the user which server to use.
-   - If the table is not found, inform the user and do not attempt to read.
-
-2. **Only after confirming the table location:**
-   - Use the correct `sas-score-read-table` or `sas-score-sas-query` tool, specifying the server explicitly.
-
-3. **If you see a direct read-table/tool call without a prior find step:**
-   - Correct the workflow and restart from the find resource step.
-
-## Example (Correct)
-- User: "read maps.india"
-- Agent:
-  1. Use `sas-find-resource-strategy` to check for `maps.india` in CAS, then SAS.
-  2. If found in SAS only, call `sas-score-read-table` with `server: 'sas'`.
-
-## Example (Incorrect)
-- User: "read maps.india"
-- Agent: Calls `sas-score-read-table` with no server or with default server without checking table location first.
-
-## Enforcement
-- This workflow is mandatory for all table read requests.
-- If you are unsure, always perform the find resource step before reading.
-
----
-
-Add this section to your always-on agent instructions or as a dedicated enforcement section for table read workflows.
+This file is the compact version of the mandatory table-read rule referenced from the main instructions.

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

@@ -10,146 +10,20 @@ description: >
 
 # 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.
+Use `sas-find-resource-strategy` as the canonical existence check for libraries.
 
-> Primary strategy: use `sas-find-resource-strategy` for all resource existence checks.
-
-**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."*
-  - Ask for corrected library name or explicit server context
-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`)
-
----
+## Behavior
+- If the server is explicit, use it.
+- If the server is omitted, follow the canonical CAS-first, then SAS fallback.
+- For SAS, uppercase the library name.
+- If found, report the server and offer table listing.
+- If not found, ask for a corrected name or explicit server.
 
 ## Using sas-score-find-library
+- Use when the user wants to verify a library exists or confirm which server contains it.
+- Do not use list tools to check existence.
 
-**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 request corrected name or server context
-- Do not proceed with table access until library existence is confirmed
-- Do not use list tools to find whether a library exists
-
----
-
-## 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
-          → ask for corrected name or explicit server
-```
-
----
-
-## 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. Please confirm the name or specify a server."*
-
-**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."*
-  - *"Please confirm the library name or specify the server (CAS or SAS)."*
-
-**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
-• Specify the intended server (CAS or SAS)
-• Try a different library name
-```
-
----
-
-## Integration with other skills
+## Integration
+- After finding a library, use `sas-list-tables-smart` to browse tables.
+- After finding a library, use `sas-read-strategy` to read from a table in it.
 
-- **Primary find strategy**: Use `sas-find-resource-strategy` for existence checks
-- **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

package/.skills/sas-find-resource-strategy/SKILL.md

@@ -13,6 +13,29 @@ Use this skill to verify resource existence without using list tools.
 
 ## Scope
 
+Viya server baseline:
+- CAS and SAS are the two servers.
+
+Known default SAS libraries:
+- MAPS
+- MAPSGFK
+- MAPSSAS
+- SASDQREF
+- SASHELP
+- SASUSER
+- WORK
+
+Known default CAS libraries:
+- Casuser
+- Formats
+- ModelPerformanceData
+- Models
+- Public
+- Samples
+- SystemData
+
+Users can define additional libraries on CAS and SAS.
+
 Supported resource types:
 - library
 - table
@@ -48,9 +71,10 @@ If server is provided:
 - SAS: uppercase first, then `sas-score-find-library({ name: "<LIB>", server: "sas" })`
 
 If server is not provided:
-1. Check CAS first - `sas-score-find-library({ name: "<lib>", server: "cas" })`
-2. If not found, check SAS with uppercase library name - `sas-score-find-library({ name: "<LIB>", server: "sas" })`
-3. Report where found, or report not found in either.
+1. If library location is already known from earlier conversation or if the library is one of the default libraries, reuse that known server and do not re-check.
+2. Check CAS first - `sas-score-find-library({ name: "<lib>", server: "cas" })`
+3. If not found, check SAS with uppercase library name - `sas-score-find-library({ name: "<LIB>", server: "sas" })`
+4. Report where found, or report not found in either.
 
 ### Find table
 
@@ -63,9 +87,11 @@ If server is provided:
 - SAS: uppercase library first, then `sas-score-find-table({ lib: "<LIB>", name: "<table>", server: "sas" })`
 
 If server is not provided:
-1. Check CAS first - `sas-score-find-table({ lib: "<lib>", name: "<table>", server: "cas" })`
-2. If not found, check SAS (uppercase library) - `sas-score-find-table({ lib: "<LIB>", name: "<table>", server: "sas" })`
-3. If found in both, report both and ask user which server to use for follow-up reads.
+1. If table location is already known from earlier conversation context, reuse that known server and do not re-check.
+2. If `lib.table` uses a known default CAS library, check CAS first.
+3. If `lib.table` uses a known default SAS library, check SAS first (uppercase library).
+4. If library is unknown (not in known defaults), check CAS first, then SAS (uppercase library).
+5. If found in both, report both and ask user which server to use for follow-up reads.
 
 ### Find models by type
 

package/.skills/sas-list-resource-strategy/SKILL.md

@@ -79,6 +79,12 @@ sas-score-list-tables({
 })
 ```
 
+Table server inference when server is not provided:
+- If library is a known default CAS library (Casuser, Formats, ModelPerformanceData, Models, Public, Samples, SystemData), use `server: "cas"` first.
+- If library is a known default SAS library (MAPS, MAPSGFK, MAPSSAS, SASDQREF, SASHELP, SASUSER, WORK), use `server: "sas"` first.
+- If library is unknown, check CAS first, then SAS.
+- If table location is already known from earlier requests, reuse that known server.
+
 If `lib` is missing, ask: "Which library should I list tables from?"
 
 ### List models

package/.skills/sas-list-tables-smart/SKILL.md

@@ -8,121 +8,23 @@ description: >
   "browse tables in", "tables in library", "enumerate tables", or any request to explore data sources.
 ---
 
-# Smart Data Access in SAS Library (List, Read, Query)
+# Smart Data Access in SAS Library (List Tables)
 
-Intelligently enumerates tables in a SAS Viya library, automatically determining the correct server
-when not explicitly specified.
+Use `sas-find-resource-strategy` to resolve the library and server, then call `sas-score-list-tables` with an explicit server.
 
-> **Pre-flight check**: Before listing tables, verify the library and table context using the `sas-find-resource-strategy` skill.
-> This ensures consistent server detection across all data operations.
-
-**If the user specifies the server explicitly** (e.g., "list tables in Public in cas"):
-- Use the specified server: `server: "cas"` or `server: "sas"`
-- Proceed directly to listing tables
-
-**If the server is NOT specified:**
-1. **First attempt**: Check CAS (`server: "cas"`)
-2. **If no tables found in CAS**: Check SAS (`server: "sas"`)
-3. **If no tables found in either**:
-   - Inform user: *"The library '<lib>' was not found in CAS or SAS. Please verify the library name is correct."*
-  - Ask for corrected library name or explicit server context
-
----
+## Behavior
+- If the server is explicit, honor it.
+- If the server is omitted, rely on the canonical CAS-first, then SAS fallback.
+- For SAS, uppercase the library name.
+- If the library is already known from earlier context, reuse it.
+- If no tables are found, inform the user and ask for a corrected library or server.
+- Do not use list tools to check whether a library exists.
 
 ## Using sas-score-list-tables
+- Use when the user wants to browse or enumerate tables in a library.
+- Keep page size small unless the user asks for more.
 
-**When:**
-- User wants to browse all tables in a library
-- User wants to see what data is available
-- User wants to explore library contents before querying
-
-**How:**
-```
-sas-score-list-tables({
-  lib: "libraryname",           // required
-  server: "cas" or "sas",       // required; determined by server check
-  limit: 10,                    // optional; default 10, adjust for pagination
-  start: 1                      // optional; default 1, use for pagination
-})
-```
-
-**Rules:**
-- Always determine the correct server first (cas → sas → neither)
-- **For SAS server: always uppercase the library name** (e.g., "maps" → "MAPS")
-- If library name is missing, ask: *"Which library should I list tables from?"*
-- Default page size is 10; adjust based on user request ("show me all", "25 tables", etc.)
-- If returned table count equals the limit, suggest pagination: *"There may be more tables. Use `start: {next_offset}` to see more."*
-- If no tables are found despite library existing, report: *"No tables found in {lib} on {server} server."*
-- Return table names only; do not fetch table metadata unless explicitly requested
-- Do not use list tools to determine whether a specific resource exists
-
----
-
-## Smart server detection logic
-
-```
-IF server specified by user
-  → IF server is "sas"
-      → uppercase lib
-  → use that server
-ELSE
-  → TRY sas-score-list-tables(lib, server="cas")
-    IF tables found
-      → success, return tables
-    ELSE
-      → uppercase lib
-      → TRY sas-score-list-tables(lib.toUpperCase(), server="sas")
-        IF tables found
-          → success, return tables
-        ELSE
-          → inform user library not found in either server
-```
-
----
-
-## Common patterns
-
-**Pattern 1 — List tables, server unspecified**
-> "List tables in Public"
-
-1. Try CAS: `sas-score-list-tables({ lib: "Public", server: "cas" })`
-2. If empty, try SAS with uppercase: `sas-score-list-tables({ lib: "PUBLIC", server: "sas" })`
-3. If still empty → inform user
-
-**Pattern 2 — List tables with explicit server (SAS)**
-> "List tables in sashelp in sas"
-
-1. Skip server detection
-2. Call with uppercase lib: `sas-score-list-tables({ lib: "SASHELP", server: "sas" })`
-
-**Pattern 3 — List tables with explicit server (CAS)**
-> "List tables in Public in cas"
-
-1. No uppercase needed for CAS
-2. Call: `sas-score-list-tables({ lib: "Public", server: "cas" })`
-
-**Pattern 4 — Pagination**
-> "Show me 25 tables in Samples, then the next batch"
-
-1. First call: `sas-score-list-tables({ lib: "Samples", limit: 25, start: 1 })`
-2. Next call: `sas-score-list-tables({ lib: "Samples", limit: 25, start: 26 })`
-
-**Pattern 5 — Library not found**
-> "List tables in foo"
-
-1. Try CAS: empty
-2. Try SAS with uppercase: empty
-3. Response: *"The library 'foo' was not found in CAS or SAS. Please verify the library name."*
-
----
-
-## Error handling
-
-| Scenario | Action |
-|---|---|
-| Library not found in either server | Inform user and ask to verify library name |
-| Empty result on first server | Automatically check second server |
-| User specifies invalid server | Return error; ask user to clarify: `"cas"` or `"sas"` |
-| Missing library name | Ask: *"Which library should I list tables from?"* |
-| Library verification needed | Use `sas-find-resource-strategy` to verify the library exists first |
+## Integration
+- Use `sas-find-resource-strategy` for resource existence checks.
+- Use `sas-read-strategy` after listing tables if the user wants rows.
 

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

@@ -12,99 +12,23 @@ description: >
 
 # SAS Read → Score Workflow
 
-Orchestrates the full two-step pattern of reading records from a SAS/CAS table and scoring them
-with a deployed MAS model.
+Use `sas-find-resource-strategy` to verify resources and server location before reading or scoring. Reuse any table location already established earlier in the conversation. SCR models do not require a prior existence check.
 
----
-
-## Pre-flight verification
-
-**Before attempting to read, query, or score a table:**
-1. **Verify table exists**: Use `sas-find-resource-strategy` to confirm the library and table exist before trying to read
-2. **Verify model exists**: Use `sas-find-resource-strategy` to confirm the model exists before scoring, except for SCR models
-3. **Confirm server location**: Ensure you know which server (CAS or SAS) contains the data
-
-This ensures consistent behavior with other data access operations.
-
----
-
-## Workflow overview
-
-The typical flow involves:
-1. **Fetch data** — Identify which table/query will provide input records
-2. **Validate model** — Confirm the model exists and understand its input schema
-3. **Score** — Invoke the model on the fetched records
-4. **Present results** — Merge predictions with original data and display
-
----
-
-## Scenario: User already has data
-
-If the user provides scenario data directly (e.g., "Score age=45, income=60000 with model X"):
-- Extract the scenario values and format it as a json object(ex: a=10,b=20 → {"a":10,"b":20})
-- Validate against model's input schema if model is mas or scr.
-- Invoke scoring
-- Return prediction
-
----
-
-## Scenario: User wants to score table rows
-
-If the user specifies a table (e.g., "Score all customers in Public.customers with model X"):
-- Verify table exists using `sas-find-resource-strategy`
-- Fetch raw rows (possibly filtered: "where status='active'")
-- Invoke scoring on each row
-- Merge results with original data
-- Display combined table
-
----
-
-## Scenario: User wants to score query results
-
-If the user wants to score aggregated/filtered results (e.g., "Score high-value customers (spend > 5000) with model X"):
-- Determine which records meet criteria (aggregation/filtering)
-- Invoke scoring
-- Merge predictions with summary data
-- Display results
-
----
-
-## Scenario: User unfamiliar with model
-
-If the user specifies a model name that's new/unknown:
-- Check if model exists
-- Retrieve model schema (inputs, outputs)
-- Show user what inputs the model expects
-- Confirm before proceeding with scoring
-
----
+## Workflow
+1. Read rows with `sas-read-strategy`.
+2. Validate the model or scoring target with `sas-find-resource-strategy` when required.
+3. Score the records with the appropriate scoring tool.
+4. Merge predictions back with the input rows.
 
 ## Rules
-
-- Always validate table existence before attempting to read
-- Always check model exists before invoking `sas-score-model-score`
-- Use find tools only for resource existence checks; do not use list tools to find resources
-- If multiple records: score batch if possible; fall back to row-by-row
-- Merge predictions with original data using row index or key column
-- Present results as table with original columns + new prediction columns
-
----
+- If the user already has scenario data, skip the read step.
+- If column names do not match model inputs, ask for a mapping.
+- Return raw field values plus prediction fields.
 
 ## Error handling
+- Table not found -> ask for correct lib.table
+- Model not found -> ask the user to verify the model name
+- Empty result -> ask whether to adjust the filter
 
-| Problem | Action |
-|---|---|
-| Table not found | Ask for correct lib.tablename |
-| Model not found | Inform user; suggest verifying model name |
-| Field/column mismatch | Show mismatch, ask user to confirm or adjust query |
-| Scoring error | Return structured error, suggest checking model inputs |
-| Empty read result | Inform user, ask if they want to adjust the query/filter |
-| Data type mismatch | Warn user about type conversion, proceed or ask for clarification |
-
----
-
-## Integration with other skills
-
-- **Before this workflow**: Use `sas-find-resource-strategy` to verify table/model resources exist
-- **For data retrieval**: Use `sas-read-strategy` to choose the right read tool (read-table vs sas-query)
-- **For scoring**: Use `sas-score-workflow-strategy` for advanced scoring options beyond MAS models
+## Integration
+- Use `sas-score-workflow-strategy` for advanced scoring routes.

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

@@ -10,152 +10,24 @@ description: >
 
 # SAS Read Strategy
 
-Guides the decision between `sas-score-read-table` and `sas-score-sas-query` based on the user's intent and the nature
-of the data operation. Determines which server contains the data and which retrieval tool is most appropriate.
+Use `sas-find-resource-strategy` to confirm the table and server before reading. Reuse any location already established earlier in the conversation.
 
-## Determine the server location
-
-Before retrieving data, locate the specific table first and determine which server(s) contain it:
-
-**Step 1: Locate the specific table (table-first)**
-- Use `sas-find-resource-strategy` to check if the table exists in CAS first, then SAS if needed
-- Do not perform a separate library-first lookup; table lookup already handles server-aware discovery
-- Do not use list tools for existence checks; rely on find tools to determine if the resource exists and where it exists.
-- Possible outcomes:
-  - If table exists **only in CAS** → set `server: "cas"`
-  - If table exists **only in SAS** → set `server: "sas"`
-  - If table exists **in both** → ask the user: *"The table exists in both CAS and SAS. Which server would you prefer to query from?"*
-  - If table exists **in neither** → inform user and suggest verifying the table name
-
----
-
-## Determine the read strategy
-
-Ask yourself: does the user already have the data in hand?
-
-- **Yes (user pasted values, or data is already in context)** → skip this strategy; data is ready to use.
-- **No** → choose the read tool based on intent:
-
-| User's Intent | Tool | Example |
-|---|---|---|
-| Get specific raw rows, apply simple filter, retrieve first N records | `sas-score-read-table` | "Show me 10 rows from customers where status='active'" |
-| Aggregate/summarize, calculate, join tables, analytical question | `sas-score-sas-query` | "Average salary by department", "Count orders by region" |
-
----
+## Choose the tool
+- Raw rows, simple filters, or pagination -> `sas-score-read-table`
+- Aggregations, joins, calculations, or analytical questions -> `sas-score-sas-query`
 
 ## Using read-table
-
-**When:**
-- User asks for raw records, row-by-row data
-- Simple WHERE filtering (e.g., "where status = 'active'")
-- Pagination needed ("first 50 rows", "next 10 rows")
-
-
-**How:**
-
-Step 1: Determine 
-```
-sas-score-read-table({
-  table: "tablename",
-  lib: "libraryname",
-  server: "cas" or "sas",  // determined from table-first lookup via sas-find-resource-strategy
-  limit: N,        // default 10, adjust based on user request
-  where: "..."     // optional SQL WHERE clause
-})
-```
-
-**Rules:**
-- Always determine the server first using `sas-find-resource-strategy`
-- Keep batch size ≤ 50 rows unless the user explicitly requests more
-- If table name is missing, ask: *"Which table should I read from? (format: lib.tablename)"*
-- If library is missing, ask: *"Which library contains the table?"*
-- Prefer table-first lookup (CAS first, then SAS) instead of a separate library lookup step
-- If table exists in both servers, ask user which to use
-- Return raw column values; do not transform or aggregate
-- Do not use list tools to determine whether a resource exists
-
----
+- Ask for `lib.table` if the table name is missing.
+- Ask for the library if only the table name is known.
+- Keep batch size at 50 rows or less unless the user asks for more.
+- Return raw values only.
 
 ## Using sas-query
+- Parse the request into valid SQL without a trailing semicolon.
+- Ask whether the user wants raw rows or a summary if intent is unclear.
+- Reuse the known server location.
 
-**When:**
-- User asks for aggregation (SUM, AVG, COUNT, GROUP BY)
-- User asks for joins, calculations, or analytical insights
-- User's question is phrased analytically ("compare", "analyze", "breakdown", "trend")
-
-**How:**
-1. Use `sas-find-resource-strategy` to check if the table exists in CAS first, then SAS if needed
-2. If table does not exist inform the user and suggest verifying the table name
-3. If table exists run the sas-query tool with the appropriate server and a generated SQL statement based on the user's natural language question. For example:
-```
-sas-query({
-  table: "lib.tablename",
-  query: "user's natural language question",
-  sql: "SELECT ... FROM ... WHERE ... GROUP BY ..."  // generated from query
-})
-```
-
-**Rules:**
-- Check which server(s) contain the table using `sas-find-resource-strategy` first
-- If table exists in both CAS and SAS, ask user which to query from
-- Parse the user's natural language question into a PROC SQL SELECT statement
-- Ensure SELECT statement is valid SQL syntax
-- Do not add trailing semicolons to the SQL string
-- If table name is missing, ask: *"Which table should I query? (format: lib.tablename)"*
-- If the intent is unclear, ask for clarification: *"Do you want raw rows, or an aggregated summary?"*
-
----
-
-## Common patterns
-
-**Pattern A — Raw row retrieval**
-> "Show me the first 5 rows from Public.customers"
-
-→ `sas-score-read-table({ table: "customers", lib: "Public", limit: 5 })`
-
-**Pattern B — Filtered retrieval**
-> "Get all high-value orders (amount > 5000) from mylib.orders"
-
-→ `sas-score-read-table({ table: "orders", lib: "mylib", where: "amount > 5000" })`
-
-**Pattern C — Aggregation**
-> "What is the average price by make in Public.cars?"
-
-→ `sas-score-sas-query({ table: "Public.cars", query: "average price by make", sql: "SELECT make, AVG(msrp) AS avg_price FROM Public.cars GROUP BY make" })`
-
-**Pattern D — Join + analysis**
-> "Show me total sales by customer in the sales and customers tables"
-
-→ `sas-score-sas-query()` with a JOIN in the generated SQL
-
----
-
-## Error handling
-
-| Problem | Action |
-|---|---|
-| Library missing or unclear | Ask the user which library contains the table |
-| Table not found in either server | Inform user and suggest checking the table name |
-| Table exists in both CAS and SAS | Ask: *"The table exists in both servers. Which would you prefer: CAS or SAS?"* |
-| Table exists only in one server | Use that server automatically in your request |
-| Table name missing entirely | Ask: *"Which table should I read from?"* |
-| Ambiguous intent (raw vs aggregate) | Ask: *"Do you want individual rows or a summary by some field?"* |
-| Empty result | Inform user, ask to adjust filter or query |
-
----
-
-## Integration with other skills
-
-- **Before this skill**: Use `sas-find-resource-strategy` for table-first resource lookup
-- **After this skill**: Use `sas-read-and-score-strategy` to score the retrieved data
-
----
-
-## Next steps
+## Integration
+- Use `sas-find-resource-strategy` before this skill.
+- Use `sas-read-and-score-strategy` when fetched rows must be scored.
 
-Once data is retrieved, typical follow-ups include:
-- **Visualize** — present as table or chart
-- **Export** — format and offer download
-- **Analyze further** — ask clarifying questions
-- **Score** — run predictions on the data
-- **Combine** — join with other datasets

package/.skills/sas-request-classifier/SKILL.md

@@ -5,71 +5,26 @@ description: Classify ambiguous SAS or Viya requests before using MCP tools. Use
 
 # SAS Request Classifier
 
-Use this skill to determine what kind of SAS object, workflow, or environment the user is referring to before selecting tools.
+Use this skill to map an ambiguous SAS/Viya request to the most likely downstream skill.
 
 ## When to use
-Use this skill when the request contains ambiguous domain terms such as:
-- model
-- mas
-- score
-- scoring
-- read
-- query
-- job
-- jobdef
-- code
-- table
-- content
-- asset
-- resource
-
-Use this skill before any execution-oriented tool call if there is a chance the request is referring to the wrong SAS domain.
-
-## Goal
-Map the user request to the most likely SAS domain and hand off to the correct downstream skill or tool path.
+Use this skill when the request contains ambiguous terms such as model, score, read, query, job, jobdef, code, table, content, asset, or resource.
 
 ## Classification targets
-Classify the request into one or more of these categories:
-- Resource existence lookup (library/table/mas/job/jobdef, with generic "model" phrasing allowed) -> Route to **sas-find-resource-strategy**
-- Resource listing (library/table/mas/job/jobdef, with generic "model" phrasing allowed) -> Route to **sas-list-resource-strategy**
-- Reading or querying tables → Route to **sas-read-strategy**
-- CAS resource, SAS resource, caslib, or table discovery → Route to **sas-find-library-smart** 
-- SAS data, libref, or table discovery → Route to **sas-find-library-smart** 
-- Score model or scoring artifact → Route to **sas-score-workflow-strategy**
-- Read data and score together → Route to **sas-read-and-score-strategy**
-- SAS job or flow execution
-- SAS code or program analysis
-- General content or metadata lookup
-- Environment, auth, or connectivity issue
-
-## Procedure
-1. Read the request and identify ambiguous nouns and verbs.
-2. Infer whether the request is asking to discover, inspect, execute, deploy, score, compare, or troubleshoot.
-3. Decide the most likely SAS domain and matching skill.
-4. If confidence is low, ask one focused clarifying question.
-5. If confidence is high, load and use the relevant skill:
-   - **sas-find-resource-strategy** — Unified find-only strategy for library/table/mas/job/jobdef, where "model" may mean mas, job, or jobdef
-   - **sas-list-resource-strategy** — Unified list strategy for library/table/mas/job/jobdef, where "model" may mean mas, job, or jobdef, with non-null pagination defaults
-   - **sas-find-library-smart** — Find CAS or SAS libraries
-   - **sas-list-tables-smart** — List tables in a library
-   - **sas-read-strategy** — Choose read-table vs. sas-query for data retrieval
-   - **sas-read-and-score-strategy** — Combine data reading with model scoring
-   - **sas-score-workflow-strategy** — Route scoring requests to correct execution engine
-6. Only after classification and skill guidance, use MCP tools.
+- Resource existence lookup -> sas-find-resource-strategy
+- Resource listing -> sas-list-resource-strategy
+- Reading or querying tables -> sas-read-strategy
+- Library/caslib lookup -> sas-find-library-smart
+- Table browsing -> sas-list-tables-smart
+- Read plus score -> sas-read-and-score-strategy
+- Scoring or score artifacts -> sas-score-workflow-strategy
+- Job or flow execution, code analysis, content lookup, environment issues -> clarify or use the most relevant SAS workflow
 
 ## Disambiguation hints
-- "Run" often implies job execution, but may also mean scoring or model invocation. Check for "score" or "model" context.
-- "Model" is a generic term that may refer to MAS, SCR,job, or jobdef resources in find/list requests. Prefer explicit patterns like `model <type>` or `<type> model`; default bare "model" to MAS unless the surrounding request implies job or jobdef.
-- "Score" may refer to model scoring or job execution. Look for model name or context.
-- "Table" usually suggests CAS or SAS but confirm library name and server context.
-- "Find" — resource lookup. Route to sas-find-resource-strategy.
-- "List" or "browse" — resource exploration. Route to sas-list-resource-strategy.
-- "Read", "query", "fetch" — data retrieval. Route to sas-read-strategy.
-- "Predict", "score records", "run model on data" — combined workflow. Route to sas-read-and-score-strategy  or sas-score-workflow-strategy.
+- "model" can mean MAS, job, or jobdef depending on context.
+- "score" can mean scoring or job execution.
+- "table" can be CAS or SAS; use server-aware find logic.
+- Reuse a table location already established earlier in the conversation.
 
 ## Output
-When you finish classification, state:
-- the inferred SAS domain
-- the confidence level
-- the relevant skill(s) to load
-- any remaining ambiguity or clarifying questions needed
+State the inferred SAS domain, confidence, relevant skill(s), and any remaining ambiguity.

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

@@ -109,7 +109,7 @@ Accepted formats:
 
 ## Integration with other skills
 
-- **Before scoring table data**: Use `sas-find-resource-strategy` to verify library/table/model resources, then `sas-read-strategy` to fetch records
+- **Before scoring table data**: Use `sas-find-resource-strategy` to verify library/table/model resources, using known-library server mapping for `lib.table`, CAS-then-SAS fallback for unknown libraries, and prior-known table location reuse; then use `sas-read-strategy` to fetch records
 - **For read + score workflows**: Use `sas-read-and-score-strategy` for the complete end-to-end pattern
 
 ---
@@ -306,10 +306,3 @@ Merge the scoring output back with the input records and present as a table wher
 - **Confirm mappings:** If column names don't match model inputs, ask before scoring.
 - **Show context:** Include key input columns in the result output so predictions make sense.
 - **Limit output:** For large result sets (>10 rows), ask before showing all.
-
----
-
-## Integration with other skills
-
-- **Before scoring table data**: Use `sas-find-resource-strategy` to verify resources, then `sas-read-strategy` to fetch records
-- **For read + score workflows**: Use `sas-read-and-score-strategy` for the complete end-to-end pattern

package/package.json

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

package/src/toolSet/modelScore.js

@@ -18,7 +18,7 @@ DO NOT USE for: find model, model metadata, list models, run programs/jobs, quer
 PARAMETERS
 - model: string — model name (required, exact match)
 - scenario: object — input data as JSON (optional, defaults to {}). Example: {age:45, income:60000}
-- uflag: boolean (default: false) — prefix model fields with underscore when true
+- uflag: boolean (optional, defaults to false) — prefix model fields with underscore when true
 
 ROUTING RULES
 - "score with model X using a=1, b=2" → { model: "X", scenario: {a:1, b:2}, uflag: false }