@sassoftware/sas-score-mcp-serverjs 1.0.1-7 → 1.0.1-8

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

@@ -0,0 +1,155 @@
+---
+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.
+
+> 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`)
+
+---
+
+## 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 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
+
+- **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

@@ -0,0 +1,105 @@
+---
+name: sas-find-resource-strategy
+description: >
+  Unified strategy for finding SAS Viya resources using find tools only. Supports library, table,
+  model, job, and jobdef lookup with server-aware behavior for CAS/SAS resources. Use this skill
+  whenever the task is to verify whether a resource exists.
+---
+
+# SAS Find Resource Strategy
+
+Use this skill to verify resource existence without using list tools.
+
+## Scope
+
+Supported resource types:
+- library
+- table
+- model
+- job
+- jobdef
+
+## Mandatory rule
+
+- Use the sas-find-resource strategy to check for the existence of a resource before attempting to read or use it. This ensures that follow-up actions are based on accurate information about resource availability.
+- Do not use list tools to find a resource.
+
+## Tool mapping
+
+- Library -> `sas-score-find-library`
+- Table -> `sas-score-find-table`
+- Model -> `sas-score-find-model`
+- Job -> `sas-score-find-job`
+- Jobdef -> `sas-score-find-jobdef`
+
+## Strategy by resource type
+
+### Find library
+
+If server is provided:
+- CAS: `sas-score-find-library({ name: "<lib>", server: "cas" })`
+- 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.
+
+### Find table
+
+Required inputs:
+- library name
+- table name
+
+If server is provided:
+- CAS: `sas-score-find-table({ lib: "<lib>", name: "<table>", server: "cas" })`
+- 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.
+
+### Find model
+
+Use:
+- `sas-score-find-model({ name: "<model>" })`
+
+If a model type suffix is provided (for example `.mas`, `.job`, `.jobdef`, `.scr`):
+- For MAS model discovery, strip suffix and look up base name with `sas-score-find-model`.
+- For `.job` and `.jobdef`, use job and jobdef find tools instead of model find.
+
+### Find job
+
+Use:
+- `sas-score-find-job({ name: "<job>" })`
+
+### Find jobdef
+
+Use:
+- `sas-score-find-jobdef({ name: "<jobdef>" })`
+
+## Clarifying prompts
+
+Ask one focused question if required fields are missing:
+- Library missing for table lookup: "Which library contains the table?"
+- Table name missing: "Which table name should I check?"
+- Resource type ambiguous: "Do you want me to find a library, table, model, job, or jobdef?"
+
+## Output format
+
+For found resources:
+- Confirm exact resource name returned by the tool.
+- Confirm server when applicable (CAS/SAS).
+
+For not found resources:
+- State that the resource was not found.
+- Ask for corrected name or server context.
+
+## Examples
+
+- "find library Samples" -> CAS first, then SAS fallback using uppercase.
+- "find table costchange in Samples" -> CAS first, then SAS fallback using uppercase library.
+- "find model breastcancer" -> `sas-score-find-model`.
+- "find job simplejob" -> `sas-score-find-job`.
+- "find jobdef daily_run" -> `sas-score-find-jobdef`.

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

@@ -0,0 +1,124 @@
+---
+name: sas-list-resource-strategy
+description: >
+  Unified strategy for listing SAS Viya resources using list tools. Supports libraries,
+  tables, models, jobs, and jobdefs. Always normalize pagination so start and limit are
+  never null: default start=1 and limit=10 when not provided.
+---
+
+# SAS List Resource Strategy
+
+Use this skill to list resources with consistent pagination defaults.
+
+## Scope
+
+Supported resource types:
+- library
+- table
+- model
+- job
+- jobdef
+
+## Mandatory pagination rule
+
+For every list operation:
+- `start` must never be null
+- `limit` must never be null
+- If `start` is missing or null, set `start: 1`
+- If `limit` is missing or null, set `limit: 10`
+
+Normalization pattern:
+```
+start = (start == null) ? 1 : start
+limit = (limit == null) ? 10 : limit
+```
+
+## Tool mapping
+
+- Library -> `sas-score-list-libraries`
+- Table -> `sas-score-list-table`
+- Model -> `sas-score-list-models`
+- Job -> `sas-score-list-jobs`
+- Jobdef -> `sas-score-list-jobdefs`
+
+## Strategy by resource type
+
+### List libraries
+
+Use:
+```
+sas-score-list-libraries({
+  server: "all" | "cas" | "sas",  // optional based on user intent
+  start: 1,
+  limit: 10
+})
+```
+
+If user provides server, honor it. If not, use default server behavior.
+
+### List tables
+
+Required input:
+- library name (`lib`)
+
+Use:
+```
+sas-score-list-tables({
+  lib: "libraryname",
+  server: "cas" | "sas",  // optional if strategy/tool supports detection
+  start: 1,
+  limit: 10
+})
+```
+
+If `lib` is missing, ask: "Which library should I list tables from?"
+
+### List models
+
+Use:
+```
+sas-score-list-models({
+  start: 1,
+  limit: 10
+})
+```
+
+### List jobs
+
+Use:
+```
+sas-score-list-jobs({
+  start: 1,
+  limit: 10
+})
+```
+
+### List jobdefs
+
+Use:
+```
+sas-score-list-jobdefs({
+  start: 1,
+  limit: 10
+})
+```
+
+## Clarifying prompts
+
+Ask one focused question if required context is missing:
+- Resource type unclear: "Do you want libraries, tables, models, jobs, or jobdefs?"
+- Listing tables without library: "Which library should I list tables from?"
+
+## Output and paging
+
+- Return the listed resources from the selected tool.
+- If result count equals `limit`, suggest next page with `start + limit`.
+- Keep using normalized pagination defaults unless user overrides.
+
+## Examples
+
+- "list jobs" -> `sas-score-list-jobs({ start: 1, limit: 10 })`
+- "list models" -> `sas-score-list-models({ start: 1, limit: 10 })`
+- "list jobdefs" -> `sas-score-list-jobdefs({ start: 1, limit: 10 })`
+- "list tables in Public" -> `sas-score-list-tables({ lib: "Public", start: 1, limit: 10 })`
+- "next jobs" after `{ start: 1, limit: 10 }` -> `sas-score-list-jobs({ start: 11, limit: 10 })`

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

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

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

@@ -0,0 +1,113 @@
+---
+name: sas-read-and-score-strategy
+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-resource-strategy` for library lookup (CAS first, then SAS if needed)
+2. **Verify table exists**: Use `sas-find-resource-strategy` for table lookup in the selected library/server
+3. **Verify model exists**: Use `sas-find-resource-strategy` for model lookup before scoring
+4. **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
+- 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
+
+---
+
+## 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-resource-strategy` to verify library/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