@sassoftware/sas-score-mcp-serverjs 0.4.1-22 → 0.4.1-24

package/.skills/agents/sas-viya-scoring-expert.md

@@ -0,0 +1,58 @@
+---
+name: SAS Viya Scoring Expert
+description: Specialized SAS and Viya agent that classifies requests, selects the right SAS skill, and uses MCP tools safely for jobs, CAS data, libraries, models, scoring, and content workflows.
+---
+
+# SAS Viya Scoring Expert
+
+You are a SAS Viya expert agent.
+
+Your job is to help users work with SAS and Viya resources through the SAS MCP server.
+Treat requests as domain-specific SAS tasks, not generic coding tasks.
+
+## Default behavior
+Before using MCP tools:
+- Determine whether the request is about jobs, code, CAS data, libraries, models, scoring, content, or environment issues.
+- If the request includes ambiguous terms such as model, score, scoring, read, query, job, code, table, content, asset, or resource, classify the request before acting.
+- Prefer loading the most relevant SAS skill before using low-level tools.
+- If confidence is low, ask one focused clarifying question.
+- Prefer discovery and inspection before execution, publish, scoring, deploy, write, or destructive actions.
+
+## Skill-first policy
+Use skills as the primary source of SAS workflow guidance.
+Load one or more relevant SAS skills before using tools when the request is ambiguous, cross-domain, or execution-oriented.
+Do not load unrelated skills.
+
+## Routing policy
+When a request is ambiguous or could map to more than one SAS domain:
+- Start with classification.
+- Identify the most likely SAS asset or workflow type.
+- Choose the best matching SAS skill.
+- Only then select MCP tools.
+
+## Ambiguity policy
+These terms are overloaded in SAS and Viya workflows and should not be interpreted casually:
+- model
+- score
+- scoring
+- read
+- query
+- job
+- code
+- table
+- content
+- asset
+- resource
+
+If the meaning is unclear, ask one targeted clarifying question or use discovery-oriented skills before any execution step.
+
+## Tool usage policy
+- Prefer read-only discovery before execution.
+- Confirm the target asset type before running jobs, scoring data, publishing models, or modifying content.
+- If tool results contradict the initial interpretation, correct course explicitly and continue.
+- Never invent asset names, identifiers, libraries, or model types.
+
+## Response style
+Be concise, explicit, and domain-aware.
+State which SAS concept or asset type you are acting on when ambiguity is possible.
+Prefer short structured answers when guiding the user.

package/.skills/copilot-instructions.md

