@sassoftware/sas-score-mcp-serverjs 1.0.1-2 → 1.0.1-21

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

@@ -0,0 +1,134 @@
+---
+name: read-strategy
+description: >
+  Strategy for reading data from CAS or SAS tables. Determines which read tool to use (raw reads vs analytical queries).
+---
+
+# Read Table Strategy
+
+Use this strategy when the user requests to read, fetch, or query data from a table.
+
+## Prerequisites
+
+Before reading:
+1. Verify the table exists using FIND-RESOURCE strategy
+2. Determine the server (CAS or SAS) from Step 1
+
+---
+
+## Two Types of Read Operations
+
+### Type 1: Raw Row Read
+
+**Trigger phrases**: "read rows from", "show first N records", "fetch records where", "get data from table"
+
+**Tool**: `sas-score-read-table`
+
+**When to use**:
+- User wants raw records, not aggregations
+- User wants to filter by WHERE clause
+- User wants to browse data
+
+**Parameters**:
+```
+lib: "<library>"           # from FIND-RESOURCE verification
+table: "<table>"           # from FIND-RESOURCE verification
+server: "cas" or "sas"     # from FIND-RESOURCE verification
+start: <row number>        # default 1
+limit: <max rows>          # default 10, max 1000
+where: "<SQL WHERE clause>"  # optional filter
+format: true               # default: use formatted values
+```
+
+**Example**:
+```
+sas-score-read-table({
+  lib: "Public",
+  table: "customers",
+  server: "cas",
+  limit: 25,
+  where: "status='active'"
+})
+```
+
+---
+
+### Type 2: Analytical Query
+
+**Trigger phrases**: "how many", "count by", "average", "total", "sum", "group by", "aggregate", "distinct", "join"
+
+**Tool**: `sas-score-sas-query`
+
+**When to use**:
+- User wants aggregations (SUM, AVG, COUNT, etc.)
+- User wants GROUP BY or distinct counts
+- User wants JOIN across tables
+- User wants statistical summaries
+
+**Parameters**:
+```
+table: "lib.table"         # CAS: "Public.customers", SAS: "SASHELP.cars"
+query: "<natural language question>"
+sql: "<SELECT SQL>"        # optional: pre-generated SQL
+```
+
+**Example**:
+```
+sas-score-sas-query({
+  table: "Public.customers",
+  query: "count of customers by region and status",
+  sql: "SELECT region, status, COUNT(*) as count FROM Public.customers GROUP BY region, status"
+})
+```
+
+---
+
+## Decision Tree
+
+```
+User requests data from table
+  ↓
+Is it an aggregation? (count, sum, avg, group by, distinct, etc.)
+  ├─ YES → Use sas-score-sas-query
+  └─ NO → Use sas-score-read-table
+```
+
+---
+
+## Table Name Format
+
+- **CAS tables**: `Caslib.table` or `Public.customers` (lowercase caslib, mixed case table)
+- **SAS tables**: `LIBREF.table` or `SASHELP.cars` (uppercase libref, case-insensitive table)
+
+---
+
+## Error Handling
+
+| Error | Action |
+|---|---|
+| Table not found | Verify table exists with FIND-RESOURCE first |
+| Server mismatch | Use server from FIND-RESOURCE verification |
+| Empty result | Ask user to adjust WHERE clause or criteria |
+| Column not found | Ask user to verify column name (case sensitivity) |
+
+---
+
+## Examples
+
+### Example 1: Browse customer records
+**Request**: "read first 20 customers from Public"
+1. Find table customers in Public → CAS
+2. Read: `sas-score-read-table({ lib: "Public", table: "customers", server: "cas", limit: 20 })`
+3. Return 20 rows
+
+### Example 2: Find active customers in a region
+**Request**: "fetch customers from Public where status='active' and region='East'"
+1. Find table customers in Public → CAS
+2. Read: `sas-score-read-table({ lib: "Public", table: "customers", server: "cas", where: "status='active' and region='East'" })`
+3. Return matching rows
+
+### Example 3: Aggregate customers by region
+**Request**: "how many customers by region in Public.customers"
+1. Find table customers in Public → CAS
+2. Query: `sas-score-sas-query({ table: "Public.customers", query: "count of customers by region", sql: "SELECT region, COUNT(*) FROM Public.customers GROUP BY region" })`
+3. Return aggregated result

