@sassoftware/sas-score-mcp-serverjs 0.4.1-1 → 0.4.1-17

package/cli.js

@@ -21,10 +21,12 @@ import { randomUUID } from 'node:crypto';
 import readCerts from './src/toolHelpers/readCerts.js';
 
 import { fileURLToPath } from 'url';
-import { dirname } from 'path';
+import { dirname, join } from 'path';
+import os from 'os';
 import { parseArgs } from "node:util";
 
 import NodeCache from 'node-cache';
+import { be } from 'zod/locales';
 //import getOpts from './src/toolHelpers/getOpts.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -44,15 +46,40 @@ const args = parseArgs({
       short: 'm',
       description: 'MCP server type (http or stdio)'
     },
+    https: {
+      type: 'boolean',
+      description: 'Use HTTPS for the server (default: FALSE)'
+    },
+    'skills-folder': {
+      type: 'string',
+      short: 'f',
+      description: 'Skills folder name'
+    },
+
     viya: {
       type: 'string',
       short: 'v',
       description: 'Viya server URL'
     },
+    mcphost: {
+      type: 'string',
+      short: 'm',
+      description: 'MCP server host (default: http://localhost:8080)'
+    },
     authflow: {
       type: 'string',
       short: 'a',
-      description: 'Authentication flow (sascli, code, token)'
+      description: 'Authentication flow (sascli, code, token, oauth, oauth,oauthclient)'
+    },
+    clientid: {
+      type: 'string',
+      short: 'c',
+      description: 'Client ID for authentication'
+    },
+    clientsecret: {
+      type: 'string',
+      short: 's',
+      description: 'Client Secret for authentication'
     },
     profile: {
       type: 'string',
@@ -62,10 +89,22 @@ const args = parseArgs({
       type: 'string',
       description: 'SAS CLI config directory'
     },
-    envfile: {
+    casserver: {
+      type: 'string',
+      description: 'CAS server name (default: cas-shared-default)'
+    },
+    computecontext: {
+      type: 'string',
+      description: 'Compute session name or context (default: SAS Job Execution compute context)'
+    },
+    env: {
       type: 'string',
       short: 'e',
-      description: 'Environment file path'
+      description: 'Environment file path (default: .env in current working directory)'
+    },
+    client: {
+      type: 'string',
+      description: 'MCP client name (github, claude...). Defaults to \'github\''
     },
     help: {
       type: 'boolean',
@@ -74,9 +113,9 @@ const args = parseArgs({
     },
     version: {
       type: 'boolean',
-      short: 'v',
       description: 'Show version'
-    }
+    },
+
   },
   strict: false,
   allowPositionals: false
@@ -84,89 +123,131 @@ const args = parseArgs({
 
 // Handle help flag
 if (args.values.help) {
-  console.log(`
+  console.error(`
 Usage: sas-score-mcp-serverjs [options]
 
 Options:
-  -p, --port <port>           Port to run the server on (default: 8080)
-  -m, --mcptype <type>        MCP server type: http or stdio (default: http)
-  -v, --viya <url>            Viya server URL
-  -a, --authflow <flow>       Authentication flow: sascli, code, or token
-  --profile <name>            SAS CLI profile name
-  --config <path>             SAS CLI config directory
-  -e, --envfile <path>        Environment file path
-  -h, --help                  Show this help message
-  --version                   Show version
+  Minimal options:
+    -v, --viya <url>               Viya server URL
+    -c, --clientid <id>            Client ID for oauth authentication(pkce preferred)
+  
+  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)
+    --client <name>                MCP client name (github, claude...). Defaults to 'github'.Use to install skills
+  Authentication options:
+    -a, --authflow <flow>          Authentication flow: oauth, oauthclient, sascli, code, token(default oauth)
+    -s, --clientsecret <secret>    Client Secret for authentication(if necessary). See clientid option as well.
+    --profile <name>               SAS CLI profile name for sascli flow (default: Default)
+    --config <path>                SAS CLI config directory for sascli flow (default: user home directory)
+
+  Other options:
+    -p, --port <port>              Port to run the server on (default: 8080)
+    --https                        Use HTTPS for the server (default: false)
+    --casserver <name>             CAS server name (default: cas-shared-default)
+    --computecontext <name>        Compute session name or context (default: SAS Job Execution compute context) 
+
+    -e, --envfile <path>           Environment file path
+    -h, --help                     Show this help message
+    --version                      Show version
+  
 
 Environment Variables:
   Use .env file or set environment variables for configuration.
+  A alternative to cmd line arguments, and in some cases required for sensitive information like client secrets.
   See README.md for more information.
   `);
   process.exit(0);
 }
 
-// Handle version flag
-if (args.values.version) {
-  let pkgJson = JSON.parse(pkg);
-  console.log(pkgJson.version);
-  process.exit(0);
-}
-
-if (process.env.ENVFILE === 'FALSE') {
-  //use this when using remote mcp server and no .env file is desired
-  console.error('[Note]: Skipping .env file as ENVFILE is set to FALSE...');
-} else {
+// read env file and then override with command line arguments
+if (args.values.env) {
   console.error('Working Directory', process.cwd());
-  let envf = process.env.ENVFILE || (process.cwd() + '\\.env');
+  let envf = process.cwd() + '\\' + args.values.env;
   //__dirname + '\\.env';
-  console.error('Env file:', envf); 
+  console.error('Env file:', envf);
   if (fs.existsSync(envf)) {
     console.error(`Loading environment variables from ${envf}...`);
-    let e = iconfig(envf); // avoid dotenv since it writes to console.log
+    let e = iconfig(envf); // avoid dotenv since it writes to console.error
     console.error('[Note]: Environment variables loaded from .env file...');
     console.error('Loaded env variables:', e);
     // dotenvExpand.expand(e);
   } else {
     console.error(
-      '[Note]: No .env file found, Using default environment variables...'
+      '[Note]: No env file found, Using default environment variables...'
     );
   }
 }
-
 // Apply command line arguments to override environment variables
-if (args.values.port) {
-  process.env.PORT = args.values.port;
-  console.error(`[Note] PORT set from command line: ${args.values.port}`);
-}
 
-if (args.values.mcptype) {
-  process.env.MCPTYPE = args.values.mcptype;
-  console.error(`[Note] MCPTYPE set from command line: ${args.values.mcptype}`);
-}
+process.env.PORT = process.env.PORT || '8080';
+process.env.HTTPS = (args.values.https) ? 'TRUE' : 'FALSE';
+process.env.MCPTYPE = args.values.mcptype || process.env.MCPTYPE || 'http';
+process.env.MCPHOST = args.values.mcphost || process.env.MCPHOST || 'http://localhost:8080';
+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 || null;
+process.env.CLIENTID = args.values.clientid || process.env.CLIENTID || 'vscodemcp';
+process.env.CLIENTSECRET = args.values.clientsecret || 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 || process.env.HOME; // default to user home directory
+process.env.CASSERVER = args.values.casserver || process.env.CASSERVER || 'cas-shared-default';
+process.env.COMPUTECONTEXT = args.values.computecontext || process.env.COMPUTECONTEXT || 'SAS Job Execution compute context';
+process.env.APPHOST = 'localhost';
+process.env.CLIENT = args.values.client || process.env.CLIENT || 'github';
 
-if (args.values.viya) {
-  process.env.VIYA_SERVER = args.values.viya;
-  console.error(`[Note] VIYA_SERVER set from command line: ${args.values.viya}`);
-}
 
-if (args.values.authflow) {
-  process.env.AUTHFLOW = args.values.authflow;
-  console.error(`[Note] AUTHFLOW set from command line: ${args.values.authflow}`);
-}
 
-if (args.values.profile) {
-  process.env.SAS_CLI_PROFILE = args.values.profile;
-  console.error(`[Note] SAS_CLI_PROFILE set from command line: ${args.values.profile}`);
+process.env.SAMESITE = 'Lax,secure';
+process.env.APPHOST = '0.0.0.0';
+process.env.APPNAME = 'sas-score-mcp-serverjs';
+
+// Handle version flag
+if (args.values.version) {
+  let pkgJson = JSON.parse(pkg);
+  console.error(pkgJson.version);
+  process.exit(0);
 }
 
-if (args.values.config) {
-  process.env.SAS_CLI_CONFIG = args.values.config;
-  console.error(`[Note] SAS_CLI_CONFIG set from command line: ${args.values.config}`);
+// copy the skills to  directory based on the client name, so that different MCP clients can have different sets of skills if needed
+// the -client indicates the current mcp client 
+console.error(`[Note] MCP client set to: ${process.env.CLIENT}`);
+
+let client = process.env.CLIENT;
+if (client != null) {
+  let destdir = '.' + client;
+  let skillsDest = join(os.homedir(), destdir,'skills');
+  const skillsSrc = join(__dirname, 'skills');
+  if (!fs.existsSync(skillsSrc)) {
+    console.error('No skills directory found in this package.');
+    process.exit(1);
+  }
+  fs.mkdirSync(skillsDest, { recursive: true });
+
+  const skills = fs.readdirSync(skillsSrc, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+
+  if (skills.length === 0) {
+    console.error('[Note]No skills found to install.');
+  } else {
+    console.error(`Installing ${skills.length} skill(s) to ${skillsDest}...`);
+    for (const skill of skills) {
+      const src = join(skillsSrc, skill);
+      const dest = join(skillsDest, skill);
+      fs.cpSync(src, dest, { recursive: true });
+      console.error(`  installed: ${skill}`);
+    }
+    console.error(`\n installed in cli. ${client}`);
+    console.error(`\n${skills.length} skill(s) installed to ${skillsDest}`);
+    console.error('[Note] Skills are ready for use.');
+
+  }
 }
 
-if (process.env.APPHOST == null) {
-  process.env.APPHOST = 'localhost';
-} 
+
+
+
 /********************************* */
 const BRAND = 'sas-score'
 /********************************* */
@@ -175,16 +256,16 @@ let version = pkgJson.version;
 let mcpType = process.env.MCPTYPE || 'http';
 console.error(
   `\nStarting MCP ServerJS - Version: ${pkgJson.version} - ${new Date().toISOString()}\n
-     brand: ${process.env.BRAND || BRAND}\n
-     mcpType: ${mcpType}\n
-     viyaServer: ${process.env.VIYA_SERVER}\n`
+     brand: ${process.env.BRAND || BRAND}
+     mcpType: ${mcpType}
+     viyaServer: ${process.env.VIYA_SERVER}`
 );
 // session sessionCache
 // For more robust caching consider products like Redis
 // and storage provided by cloud providers
-console.error(process.env.COMPUTECONTEXT);
+
 debugger;
-let sessionCache = new NodeCache({ stdTTL: 24 *60*60, checkperiod: 2 * 60, useClones: false });
+let sessionCache = new NodeCache({ stdTTL: 24 * 60 * 60, checkperiod: 2 * 60, useClones: false });
 
 //
 // Load environment variables from .env file if present
@@ -192,35 +273,25 @@ let sessionCache = new NodeCache({ stdTTL: 24 *60*60, checkperiod: 2 * 60, useCl
 // stdio: set the env in the mcp config
 // http: use dotenv-cli to load env before starting the mcp server
 
-
-// need to tell core what transport to use(http or stdio)
-
-//  subclasses for sasQuery tool (special use case)
-// to be replaced by the planned adding external tool definition capability
-
-let subclassJson = [];
-if (process.env.SUBCLASS != null) {
-  console.error(`Using subclass: ${process.env.SUBCLASS}`);
-  let subclass = process.env.SUBCLASS;
-  if (fs.existsSync(subclass)) {
-    console.error(`Loading subclass information from ${subclass}...`);
-    let s = fs.readFileSync(subclass, 'utf8');
-    subclassJson = JSON.parse(s);
-    console.error(`Loaded subclass: ${JSON.stringify(subclassJson, null, 2)}`);
-  }
-}
 // setup base appEnv 
 // for stdio this is the _appContext
 // for http each session a copy of this as appEnvTemplate is created in corehttp
 
-// backward compability variables
-let clientID = process.env.CLIENTID || process.env.CLIENTIDPW || null;
-let clientSecret = process.env.CLIENTSECRET || process.env.CLIENTSECRETPW || null;
 let https = process.env.HTTPS != null ? process.env.HTTPS.toUpperCase() : "FALSE";
+let authExternal = false;
+let authFlow = process.env.AUTHFLOW;
+let mcpHost = process.env.MCPHOST;
+
+if (authFlow === 'oauth' || authFlow === 'oauthclient') {
+  authFlow = 'bearer';
+  authExternal = (authFlow === 'oauthclient') ? true : false;
+}
 let autoLogon = process.env.AUTOLOGON != null ? process.env.AUTOLOGON.toUpperCase() : "FALSE";
 const appEnvBase = {
   version: version,
-  mcpType: mcpType, 
+  mcpType: mcpType,
+  mcpClient: process.env.MCPCLIENT || 'github',
+  mcpHost: (process.env.MCPHOST == null) ? 'http://localhost:8080' : process.env.MCPHOST,
   brand: (process.env.BRAND == null) ? BRAND : process.env.BRAND,
   HTTPS: https,
   SAS_CLI_PROFILE: process.env.SAS_CLI_PROFILE || 'Default',
@@ -228,27 +299,25 @@ const appEnvBase = {
   SSLCERT: process.env.SSLCERT || null,
   VIYACERT: process.env.VIYACERT || null,
 
-  AUTHFLOW: process.env.AUTHFLOW || 'sascli',
+  AUTHFLOW: authFlow,
+  AUTHEXTERNAL: authExternal,
+  BEARERTOKEN: null,
   AUTOLOGON: autoLogon,
   VIYA_SERVER: process.env.VIYA_SERVER,
   PORT: process.env.PORT || 8080,
   USERNAME: process.env.USERNAME || null,
   PASSWORD: process.env.PASSWORD || null,
-  CLIENTID: clientID,
-  CLIENTSECRET: clientSecret,
+  CLIENTID: process.env.CLIENTID || null,
+  CLIENTSECRET: process.env.CLIENTSECRET || null,
   PKCE: process.env.PKCE || null,
 
   TOKEN: process.env.TOKEN || null,
   REFRESH_TOKEN: process.env.REFRESH_TOKEN || null,
   TOKENFILE: process.env.TOKENFILE || null,
   TLS_CREATE: process.env.TLS_CREATE || null,
-  SUBCLASS: process.env.SUBCLASS || null,
-  subclassJson: subclassJson,
-  // future use for controlling tool list using env variable
-  toolsets:
-    process.env.TOOLSETS != null
-      ? process.env.TOOLSETS.split(',')
-      : ['default'],
+  CASSERVER: process.env.CASSERVER,
+  COMPUTECONTEXT: process.env.COMPUTECONTEXT,
+
   // command line arguments
   cliArgs: args.values,
   // user defined tools
@@ -268,7 +337,8 @@ const appEnvBase = {
   tlsOpts: null,
   oauthInfo: null,
   contexts: {
-    AUTHFLOW: process.env.AUTHFLOW || 'sascli',
+    AUTHFLOW: authFlow,
+    AUTHEXTERNAL: authExternal,
     host: process.env.VIYA_SERVER,
     APPHOST: process.env.APPHOST || 'localhost',
     APPNAME: process.env.APPNAME || 'sas-score-mcp-serverjs',
@@ -277,8 +347,8 @@ const appEnvBase = {
     store: null, /* for restaf users */
     storeConfig: {},
     oauthInfo: null,
-    CLIENTID: clientID,
-    CLIENTSECRET: clientSecret,
+    CLIENTID: process.env.CLIENTID || null,
+    CLIENTSECRET: process.env.CLIENTSECRET || null,
     pkce: process.env.PKCE || null,
     casSession: null, /* restaf cas session object */
     computeSession: null, /* restaf compute session object */
@@ -293,15 +363,14 @@ const appEnvBase = {
   }
 };
 
-process.env.APPPORT=appEnvBase.PORT;
+process.env.APPPORT = appEnvBase.PORT;
+let useHapi = process.env.USEHAPI === 'TRUE' ? true : false;
+appEnvBase.useHapi = useHapi;
 
 // setup TLS options for viya calls
-console.error('[Note]Viya SSL dir set to: ' + appEnvBase.VIYACERT);
 appEnvBase.contexts.viyaCert = readCerts(appEnvBase.VIYACERT); /* appEnvBase.contexts.viyaCert is set here */
 
 // setup TLS options for app server (expressMcpServer or hapiMcpServer)
-
-console.error('[Note]App SSL dir set to: ' + appEnvBase.SSLCERT);
 appEnvBase.tlsOpts = readCerts(appEnvBase.SSLCERT);
 appEnvBase.contexts.appCert = appEnvBase.tlsOpts; /* just for completeness */
 
@@ -315,7 +384,7 @@ if (appEnvBase.TOKENFILE != null) {
     console.error(`[Note]Loading token from file: ${appEnvBase.TOKENFILE}...`);
     appEnvBase.TOKEN = fs.readFileSync(appEnvBase.TOKENFILE, { encoding: 'utf8' });
     appEnvBase.AUTHFLOW = 'token';
-    appEnvBase.appContexts.logonPayload = {
+    appEnvBase.contexts.logonPayload = {
       host: appEnvBase.VIYA_SERVER,
       authType: 'server',
       token: appEnvBase.TOKEN,
@@ -328,10 +397,6 @@ if (appEnvBase.TOKENFILE != null) {
 }
 
 
-
-// if authflow is cli or code, postpone getting logonPayload until needed
-
-
 // setup mcpServer (both http and stdio use this)
 // this is singleton - best practices recommend this
 
@@ -342,18 +407,55 @@ let appEnvTemplate = Object.assign({}, appEnvBase);
 
 sessionCache.set('appEnvTemplate', appEnvTemplate);
 
+// prime transport cache
 let transports = {
   "dummy": null
 };
 sessionCache.set('transports', transports);
+let tokenlist = {
+  dummy: null
+}
+sessionCache.set('tokenlist', tokenlist);
 
 // set this for stdio transport use
 // dummy sessionId for use in the tools  
-let useHapi = process.env.AUTHFLOW === 'code' ? true : false;
-console.error('[Note] appEnvBase is', JSON.stringify(appEnvBase, null,2));
+
 // creat a dummy sessionId for stdio since there is only one session and transport in that case, and tools need a sessionId to access the appEnvBase and contexts
 let sessionId = randomUUID();
 sessionCache.set(sessionId, appEnvBase);
+sessionCache.set('currentId', sessionId);
+
+console.error('===================================================================');
+console.error(`MCP ServerJS - Version: ${pkgJson.version} - ${new Date().toISOString()}`);
+console.error(`
+Usage: sas-score-mcp-serverjs [options]
+
+Options:
+  Minimal options:
+    VIYA_SERVER                   ${appEnvBase.VIYA_SERVER}
+    CLIENTID                      ${appEnvBase.CLIENTID}
+
+  MCP server options:
+    MCPTYPE                       ${appEnvBase.mcpType}
+    MCPHOST                       ${appEnvBase.mcpHost}
+    PORT                          ${appEnvBase.PORT}
+    HTTPS                         ${appEnvBase.contexts.HTTPS}
+    CLIENT                        ${appEnvBase.mcpClient}
+
+  Authentication options:
+    AUTHFLOW                      ${process.env.AUTHFLOW}  
+    CLIENTSECRET                  ${appEnvBase.CLIENTSECRET}
+    PROFILE                       ${appEnvBase.SAS_CLI_PROFILE} 
+    CONFIG                        ${appEnvBase.SAS_CLI_CONFIG} 
+
+  Other options:
+    CASSERVER                     ${appEnvBase.CASSERVER} 
+    COMPUTECONTEXT                ${appEnvBase.COMPUTECONTEXT}
+    }
+
+`);
+console
+debugger;
 if (mcpType === 'stdio') {
   console.error('[Note] Setting up stdio transport with sessionId:', sessionId);
   console.error('[Note] Used in setting up tools and some persistence(not all).');
@@ -390,7 +492,7 @@ function iconfig(envFile) {
     });
     return envData;
   } catch (err) {
-    console.log(err);
+    console.error(err);
     process.exit(0);
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sassoftware/sas-score-mcp-serverjs",
-  "version": "0.4.1-1",
+  "version": "0.4.1-17",
   "description": "A mcp server for SAS Viya",
   "author": "Deva Kumar <deva.kumar@sas.com>",
   "license": "Apache-2.0",
@@ -18,7 +18,9 @@
     "deploy": "bash ./deploy.sh",
     "push2acr": "cd docker && bash ./push2acr.sh",
     "bump": "npm version prerelease",
-    "pub": "npm publish --tag dev --access public"
+    "pub": "npm publish --tag dev --access public",
+    "postinstall": "node scripts/setup-skills.js",
+    "setup-skills": "node scripts/setup-skills.js"
   },
   "repository": "https://github.com/sassoftware/sas-score-mcp-serverjs",
   "keywords": [
@@ -40,7 +42,8 @@
     "cli.js",
     "openApi.json",
     "openApi.yaml",
-    "skills"
+    "skills",
+    "scripts"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
@@ -71,7 +74,6 @@
     "@babel/preset-env": "^7.28.5",
     "@types/debug": "^4.1.12",
     "@types/node": "^25.0.3",
-    "npm-check-updates": "^19.2.0",
     "rimraf": "^6.1.2",
     "typescript": "^5.9.3"
   }

package/scripts/docs/SCORE_SKILL_REFERENCE.md

@@ -0,0 +1,142 @@
+# Score Skill Documentation
+
+## Overview
+The `score` skill is a generic scoring interface that automatically routes scoring requests to the appropriate tool based on the model type specified in the request.
+
+## Syntax
+```
+score with model <name>.<type> [scenario =<key=value pairs>]
+score <name>.<type> [scenario =<key=value pairs>]
+```
+
+## Supported Types
+- **job** — Route to `run-job` for job-based scoring
+- **jobdef** — Route to `run-jobdef` for job definition-based scoring
+- **mas** — Route to `model-score` (Model Aggregation Service)
+- **scr** — Route to `scr-score` (Score Code Runtime container)
+- **sas** — Route to `run-sas-program` (arbitrary SAS/SQL scoring)
+
+## Usage Examples
+
+### MAS Model Scoring
+```
+score with model churn.mas where scenario =age=45,income=60000
+score mymodel.mas using age=45, income=60000
+```
+Routes to: `model-score` with model name and scenario parameters
+
+### Job-Based Scoring
+```
+score with model monthly_scorer.job scenario =month=10,year=2025
+score mymodel.job with month=10, year=2025
+```
+Routes to: `run-job` with job name and parameters
+
+### Job Definition Scoring
+```
+score fraud_detector.jobdef using amount=500,merchant=online
+score predictions.jobdef where scenario =x=1,y=2
+```
+Routes to: `run-jobdef` with jobdef name and parameters
+
+### SCR (Score Code Runtime) Scoring
+```
+score https://scr-host/models/loan.scr using age=45,credit_score=700
+score mymodel.scr where scenario =age=45,income=60000
+```
+Routes to: `scr-score` with SCR URL and scenario
+
+### SAS Program Scoring
+```
+score predictions.sas where scenario =x=1,y=2
+score my_scoring_code.sas using month=10,year=2025
+```
+Routes to: `run-sas-program` with scenario parameters
+
+## Parameter Details
+
+| Parameter | Required | Type | Description |
+|-----------|----------|------|-------------|
+| `model` | Yes | string | Model name with type suffix (e.g., `mymodel.mas`) |
+| `scenario` | No | string\|object\|array | Input data as comma-separated key=value pairs |
+| `type` | No | string | Type override (inferred from model name if not specified) |
+| `prompt` | No | string | Full prompt for context |
+| `context_data` | No | object | Contextual variables for fallback |
+
+## Scenario Format
+The scenario parameter accepts multiple formats:
+
+**String format** (comma-separated):
+```
+age=45,income=60000,credit=700
+```
+
+**Object format**:
+```javascript
+{age: 45, income: 60000, credit: 700}
+```
+
+**Array format** (batch scoring):
+```javascript
+[
+  {age: 45, income: 60000},
+  {age: 50, income: 75000},
+  {age: 35, income: 55000}
+]
+```
+
+## Type Inference
+The skill automatically infers the type from the model name:
+
+```
+mymodel.mas    → type = "mas"
+scorer.job     → type = "job"
+detector.jobdef → type = "jobdef"
+risk.scr       → type = "scr"
+predict.sas    → type = "sas"
+```
+
+If the type is not specified in the model name or as a parameter, the skill will ask for clarification:
+```
+"Is this a mas, scr, job, jobdef, or sas model?"
+```
+
+## Context-Based Scoring
+If no scenario is provided, the skill can extract relevant variables from the conversation context:
+
+1. Extracts available variables from context
+2. Asks user for confirmation: *"I found these variables: [list]. Should I use them for scoring?"*
+3. Proceeds with confirmed variables
+
+## Return Values
+The scoring response varies by type:
+
+| Type | Returns |
+|------|---------|
+| **job** | Log output, tables created by job |
+| **jobdef** | Log output, tables created by jobdef |
+| **mas** | Predictions, probabilities, scores |
+| **scr** | Predictions and metadata from SCR endpoint |
+| **sas** | SAS execution output with results |
+
+All responses include metadata indicating which tool was invoked.
+
+## Error Handling
+
+| Error | Message |
+|-------|---------|
+| Invalid type | "Unknown model type. Use: job, jobdef, mas, scr, or sas" |
+| Missing model | "Please provide model name (e.g., score with model mymodel.mas)" |
+| Invalid scenario | "Scenario must be key=value pairs separated by commas" |
+| Routing failure | Backend error from invoked tool |
+
+## Implementation Details
+
+The skill is defined in `src/toolSet/scoreSkill.js` and:
+- Parses model name to extract type
+- Normalizes type names (e.g., `jobs` → `job`)
+- Routes to appropriate tool handler
+- Attaches scoring metadata to response
+- Handles errors from backend tools
+
+The skill is automatically registered in `makeTools.js` and available alongside other MCP tools.