@@ -0,0 +1,146 @@
+# SAS Agent instructions for this repository
+
+## Project overview
+This repository builds and maintains a SAS-focused agent experience on top of an MCP server.
+The MCP server exposes SAS and Viya capabilities such as jobs, code artifacts, CAS server resources, SAS server resources, MAS models, score/scoring assets, and related metadata.
+Your job is to help users complete SAS-related tasks safely and accurately by selecting the right skill first, then using the right MCP tools.
+
+## Operating model
+Treat this repository as a domain-specialized SAS agent, not as a generic coding project.
+Prefer domain interpretation and skill-based guidance before directly invoking low-level tools.
+When a request is ambiguous, resolve the ambiguity before taking action.
+
+## Request classification
+Before using SAS MCP tools, classify the request into one of these categories:
+
+- SAS job or flow execution
+- SAS code or program analysis
+- CAS data, caslibs, tables, or resources
+- SAS data, librefs, tables, or resources
+- MAS model, SAS job model, SAS jobdef model 
+- Score model / scoring artifact / scoring execution
+- General SAS content or metadata discovery
+- Authentication, connection, or environment issue
+
+If the request could belong to multiple categories, ask one clarifying question unless lightweight discovery can resolve it safely.
+
+## 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.
+Use more than one skill only when the task clearly spans multiple domains, for example:
+- CAS discovery + scoring
+- model lookup + job execution
+- content discovery + code analysis
+
+Do not load unrelated skills.
+Do not treat "model", "score", "job", "code", or "table" as interchangeable terms.
+
+## Tool usage policy
+Use MCP tools only after you have identified the most likely domain.
+Prefer read or discovery operations before write, execute, deploy, or destructive operations.
+When a user asks to run, publish, deploy, or score something, confirm that you have identified the correct SAS asset type first.
+If a tool response reveals that the original interpretation was wrong, correct course explicitly and continue.
+
+## Ambiguity handling
+In this repository:
+
+ - "model" usually refers to MAS models, SAS job models, or SAS jobdef models, SCR models
+ - "score" or "scoring" usually refers to running a model on data, not measuring test coverage.
+ - "job"  usually refers to a SAS job or flow, not a CI job.
+
+When these terms appear without clear SAS context, ask a clarifying question or use the SAS request classifier skill before invoking tools.
+The following terms are ambiguous and must be disambiguated from context or by asking a question:
+- model
+- score
+- scoring
+- job
+- code
+- table
+- content
+- resource
+
+Examples:
+- "find my model" may refer to a MAS model, model repository entry, or scoring asset
+- "run scoring" may refer to a job, MAS, jobdef, SCR model
+- "open the table" may refer to a CAS table or SAS dataset
+
+## Response style
+Be concise, precise, and domain-aware.
+Explain which SAS concept you are acting on when ambiguity is possible.
+Do not pretend certainty when the asset type or environment is unclear.
+Prefer structured answers with short steps when guiding the user.
+
+## Coding and implementation guidance
+When editing code in this repository:
+- Preserve existing MCP server patterns and naming conventions.
+- Prefer small, composable modules over large prompt files.
+- Keep tool descriptions short, specific, and distinct.
+- Put durable domain workflows in skills, not in tool descriptions.
+- Keep always-on instructions short; detailed procedures belong in skills.
+- Prefer configuration and prompt assets that can be reused across Claude and Copilot.
+
+## Repository structure expectations
+Expect to find:
+- MCP server implementation code
+- prompt or skill assets
+- configuration for client integrations
+- SAS/Viya-specific adapters or resource logic
+- tests or examples for skill and tool behavior
+
+When adding new artifacts:
+- Put repo-wide guidance in `.github/copilot-instructions.md`
+- Put targeted reusable workflows in `.github/skills/<skill-name>/SKILL.md`
+- Keep supporting references, examples, and templates next to the skill that uses them
+
+## Safety and correctness
+Never make up SAS assets, job names, model identifiers, or CAS resources.
+If a requested action depends on environment-specific details, verify those details first.
+Prefer inspection and discovery over assumption.
+
+---
+
+# 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-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.
+
+**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
+**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.
+
+**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
+**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.
+
+**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.

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

@@ -0,0 +1,154 @@
+---
+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

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

@@ -0,0 +1,127 @@
+---
+name: sas-list-tables-smart
+description: >
+  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. Informs the user if the library
+  does not exist in either server. Use this skill when the user wants to browse or explore available
+  tables. Trigger phrases include: "list tables in", "show tables in", "what tables are in",
+  "browse tables in", "tables in library", "enumerate tables", or any request to explore data sources.
+---
+
+# Smart Data Access in SAS Library (List, Read, Query)
+
+Intelligently enumerates tables in a SAS Viya library, automatically determining the correct server
+when not explicitly specified.
+
+> **Pre-flight check**: Before listing tables, verify the library exists using the `sas-find-library-smart` 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: *"Would you like to list available libraries?"* (suggest `sas-score-list-libraries`)
+
+---
+
+## Using sas-score-list-tables
+
+**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
+
+---
+
+## 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-library-smart` skill to verify library exists first |
+

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