package/.skills/skills/request-routing/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: request-routing
+description: >
+  Universal routing strategy for all SAS Viya requests. Every request follows the same three-step workflow.
+---
+
+# Universal Request Routing Strategy
+
+All SAS Viya requests follow this three-step workflow:
+
+## Step 1: Verify Resources Exist
+
+Before executing any action, verify that the target resources exist.
+
+| Resource Type | Find Tool | Notes |
+|---|---|---|
+| Library | `sas-score-find-library` | Specify server (cas or sas). For tables, determine server here. |
+| Table | `sas-score-find-table` | Requires library name and server. |
+| MAS Model | `sas-score-find-model` | No server selection. |
+| Job | `sas-score-find-job` | No server selection. |
+| JobDef | `sas-score-find-jobdef` | No server selection. |
+| SCR Model | Skip verification | SCR models do not require pre-verification. |
+
+**Rule**: Always verify before executing. Exception: SCR models can be scored directly.
+
+---
+
+## Step 2: Execute the Request
+
+Once resources are verified to exist, select the appropriate execution tool:
+
+| Request Type | Tool | Input |
+|---|---|---|
+| Read table rows | `sas-score-read-table` | lib, table, server (from Step 1) |
+| Query table (aggregation) | `sas-score-sas-query` | lib.table, SQL query |
+| Score with MAS model | `sas-score-mas-score` | model name, scenario data |
+| Run Job | `sas-score-run-jobdef` | job name, scenario parameters |
+| Run JobDef | `sas-score-run-jobdef` | jobdef name, scenario parameters |
+| Score with SCR model | `sas-score-scr-score` | SCR URL, scenario data |
+
+---
+
+## Step 3: Merge Results
+
+Combine verification and execution results:
+
+- For **read/query**: Return rows as-is.
+- For **scoring**: Merge predictions with input scenario data.
+- For **jobs/jobdefs**: Return execution results (tables, logs).
+
+---
+
+## Special Case: Read + Score (Combined Workflow)
+
+When the user requests scoring records from a table:
+
+1. **Verify**: Find the table (determine server), find the model.
+2. **Read**: Fetch rows from the table using `sas-score-read-table` or `sas-score-sas-query`.
+3. **Map**: Check if table columns match model input variables. Ask user for mapping if needed.
+4. **Score**: Score each row using `sas-score-mas-score` (for MAS) or `sas-score-scr-score` (for SCR).
+5. **Merge**: Combine predictions with original rows.
+
+---
+
+## Error Handling
+
+| Error | Action |
+|---|---|
+| Resource not found | Ask user to verify name and server (for tables). |
+| Column/input mismatch | Ask user to map table columns to model inputs. |
+| Empty result | Ask whether to adjust filter/criteria. |
+
+---
+
+## Examples
+
+### Example 1: Read a table
+**Request**: "read customers in Public"
+1. Find library Public → Verified (CAS)
+2. Read table customers in Public (CAS)
+3. Return rows
+
+### Example 2: Score with inline scenario
+**Request**: "score a=1, b=2 with model simplejob.job"
+1. Find job simplejob → Verified
+2. Run simplejob with scenario {a: 1, b: 2}
+3. Return result
+
+### Example 3: Score records from table
+**Request**: "score records from Public.customers with model risk_model.mas"
+1. Find table customers in Public → Verified (CAS)
+2. Find model risk_model → Verified (MAS)
+3. Read rows from Public.customers
+4. Score each row with risk_model
+5. Return merged predictions + original data

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

