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

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

@@ -0,0 +1,314 @@
+---
+name: sas-score-workflow-strategy
+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-resource-strategy` to verify library/table/model resources, then `sas-read-strategy` to fetch records
+- **For read + score workflows**: Use `sas-read-and-score-strategy` for the complete end-to-end pattern
+
+---
+
+## 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 use `sas-find-resource-strategy` 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: `sas-find-resource-strategy` to confirm resource existence, `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 | Use `sas-find-resource-strategy` to verify the model (or job/jobdef type) exists |
+| 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-resource-strategy` to verify resources, then `sas-read-strategy` to fetch records
+- **For read + score workflows**: Use `sas-read-and-score-strategy` for the complete end-to-end pattern

package/cli.js

@@ -16,8 +16,6 @@ import createMcpServer from './src/createMcpServer.js';
 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 +70,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,12 +100,17 @@ const args = parseArgs({
       alias: 'mcpclient',
       description: 'MCP client name (github, claude...). Defaults to \'github\''
     },
-    agentfolder: {
+    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',
@@ -131,29 +129,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
-    --agentfolder <folder>         Subfolder under the client folder to copy the skills to, used to have different set of skills for different agents under the same client
   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)
@@ -172,6 +169,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) {
@@ -201,7 +205,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';
@@ -381,10 +385,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, args.values.agentfolder); 
+    setupSkills(process.env.CLIENT, args.values.folder); 
   } 
 } else {
     console.error(`[Note] Agent mode not enabled`);

package/package.json

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

package/src/setupSkills.js

@@ -23,22 +23,41 @@ function setupSkills(clientName,agentFolder) {
     console.error("==================================================================");
     console.error(`           Copying ${source} to ${destination}...`);
 
+
+
+    // Copy agents folder if it exists
+     let agentsFromPath = path.join(__dirname, `../.agents`);
+     let agentsToPath = path.join(destination, 'agents');
+     copyFolderSync(agentsFromPath, agentsToPath);
+
+    // now  copy the skills folder to the destination
+    let toPath = path.join(destination, '.skills');
+    let fromPath = path.join(__dirname, `../.skills`);
+    copyFolderSync(fromPath, toPath);
+    
+    // Now copy instructions 
+    let instructionsFromPath = path.join(__dirname, `../.instructions`);
+    let instructionsToPath = destination;
+    copyFolderSync(instructionsFromPath, instructionsToPath);
+
     function copyFolderSync(from, to) {
         if (!fs.existsSync(from)) return [];
         if (!fs.existsSync(to)) fs.mkdirSync(to, { recursive: true });;
         fs.readdirSync(from).forEach(element => {
             const fromPath = path.join(from, element);
-            const toPath = path.join(to, element);
+            let  toPath = path.join(to, element);
+            if (clientName === 'claude' && element === 'copilot-instructions.md') {
+                toPath = path.join(to, 'CLAUDE.md');
+            }
             if (fs.lstatSync(fromPath).isFile()) {
                 console.error(`       📄 Copying file: ${element}`);
                 fs.copyFileSync(fromPath, toPath);
             } else if (fs.lstatSync(fromPath).isDirectory()) {
                 console.error(`📂 Copying folder: ${element}`);
-                copyFolderSync(fromPath, toPath) ;
+                copyFolderSync(fromPath, toPath);
             }
         });
     }
-
     function listExpandedFolder(dir, indent = "") {
         const entries = fs.readdirSync(dir, { withFileTypes: true });