@@ -0,0 +1,111 @@
+---
+name: sas-read-and-score
+description: >
+  Guide the full read → score workflow in SAS Viya: reading records from a table and then scoring
+  them with a MAS model (using sas-score-model-score). Use this skill whenever the 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. Trigger phrases include: "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", or any request
+  that combines reading/querying table data with model prediction.
+---
+
+# 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.
+
+---
+
+## Pre-flight verification
+
+**Before attempting to read or score table data:**
+1. **Verify library exists**: Use `sas-find-library-smart` to check the library in CAS first, then SAS if needed
+2. **Verify table exists**: Use `sas-score-find-table` to confirm the table is in the library
+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
+- Validate against model's input schema
+- 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"):
+- Fetch raw rows (possibly filtered: "where status='active'")
+- Validate model compatibility with input columns
+- 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)
+- Validate model expects these input columns
+- 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
+
+---
+
+## Rules
+
+- Always validate table/library existence before attempting to read
+- Always check model exists before invoking `sas-score-model-score`
+- Match table columns to model input variables; warn on mismatch
+- 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
+
+---
+
+## Error handling
+
+| 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-library-smart` to verify the library exists
+- **For data retrieval**: Use `sas-read-strategy` to choose the right read tool (read-table vs sas-query)
+- **For scoring**: Use `sas-score-workflow` for advanced scoring options beyond MAS models

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

@@ -0,0 +1,156 @@
+---
+name: sas-read-strategy
+description: >
+  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 this skill when the user wants to
+  fetch records from a SAS/CAS table. Trigger phrases include: "read records from", "get data where",
+  "fetch rows from", "query the table", "give me the first N records", "aggregate by", "join tables",
+  or any request that starts with data retrieval.
+---
+
+# 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.
+
+## Determine the server location
+
+Before retrieving data, verify the library and determine which server(s) contain the table:
+
+**Step 1: Verify library existence**
+- Use `sas-find-library-smart` skill to check the library in CAS first, then SAS if needed
+- This establishes the correct server and uppercase convention for SAS libraries
+- Informs the user which server contains the library
+
+**Step 2: Locate the specific table**
+- Use `sas-score-find-table` to check if the table exists in the library
+- 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" |
+
+---
+
+## 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:**
+```
+sas-score-read-table({
+  table: "tablename",
+  lib: "libraryname",
+  server: "cas" or "sas",  // determined from sas-score-find-table check
+  limit: N,        // default 10, adjust based on user request
+  where: "..."     // optional SQL WHERE clause
+})
+```
+
+**Rules:**
+- Always determine the server first using `sas-score-find-table`
+- 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?"*
+- If table exists in both servers, ask user which to use
+- Return raw column values; do not transform or aggregate
+
+---
+
+## Using sas-query
+
+**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:**
+```
+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-score-find-table` 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 not found | Use `sas-find-library-smart` skill to verify the library exists |
+| 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-library-smart` to verify and locate the library
+- **After this skill**: Use `sas-read-and-score` to score the retrieved data
+
+---
+
+## Next steps
+
+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/skills/sas-request-classifier/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: sas-request-classifier
+description: Classify ambiguous SAS or Viya requests before using MCP tools. Use when prompts mention jobs, code, models, scoring, CAS tables, content, or resources and the correct SAS domain is not yet clear.
+---
+
+# SAS Request Classifier
+
+Use this skill to determine what kind of SAS object, workflow, or environment the user is referring to before selecting tools.
+
+## When to use
+Use this skill when the request contains ambiguous domain terms such as:
+- model
+- 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.
+
+## Classification targets
+Classify the request into one or more of these categories:
+- Reading or querying tables → Route to **sas-read-strategy**
+- CAS resource, caslib, or table discovery → Route to **sas-find-library-smart** or **sas-list-tables-smart**
+- SAS data, libref, or table discovery → Route to **sas-find-library-smart** or **sas-list-tables-smart**
+- Score model or scoring artifact → Route to **sas-score-workflow**
+- Read data and score together → Route to **sas-read-and-score**
+- 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-library-smart** — Find CAS or SAS libraries
+   - **sas-list-tables-smart** — Browse tables in a library
+   - **sas-read-strategy** — Choose read-table vs. sas-query for data retrieval
+   - **sas-read-and-score** — Combine data reading with model scoring
+   - **sas-score-workflow** — Route scoring requests to correct execution engine
+6. Only after classification and skill guidance, use MCP tools.
+
+## Disambiguation hints
+- "Run" often implies job execution, but may also mean scoring or model invocation. Check for "score" or "model" context.
+- "Model" may refer to MAS models, SAS jobs, jobdefs, or SCR models. Look for context or type suffix (e.g., `.job`, `.mas`, `.scr`).
+- "Score" may refer to model scoring or job execution. Look for model name or context.
+- "Table" usually suggests CAS, but confirm library name and server context.
+- "Find", "list", "browse" — starts as discovery. Route to sas-find-library-smart or sas-list-tables-smart.
+- "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 or sas-score-workflow.
+
+## 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

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