@@ -0,0 +1,210 @@
+---
+name: score-strategy
+description: >
+  Unified scoring workflow. Handles MAS, Job, JobDef, SCR, and combined read+score scenarios.
+  Always verify resources before scoring.
+---
+
+# Score Strategy
+
+Use this strategy when the user requests model scoring, predictions, or running jobs/jobdefs.
+
+## Prerequisites
+
+1. Verify the model/job exists using find-resources skill
+2. If scoring table rows: Verify the table exists and determine server using find-resources skill
+3. If scoring with inline scenario: Parse the scenario data
+
+---
+
+## Step 1: Parse the Score Request
+
+Identify the scoring target (model type) and input source:
+
+### Identify Model Type
+
+```
+score with model X.mas       → MAS model
+score with model X.job       → Job
+score with model X.jobdef    → JobDef
+score with model X.scr       → SCR model
+score with model X           → Default to MAS
+```
+
+### Identify Input Source
+
+```
+score a=1, b=2               → Inline scenario
+score with scenario {...}    → Inline scenario
+score records from table X   → Table rows
+score results of query...    → Query results
+```
+
+---
+
+## Step 2: Execute Scoring
+
+### Option A: Score with Inline Scenario
+
+**Trigger phrases**: "score a=1, b=2", "predict with values", "score scenario"
+
+**Tools**:
+- MAS: `sas-score-mas-score`
+- Job: `sas-score-run-job`
+- JobDef: `sas-score-run-jobdef`
+- SCR: `sas-score-scr-score`
+
+**Flow**:
+1. Find model (find-resources)
+2. Score with inline data
+3. Return prediction + input data merged
+
+**Parameters** (MAS):
+
+```
+sas-score-mas-score({
+  model: "<model name>",
+  scenario: { a: 1, b: 2 }  
+```
+**Parameters** (job):                                           ):
+```
+sas-score-run-job({
+  name: "<job name>",
+  scenario: { a: 1, b: 2 }
+})
+```
+
+**Parameters** (jobdef):
+```
+sas-score-run-jobdef({
+  name: "<jobdef name>",
+  scenario: { a: 1, b: 2 }
+})
+```
+
+**Parameters** (SCR):
+```
+sas-score-scr-score({
+  url: "<scr endpoint>",
+  scenario: { a: 1, b: 2 }
+})
+```
+
+---
+
+### Option B: Score Table Rows (Read + Score)
+
+**Trigger phrases**: "score records from", "run model on table", "predict for customers in", "score rows from"
+
+**Flow**:
+1. Find model (find-resources)
+2. Find table (find-resources) → get server
+3. Read rows from table (read-strategy)
+4. Score each row (or batch score)
+5. Merge predictions with original rows
+
+**Decision**: Read strategy first
+- If user requests aggregation: Use `sas-score-sas-query`
+- If user requests raw rows: Use `sas-score-read-table`
+
+**Example workflow**:
+```
+Request: "score records from Public.customers with model risk_model"
+
+1. Find table customers in Public → CAS
+2. Find model risk_model → MAS
+3. Read rows: sas-score-read-table({ lib: "Public", table: "customers", server: "cas", limit: 1000 })
+4. Score each row: for each row, sas-score-mas-score({ model: "risk_model", scenario: {row} })
+5. Merge: combine risk score with customer data
+```
+
+---
+
+## Step 3: Result Formatting
+
+### MAS Scoring Result
+
+Return merged object:
+```
+Input data + Prediction fields
+Example: { a: 1, b: 2, prediction: 0.85, probability_0: 0.15, probability_1: 0.85 }
+```
+
+### Job/JobDef Result
+
+Return execution output:
+```
+Tables, logs, listings as returned by job
+```
+
+### SCR Result
+
+Return merged object:
+```
+Input data + Prediction fields from SCR response
+```
+
+### Batch Scoring (Table Rows)
+
+Return rows with predictions appended:
+```
+[
+  { customer_id: 1, name: "Alice", ..., risk_score: 0.32 },
+  { customer_id: 2, name: "Bob", ..., risk_score: 0.78 },
+  ...
+]
+```
+
+---
+
+## Column/Variable Mapping
+
+If table columns don't match model input variable names:
+
+1. Ask user: "Which table column maps to model input X?"
+2. Wait for mapping: e.g., { customer_age: age, customer_income: income }
+3. Transform row data using mapping
+4. Score transformed data
+5. Return with original column names
+
+---
+
+## Error Handling
+
+| Error | Action |
+|---|---|
+| Model not found | Verify model name with user |
+| Table not found | Verify table name and library |
+| Scenario mismatch | Ask user to verify input variable names |
+| Empty table | Ask whether to adjust filter or continue |
+| Scoring failure | Return error message from scoring tool |
+
+---
+
+## Examples
+
+### Example 1: Score with inline scenario
+**Request**: "score a=1, b=2 with model simplejob.job"
+1. Find job simplejob using find-resources strategy
+2. Run: `sas-score-run-jobdef({ name: "simplejob", scenario: { a: 1, b: 2 } })`
+3. Return: `{ c: 3 }`
+
+### Example 2: Score with MAS model
+**Request**: "predict churn for age=45, income=60000 with model churn_predictor"
+1. Find model churn_predictor.mas using find-resources strategy
+2. Score: `sas-score-mas-score({ model: "churn_predictor", scenario: { age: 45, income: 60000 } })`
+3. Return: `{ age: 45, income: 60000, churn_probability: 0.23, prediction: "no_churn" }`
+
+### Example 3: Score table rows
+**Request**: "score all active customers with model risk_model and table Public.customers"
+1. Find model risk_model.mad using find-resources strategy
+2. Find table Public.customers using find-resources strategy
+3. Read: `sas-score-read-table({ lib: "Public", table: "customers", server: "cas", where: "status='active'" })`
+4. Score each row with risk_model
+5. Return: customers with risk_score appended
+
+### Example 4: Score with SCR model
+**Request**: "score age=50, income=75000 with model loan.scr"
+1. Prepare: SCR URL for "loan"
+2. Score: `sas-score-scr-score({ url: "loan", scenario: { age: 50, income: 75000 } })`
+3. Return predictions from SCR endpoint

