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

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));
@@ -39,6 +41,10 @@ const args = parseArgs({
       short: 'p',
       description: 'Port to run the server on'
     },
+    https: {
+      type: 'string',
+      description: 'Use HTTPS for the server (default: false)'
+    },
     mcptype: {
       type: 'string',
       short: 'm',
@@ -52,7 +58,7 @@ const args = parseArgs({
     authflow: {
       type: 'string',
       short: 'a',
-      description: 'Authentication flow (sascli, code, token)'
+      description: 'Authentication flow (sascli, code, token, bearer,auth)'
     },
     profile: {
       type: 'string',
@@ -76,6 +82,11 @@ const args = parseArgs({
       type: 'boolean',
       short: 'v',
       description: 'Show version'
+    },
+    'install-skills': {
+      type: 'string',
+      short: 's',
+      description: 'Install bundled skills/'
     }
   },
   strict: false,
@@ -84,19 +95,22 @@ 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
+  -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
+  -c, --mcpclient <name>         Name of the MCP client (for token management)
+  -a, --authflow <flow>          Authentication flow: sascli, code, or token
+  --provider <name>              Authentication by external provider, e.g. AZURE. 
+  --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
+  -s, --install-skills <client>Install bundled skills to ~/.claude/skills/
 
 Environment Variables:
   Use .env file or set environment variables for configuration.
@@ -108,10 +122,44 @@ Environment Variables:
 // Handle version flag
 if (args.values.version) {
   let pkgJson = JSON.parse(pkg);
-  console.log(pkgJson.version);
+  console.error(pkgJson.version);
   process.exit(0);
 }
 
+// Handle install-skills flag
+if (args.values['install-skills']) {
+  let destdir = '.' + args.values['install-skills'];
+  const skillsSrc = join(__dirname, 'skills');
+  const skillsDest = join(os.homedir(), destdir, '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('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${skills.length} skill(s) installed to ${skillsDest}`);
+    console.error('Restart Client to activate the new skills.');
+    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...');
@@ -119,10 +167,10 @@ if (process.env.ENVFILE === 'FALSE') {
   console.error('Working Directory', process.cwd());
   let envf = process.env.ENVFILE || (process.cwd() + '\\.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);
@@ -143,12 +191,20 @@ if (args.values.mcptype) {
   process.env.MCPTYPE = args.values.mcptype;
   console.error(`[Note] MCPTYPE set from command line: ${args.values.mcptype}`);
 }
-
+if (args.values.mcpclient) {
+  process.env.MCPCLIENT = args.values.mcpclient;
+  console.error(`[Note] MCPCLIENT set from command line: ${args.values.mcpclient}`);
+}
 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.mcpserver) {
+  process.env.MCPSHOST = args.values.mcphost;
+  console.error(`[Note] MCPHOST set from command line: ${args.values.mcpserver}`);
+}
+
 if (args.values.authflow) {
   process.env.AUTHFLOW = args.values.authflow;
   console.error(`[Note] AUTHFLOW set from command line: ${args.values.authflow}`);
@@ -166,7 +222,7 @@ if (args.values.config) {
 
 if (process.env.APPHOST == null) {
   process.env.APPHOST = 'localhost';
-} 
+}
 /********************************* */
 const BRAND = 'sas-score'
 /********************************* */
@@ -182,9 +238,9 @@ console.error(
 // 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
@@ -217,10 +273,26 @@ if (process.env.SUBCLASS != null) {
 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 = 'bearer';
+  authExternal = true;
+}
+if (authFlow === 'oauthproxy') {
+  authFlow = 'bearer';
+  authExternal = false;
+} 
+
+console.error(`[Note] Authentication flow: ${authFlow}, External provider: ${authExternal}`);
 let autoLogon = process.env.AUTOLOGON != null ? process.env.AUTOLOGON.toUpperCase() : "FALSE";
 const appEnvBase = {
   version: version,
-  mcpType: mcpType, 
+  mcpType: mcpType,
+  mcpClient: process.env.MCPCLIENT || 'vscode',
+  mcpHost: mcpHost,
   brand: (process.env.BRAND == null) ? BRAND : process.env.BRAND,
   HTTPS: https,
   SAS_CLI_PROFILE: process.env.SAS_CLI_PROFILE || 'Default',
@@ -228,7 +300,9 @@ 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,
@@ -268,7 +342,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',
@@ -293,7 +368,9 @@ 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);
@@ -315,7 +392,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 +405,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 +415,25 @@ 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);
+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 +470,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-15",
   "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": [

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

@@ -0,0 +1,123 @@
+---
+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.
+
+**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 `list-libraries`)
+
+---
+
+## Using 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:**
+```
+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 list-tables(lib, server="cas")
+    IF tables found
+      → success, return tables
+    ELSE
+      → uppercase lib
+      → TRY 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: `list-tables({ lib: "Public", server: "cas" })`
+2. If empty, try SAS with uppercase: `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: `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: `list-tables({ lib: "Public", server: "cas" })`
+
+**Pattern 4 — Pagination**
+> "Show me 25 tables in Samples, then the next batch"
+
+1. First call: `list-tables({ lib: "Samples", limit: 25, start: 1 })`
+2. Next call: `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?"* |
+

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

@@ -1,13 +1,13 @@
 ---
 name: sas-read-and-score
 description: >
-  Guide the full read → score workflow in SAS Viya: reading records from a table (using read-table
-  or sas-query) and then scoring them with a MAS model (using 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 table data with model prediction.
+  Guide the full read → score workflow in SAS Viya: reading records from a table and then scoring
+  them with a MAS model (using 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
@@ -15,68 +15,68 @@ description: >
 Orchestrates the full two-step pattern of reading records from a SAS/CAS table and scoring them
 with a deployed MAS model.
 
-This skill chains two sub-skills:
-1. **sas-read-strategy** — Choose between `read-table` and `sas-query`
-2. **sas-score-workflow** — Validate model, invoke scoring, present results
-
 ---
 
-## Quick reference
+## Workflow overview
 
-1. **Does the user already have data in hand?**
-   - Yes → skip to Step 2 (scoring)
-   - No → use `sas-read-strategy` to fetch data
+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
 
-2. **Is the model name familiar?**
-   - Yes → proceed to score
-   - No → pause and use `find-model` / `model-info`
+---
 
-3. **Invoke model-score** with the fetched data
+## Scenario: User already has data
 
-4. **Merge results** and present as a table
+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
 
 ---
 
-## Common flows
+## Scenario: User wants to score table rows
 
-**Flow A — Score rows from a table directly**
-> "Score the first 10 customers in Public.customers with the churn model"
+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
 
-1. Apply `sas-read-strategy` → use `read-table` to fetch 10 rows
-2. Apply `sas-score-workflow` → invoke `model-score` and present results
-
-**Flow B — Score results of an analytical query**
-> "Score high-value customers (spend > 5000) in mylib.sales with the fraud model"
+---
 
-1. Apply `sas-read-strategy` → use `sas-query` for aggregation
-2. Apply `sas-score-workflow` → invoke `model-score` and present results
+## Scenario: User wants to score query results
 
-**Flow C — User supplies scenario data directly**
-> "Score age=45, income=60000, region=South with the churn model"
+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
 
-1. Skip read strategy
-2. Apply `sas-score-workflow` → invoke `model-score` and present result
+---
 
-**Flow D — Model unfamiliar**
-> "Score Public.applicants with the creditRisk2 model"
+## Scenario: User unfamiliar with model
 
-1. Model unfamiliar → use `find-model` to verify existence
-2. Apply `sas-read-strategy` to fetch data
-3. Apply `sas-score-workflow` to score
+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
 
 ---
 
-## For detailed guidance
-
-- **Read strategy decisions?** See `sas-read-strategy` skill
-- **Scoring validation and presentation?** See `sas-score-workflow` skill
-
-**Flow D — Model unfamiliar**
-> "Score Public.applicants with the creditRisk2 model"
+## Rules
 
-1. Pause — "creditRisk2" is new
-2. Suggest: `find-model` to confirm it exists, `model-info` to get input variables
-3. Once confirmed → `read-table` + `model-score`
+- Always validate table/library existence before attempting to read
+- Always check model exists before invoking `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
 
 ---
 
@@ -85,7 +85,8 @@ This skill chains two sub-skills:
 | Problem | Action |
 |---|---|
 | Table not found | Ask for correct lib.tablename |
-| Model not found | Suggest find-model |
-| Field name mismatch | Show mismatch, ask user to confirm mapping |
-| Scoring error | Return structured error, suggest model-info |
-| Empty read result | Tell user, ask if they want to adjust the query/filter |
+| 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 |

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

@@ -11,9 +11,7 @@ description: >
 # SAS Read Strategy
 
 Guides the decision between `read-table` and `sas-query` based on the user's intent and the nature
-of the data operation.
-
----
+of the data operation. Determines which server contains the data and which retrieval tool is most appropriate.
 
 ## Determine the server location
 
@@ -125,10 +123,11 @@ sas-query({
 
 | Problem | Action |
 |---|---|
-| Table not found in either server | Ask: *"Which library contains the table? (e.g., Public, Samples, mylib)"* |
+| Table not found in either server | Inform user and ask: *"Which library contains this table? (e.g., Public, Samples, mylib)"* |
 | 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 |
-| Library not found | Ask: *"Which library contains the table? (e.g., Public, Samples, mylib)"* |
+| Library not found | Inform user and ask to verify the library name |
+| 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 |
 
@@ -136,8 +135,9 @@ sas-query({
 
 ## Next steps
 
-Once data is retrieved, decide the next action based on context:
-- If user wants to **score** the data → move to `sas-score-workflow`
-- If user wants to **visualize** → present as table or chart
-- If user wants to **export** → format and offer download
-- If user wants to **analyze further** → ask clarifying questions
+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/sas-score-workflow/SKILL.md

@@ -33,12 +33,27 @@ score <name>.<type> [scenario =<key=value pairs>]
 
 If no type is specified (bare model name), assume `.mas` (MAS model).
 
-
 ---
 
 ## Type-Based Routing
 
-Parse the model name to extract the type suffix and route accordingly:
+### 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 `run-job`
+   - `churn.mas` → pass `churn` to `model-score`
+   - `fraud_detector.jobdef` → pass `fraud_detector` to `run-jobdef`
 
 ### Type: `.mas` (Model Aggregation Service)
 - **Tool**: `model-score`
@@ -70,6 +85,8 @@ Parse the model name to extract the type suffix and route accordingly:
 - **Example**: `score my_scoring_code.sas using x=1,y=2`
 - **Invocation**: `run-sas-program({ folder: "my_scoring_code", scenario: {...} })`
 
+
+
 ---
 
 ## Scenario Parsing