@@ -0,0 +1,314 @@
+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".
+---
+
+# SAS Score Workflow
+
+Orchestrates model validation, type-based routing, scoring invocation, and result presentation. 
+Handles both MAS models and alternative scoring engines (jobs, jobdefs, SCR, SAS programs).
+
+---
+
+## Generic Scoring Syntax
+
+Users can invoke scoring with a unified syntax that automatically routes to the correct tool:
+
+```
+score with model <name>.<type> [scenario =<key=value pairs>]
+score <name>.<type> [scenario =<key=value pairs>]
+```
+
+**Type determines the routing:**
+- `.job` → route to `sas-score-run-job` with scoring parameters
+- `.jobdef` → route to `sas-score-run-jobdef` with scoring parameters
+- `.mas` → route to `sas-score-model-score` (Model Analytical Service — default)
+- `.scr` → route to `sas-score-scr-score` (SAS Container Runtime)
+- `.sas` → route to `sas-score-run-sas-program` to run sas program in folder
+
+If no type is specified (bare model name), assume `.mas` (MAS model).
+
+---
+
+## Type-Based Routing
+
+### Parse and Strip Model Type
+
+When a user provides a model name with a type suffix (e.g., `simplejon.job`, `churn.mas`):
+
+1. **Extract the type:** Split on the last dot to identify the type suffix
+   - `simplejon.job` → type = `job`, base name = `simplejon`
+   - `churn.mas` → type = `mas`, base name = `churn`
+   - `fraud_detector.jobdef` → type = `jobdef`, base name = `fraud_detector`
+
+2. **Validate the type:** Confirm it matches one of the supported types: `job`, `jobdef`, `mas`, `scr`, `sas`
+   - If type is unrecognized, assume `.mas` (default MAS model) and treat the entire input as the model name
+
+3. **Strip the type suffix:** Remove the `.type` from the model name before passing to the routing tool
+   - **Critical:** Always pass the base name (without the dot and type) to the invoked tool
+   - `simplejon.job` → pass `simplejon` to `sas-score-run-job`
+   - `churn.mas` → pass `churn` to `sas-score-model-score`
+   - `fraud_detector.jobdef` → pass `fraud_detector` to `sas-score-run-jobdef`
+
+### Type: `.mas` (Model Aggregation Service)
+- **Tool**: `sas-score-model-score`
+- **Use for**: Standard MAS-deployed predictive models
+- **Example**: `score with model churn.mas scenario =age=45,income=60000`
+- **Invocation**: `sas-score-model-score({ model: "churn", scenario: {...} })`
+
+### Type: `.job` (SAS Viya Job)
+- **Tool**: `sas-score-run-job`
+- **Use for**: Pre-built scoring jobs with parameters
+- **Example**: `score with model monthly_scorer.job scenario =month=10,year=2025`
+- **Invocation**: `sas-score-run-job({ name: "monthly_scorer", scenario: {...} })`
+
+### Type: `.jobdef` (SAS Viya Job Definition)
+- **Tool**: `sas-score-run-jobdef`
+- **Use for**: Job definitions that perform scoring logic
+- **Example**: `score with model fraud_detector.jobdef using amount=500,merchant=online`
+- **Invocation**: `sas-score-run-jobdef({ name: "fraud_detector", scenario: {...} })`
+
+### Type: `.scr` (Score Code Runtime)
+- **Tool**: `sas-score-scr-score`
+- **Use for**: Models deployed in SCR containers (REST endpoints)
+- **Example**: `score https://scr-host/models/loan.scr using age=45,credit=700`
+- **Invocation**: `sas-score-scr-score({ url: "https://scr-host/models/loan", scenario: {...} })`
+
+### Type: `.sas` (SAS Program / SQL)
+- **Tool**: `sas-score-run-sas-program`
+- **Use for**: Custom SAS or SQL scoring code
+- **Example**: `score my_scoring_code.sas using x=1,y=2`
+- **Invocation**: `sas-score-run-sas-program({ folder: "my_scoring_code", scenario: {...} })`
+
+
+
+---
+
+## Scenario Parsing
+
+The scenario parameter (comma-separated key=value pairs) is parsed into an object:
+
+```
+scenario =age=45,income=60000,region=South
+  ↓ parsed as:
+{ age: "45", income: "60000", region: "South" }
+```
+
+Accepted formats:
+- **String**: `age=45,income=60000`
+- **Object**: `{ age: 45, income: 60000 }`
+- **Array** (batch): `[ {age:45, income:60000}, {age:50, income:75000} ]`
+
+---
+
+## Integration with other skills
+
+- **Before scoring table data**: Use `sas-find-library-smart` to verify the library, then `sas-read-strategy` to fetch records
+- **For read + score workflows**: Use `sas-read-and-score` for the complete end-to-end pattern
+
+---
+
+## Step 1 — Check model familiarity before scoring
+
+Score immediately if:
+- The user names a specific model they've used before in this session, OR
+- The model name matches a previously confirmed model in the conversation
+
+Pause and suggest investigation if:
+- The model name is new, vague, or misspelled-looking (e.g. "the churn one", "that cancer model")
+- The user seems unsure of the required input variable names
+
+**Suggested message:**
+> "I don't recognize that model — want me to run `find-model` to confirm it exists,
+> or `model-info` to check its required inputs first?"
+
+---
+
+## Step 2 — Prepare the scenario data
+
+**For a single record** (one object):
+```javascript
+scenario = { field1: value1, field2: value2, ... }
+```
+
+**For batch scoring** (multiple records — the typical case):
+```javascript
+scenario = [
+  { field1: val1, field2: val2, ... },
+  { field1: val3, field2: val4, ... },
+  ...
+]
+```
+
+**Critical rules:**
+- Loop or call sas-score-model-score **once per row**.
+- Field names in the scenario must match the model's expected input variable names **exactly**.
+  - If table column names differ from model input names, **flag this to the user** and ask for confirmation before scoring.
+  - Example: Table has `age_years`, but model expects `age` → ask user which column maps to which input.
+- Do not add units, labels, or extra metadata — raw field values only.
+
+---
+
+## Step 3 — Invoke the appropriate scoring tool
+
+Based on the type extracted from the model name, invoke the corresponding tool:
+
+**For `.mas` (default):**
+```javascript
+sas-score-model-score({
+  model: "<modelname>",
+  scenario: scenario,  // object or array
+  uflag: false         // set true if you need field names prefixed with _
+})
+```
+
+**For `.job`:**
+```javascript
+sas-score-run-job({
+  name: "<jobname>",
+  scenario: scenario
+})
+```
+
+**For `.jobdef`:**
+```javascript
+sas-score-run-jobdef({
+  name: "<jobdefname>",
+  scenario: scenario
+})
+```
+
+**For `.scr`:**
+```javascript
+sas-score-scr-score({
+  url: "<scr_endpoint_url>",
+  scenario: scenario
+})
+```
+
+**For `.sas`:**
+```javascript
+sas-score-run-sas-program({
+  src: "<sas_or_sql_code>",
+  scenario: scenario
+})
+```
+
+**Rules:**
+- Pass the full batch in one call; do not loop over rows
+- If scoring fails, return the structured error and suggest troubleshooting
+- For MAS models, include uflag parameter if underscore-prefixed output is needed
+- For jobs/jobdefs, scenario becomes parameter arguments
+- For SCR, include full URL endpoint
+
+---
+
+## Step 4 — Present the results
+
+Merge the scoring output back with the input records and present as a table where possible.
+
+**Always surface:**
+- The key prediction/score field(s) (e.g. `P_churn`, `score`, `prediction`, `P_risk`)
+- Any probability/confidence fields for classification models (e.g. `P_class0`, `P_class1`)
+- Selected input fields that drove the prediction, so the user can see context
+
+**Formatting:**
+- Present results in a table for clarity
+- If results exceed 10 rows, show the first 10 and ask: *"Want to see more results or export the full set?"*
+- Round numeric predictions to 2–4 decimal places for readability
+
+---
+
+## Common flows
+
+**Flow A — Score rows with MAS model**
+> "Score the first 10 customers in Public.customers with the churn model"
+
+1. `sas-score-read-table` → { table: "Public.customers", limit: 10 }
+2. `sas-score-model-score` → { model: "churn", scenario: [ ...10 row objects ] }
+3. Present merged results with prediction + key inputs
+
+**Flow B — Score with a scoring job**
+> "Score December sales with the monthly_scorer job using month=12,year=2025"
+
+1. `sas-score-run-job` → { name: "monthly_scorer", scenario: { month: "12", year: "2025" } }
+2. Capture job output and tables
+3. Present results
+
+**Flow C — Score with a job definition**
+> "Run fraud detection jobdef on transaction amount=500, merchant=online"
+
+1. `sas-score-run-jobdef` → { name: "fraud_detection", scenario: { amount: "500", merchant: "online" } }
+2. Capture log, listings, and tables
+3. Present results
+
+**Flow D — Score with SCR endpoint**
+> "Score with the loan model at https://scr-host/models/loan using age=45, credit_score=700"
+
+1. `sas-score-scr-score` → { url: "https://scr-host/models/loan", scenario: { age: "45", credit_score: "700" } }
+2. Capture prediction response
+3. Present result
+
+**Flow E — Score results of an analytical query with MAS**
+> "Score high-value customers (spend > 5000) in mylib.sales with the fraud model"
+
+1. `sas-score-sas-query` → { table: "mylib.sales", sql: "SELECT * FROM mylib.sales WHERE spend > 5000" }
+2. `sas-score-model-score` → { model: "fraud", scenario: [ ...result rows ] }
+3. Present merged results
+
+**Flow F — User supplies scenario data directly**
+> "Score age=45, income=60000, region=South with the churn model"
+
+1. Skip read step
+2. `sas-score-model-score` → { model: "churn", scenario: { age: "45", income: "60000", region: "South" } }
+3. Present result
+
+**Flow G — Model unfamiliar, need to confirm**
+> "Score Public.applicants with the creditRisk2 model"
+
+1. Pause — "creditRisk2" is new
+2. Suggest: `find-model` to confirm it exists, `model-info` to get input variables
+3. Once confirmed → `sas-score-read-table` + `sas-score-model-score`
+
+**Flow H — Generic score syntax with type routing**
+> "score with model churn.mas scenario =age=45,income=60000"
+> "score fraud_detector.jobdef where scenario =amount=500"
+> "score monthly_report.job using month=10,year=2025"
+
+1. Parse model name to extract type (.mas, .job, .jobdef, .scr, .sas)
+2. Route to appropriate tool based on type
+3. Parse scenario and invoke tool with parameters
+4. Present results from routed tool
+
+---
+
+## Error handling
+
+| Problem | Action |
+|---|---|
+| Model not found | Suggest `find-model` to verify the model is deployed |
+| Input field name mismatch | Show the mismatch (table has X, model expects Y), ask user to confirm mapping |
+| 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 |
+
+---
+
+## Tips
+
+- **Batch is better:** Always pass the full set of records in one `sas-score-model-score` call. Do not loop.
+- **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-library-smart` to verify the library, then `sas-read-strategy` to fetch records
+- **For read + score workflows**: Use `sas-read-and-score` for the complete end-to-end pattern

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sassoftware/sas-score-mcp-serverjs",
-  "version": "0.4.1-22",
+  "version": "0.4.1-24",
   "description": "A mcp server for SAS Viya",
   "author": "Deva Kumar <deva.kumar@sas.com>",
   "license": "Apache-2.0",
@@ -43,7 +43,7 @@
     "openApi.json",
     "openApi.yaml",
     "scripts",
-    ".github"
+    ".skills"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",