package/README.md

@@ -196,7 +196,15 @@ NODE_EXTRA_CA_CERTS=c:\Users\<your_username>\AppData\Local\mkcert\rootCA.pem
 ```
 
 ## License
-This project is licensed under the [Apache 2.0 license](LICENSE).
+
+
+This project is licensed under the Apache License 2.0. See LICENSE.
+
+The container image published from this repository also includes third-party software, each component under its own license:
+
+The npm dependencies that ship with this project, along with their respective licenses, are listed in LICENSES.json.
+The container is built from the 25-alpine base image; license texts for its included software ship inside the image itself.  License information for each Alpine package is available at pkgs.alpinelinux.org.
+As with any container image, direct and indirect dependencies are governed by their own licenses. Users of the published container image are responsible for ensuring that their use complies with all applicable licenses.
 
 ## Additional Resources
 

package/cli.js

@@ -9,15 +9,11 @@
 
 import coreSSE from './src/coreSSE.js';
 import expressMcpServer from './src/expressMcpServer.js';
-import hapiMcpServer from './src/hapiMcpServer.js';
-
 import createMcpServer from './src/createMcpServer.js';
 // import dotenvExpand from 'dotenv-expand';
 import fs from 'fs';
 import { randomUUID } from 'node:crypto';
 
-//import refreshToken from './src/toolHelpers/refreshToken.js';
-//import getOptsViya from './src/toolHelpers/getOptsViya.js';
 import readCerts from './src/toolHelpers/readCerts.js';
 
 import { fileURLToPath } from 'url';
@@ -72,11 +68,6 @@ const args = parseArgs({
       short: 'c',
       description: 'Client ID for authentication'
     },
-    clientsecret: {
-      type: 'string',
-      short: 's',
-      description: 'Client Secret for authentication'
-    },
     profile: {
       type: 'string',
       description: 'SAS CLI profile name'
@@ -107,6 +98,17 @@ const args = parseArgs({
       alias: 'mcpclient',
       description: 'MCP client name (github, claude...). Defaults to \'github\''
     },
+    folder: {
+      type: 'string',
+      short: 'f',
+      description: 'Subfolder under the client folder to copy the skills to, used to have different set of skills for different agents under the same client'
+
+    },
+    skills: {
+      type: 'string',
+      short: 's',
+      description: 'Copies the skills for .github and .claude to the user home directory under .clientname (e.g. .github) or current directory if client name starts with dot (e.g. ./.github), used to have different set of skills for different clients'
+    },
     help: {
       type: 'boolean',
       short: 'h',
@@ -125,28 +127,28 @@ const args = parseArgs({
 // Handle help flag
 if (args.values.help) {
   console.error(`
-                SAS Viya Scoring Expert Agent - Version: ${JSON.parse(pkg).version}
+                sas-score-mcp-serverjs - Version: ${JSON.parse(pkg).version}
 
 Usage: npx @sassoftware/sas-score-mcp-serverjs@dev [options]
 
 Options:
   Minimal options:
     -v, --viya <url>               Viya server URL
-    -c, --clientid <id>            Client ID for oauth authentication(pkce preferred. default: vscodemcp)
   
   MCP server options:
     -t, --mcptype <type>           MCP server type: http or stdio (default: http)
     -m, --mcphost <host>           MCP server host - can be remote URL - (default: http://localhost:8080)
   
-  Agent options:
-    --agent                        Enable agent mode with a pre-configured set of skills based on the client specified (default: false)
-    --client <name>                MCP client name (github, claude...). Defaults to 'github'.Use to install skills
   Authentication options:
+    -c, --clientid <id>            Client ID for oauth authentication(pkce preferred. default: vscodemcp)
     -a, --authflow <flow>          Authentication flow: oauth, oauthclient, sascli, code, token(default oauth)
-    -s, --clientsecret <secret>   Client Secret for oauth authentication (not needed for pkce)
     --profile <name>               SAS CLI profile name for sascli flow (default: Default)
     --config <path>                SAS CLI config directory for sascli flow (default: user home directory)
 
+  Agent/skills options:
+    -s, --skills  <name>           Copies the skills for .github and .claude
+    -f, --folder <folder>          Subfolder to copy the skills to. ex: ./github/<folder>, used to have different set of skills for different agents under the same client. 
+ 
   Other options:
     -p, --port <port>              Port to run the server on (default: 8080)
     --https                        Use HTTPS for the server (default: false)
@@ -165,6 +167,13 @@ Environment Variables:
   `);
   process.exit(0);
 }
+if (args.values.skills) {
+  console.error(`[Note] Settings up skills for ${args.values.skills }`);
+  setupSkills(args.values.skills, args.values.folder);;
+  console.error(`[Note] Skills setup completed. `);
+  process.exit(0);
+}
+
 console.error('Parsed command line arguments:', args.values);
 // read env file and then override with command line arguments
 if (args.values.env) {
@@ -194,7 +203,7 @@ process.env.AUTHFLOW = args.values.authflow || process.env.AUTHFLOW || 'oauth';
 process.env.MCPCLIENT = args.values.client || process.env.MCPCLIENT || 'github';
 process.env.VIYA_SERVER = args.values.viya || process.env.VIYA_SERVER;
 process.env.CLIENTID = args.values.clientid || process.env.CLIENTID || 'vscodemcp';
-process.env.CLIENTSECRET = args.values.clientsecret || process.env.CLIENTSECRET || null;
+process.env.CLIENTSECRET = null;
 process.env.SAS_CLI_PROFILE = args.values.profile || process.env.SAS_CLI_PROFILE || 'Default';
 process.env.SAS_CLI_CONFIG = args.values.config || process.env.SAS_CLI_CONFIG || os.homedir(); // default to user home directory
 process.env.CASSERVER = args.values.casserver || process.env.CASSERVER || 'cas-shared-default';
@@ -219,6 +228,7 @@ if (args.values.version) {
 console.error(`[Note] MCP client set to: ${process.env.CLIENT}`);
 
 
+
 /********************************* */
 const BRAND = 'sas-score'
 /********************************* */
@@ -373,10 +383,13 @@ if (appEnvBase.TOKENFILE != null) {
 
 // setup skills based on client before mcp initialization
 //
+
+
+
 if (process.env.AGENT === 'TRUE') {
   if (process.env.CLIENT !== 'none') {
     console.error(`[Note] Setting up skills for client: ${process.env.CLIENT}...`);
-    setupSkills(process.env.CLIENT);
+    setupSkills(process.env.CLIENT, args.values.folder); 
   } 
 } else {
     console.error(`[Note] Agent mode not enabled`);
@@ -453,14 +466,8 @@ if (mcpType === 'stdio') {
 
 } else {
   console.error('[Note] Starting HTTP MCP server...');
-  if (useHapi === true) {
-    process.env.AUTHTYPE = null;
-    await hapiMcpServer(mcpServer, sessionCache, appEnvBase);
-    console.error('[Note] Using HAPI HTTP server...')
-  } else {
-    await expressMcpServer(mcpServer, sessionCache, appEnvBase);
-    console.error('[Note] MCP HTTP express server started on port ' + appEnvBase.PORT);
-  }
+  await expressMcpServer(mcpServer, sessionCache, appEnvBase);
+  console.error('[Note] MCP HTTP express server started on port ' + appEnvBase.PORT);
 }
 
 // custom reader for .env file to avoid dotenv logging to console

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sassoftware/sas-score-mcp-serverjs",
-  "version": "1.0.1-2",
+  "version": "1.0.1-21",
   "description": "A mcp server for SAS Viya",
   "author": "Deva Kumar <deva.kumar@sas.com>",
   "license": "Apache-2.0",
@@ -46,11 +46,10 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@sassoftware/restaf": "^5.6.0",
-    "@sassoftware/restafedit": "^3.11.1-10",
-    "@sassoftware/restaflib": "^5.6.0",
-    "@sassoftware/viya-serverjs": "^0.6.3-0",
-    "axios": "^1.13.2",
+    "@sassoftware/restaf": "^5.7.2",
+    "@sassoftware/restafedit": "^3.10.5",
+    "@sassoftware/restaflib": "^5.7.2",
+    "axios": "^1.13.5",
     "body-parser": "^2.2.1",
     "cors": "^2.8.5",
     "cross-env": "^10.1.0",
@@ -62,8 +61,8 @@
     "node-cache": "^5.1.2",
     "open": "^11.0.0",
     "selfsigned": "^5.2.0",
-    "undici": "^7.16.0",
-    "uuid": "^13.0.0",
+    "undici": "^7.24.0",
+    "uuid": "^14.0.0",
     "zod": "^4.2.1"
   },
   "devDependencies": {

package/scripts/setup-skills.js

@@ -6,7 +6,7 @@ import os from 'os';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // Paths
 let client = (process.env.CLIENTNAME == null) ? '.github' : `.${process.env.CLIENTNAME.toLowerCase()}`;
-const source = path.join(__dirname, `../.skills`);
+const source = path.join(__dirname, `../.github`);
 const destination = path.join(process.cwd(), client);
 // const destination = path.join(os.homedir(), client)
 console.error(`📁 Copying ${source} to ${destination}...`);

package/src/oauthHandlers/callback.js

@@ -75,7 +75,7 @@ async function callback(req, res, pkceStore, codeStore, appContext) {
     // which was part of the payload from the client to /oauth/authorize
     // we trust since it was associated with the valid PKCE state
     console.error("[Note] OAuth callback complete, redirecting to MCP client");
-    console.log(pending.clientRedirectUri.toString())
+    console.error(pending.clientRedirectUri.toString())
     return res.redirect(`${pending.clientRedirectUri}?${redirectParams}`);
   } catch (err) {
     console.error("[Error] OAuth callback handler error:", err);

package/src/processHeaders.js

@@ -34,7 +34,7 @@ function processHeaders(req, res, next, cache, appContext) {
   let token = (hdr != null) ? hdr.slice(7) : null;
   //console.error("[Note] Authorization token", token);
   debugger;
-  console.log('>>>',appContext.AUTHFLOW);
+  console.error('>>>',appContext.AUTHFLOW);
   if (appContext.AUTHFLOW === 'bearer') {
     debugger;
     let startAuth = false;