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

package/src/toolSet/{runMacro.js → macroScore.js}

@@ -1,82 +1,86 @@
-/*
- * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { z } from 'zod';
-import _submitCode from '../toolHelpers/_submitCode.js';
-
-
-function runMacro(_appContext) {
-  let description = `
-run-macro — submit and execute a SAS macro on SAS Viya server.
-
-USE when: run macro, execute macro with parameters
-DO NOT USE for: arbitrary SAS code (use run-sas-program), jobs, jobdefs
-
-PARAMETERS
-- macro: string — macro name without "%" (required)
-- scenario: string — parameters or setup code (optional). Accepts: "x=1, y=abc" or "%let x=1; %let y=abc;"
-
-ROUTING RULES
-- "run macro abc" → { macro: "abc", scenario: "" }
-- "run macro abc with x=1, y=2" → { macro: "abc", scenario: "x=1, y=2" }
-- "run macro xyz with %let a=1; %let b=2;" → { macro: "xyz", scenario: "%let a=1; %let b=2;" }
-
-EXAMPLES
-- "run macro abc" → { macro: "abc", scenario: "" }
-- "run macro summarize with x=1, y=2" → { macro: "summarize", scenario: "x=1, y=2" }
-
-NEGATIVE EXAMPLES (do not route here)
-- "run SAS code" (use run-sas-program)
-- "run job X" (use run-job)
-- "run jobdef X" (use run-jobdef)
-
-ERRORS
-Returns log, ods, tables created by macro. Auto-converts "x=1, y=2" to "%let x=1; %let y=2;" format.
-  `;
-
-  let spec = {
-    name: 'run-macro',
-    description: description,
-    
-    inputSchema: z.object({
-      macro: z.string(),
-      scenario: z.string().optional()
-    }),
-     
-    handler: async (params) => {
-      const scenarioRaw = (params.scenario || '').trim();
-      let setup = '';
-      if (scenarioRaw) {
-        // If the scenario already contains macro syntax, send it through unchanged
-        const hasMacroSyntax = /%let\b|%[a-zA-Z_]\w*\s*\(|%[a-zA-Z_]\w*\s*;/.test(scenarioRaw) || scenarioRaw.includes('%');
-        if (hasMacroSyntax) {
-          setup = scenarioRaw;
-        } else {
-          // Convert "x=1,y=abc" -> "%let x=1; %let y=abc;"
-          setup = scenarioRaw.split(',')
-            .map(p => p.trim())
-            .filter(Boolean)
-            .map(p => {
-              const [k, ...rest] = p.split('=');
-              if (!k) return '';
-              const key = k.trim();
-              const val = rest.join('=').trim();
-              return `%let ${key}=${val};`;
-            })
-            .filter(Boolean)
-            .join(' ');
-        }
-      }
-      const src = `${setup} %${params.macro};`;
-      params.src = src;
-      let r = await _submitCode(params);
-      return r;
-    }
-  }
-  return spec;
-}
-
-export default runMacro;
-
+/*
+ * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { z } from 'zod';
+import _submitCode from '../toolHelpers/_submitCode.js';
+
+
+function macroScore(_appContext) {
+  const isAgent = _appContext && _appContext.agent;
+  let description = isAgent ? `
+macro-score — execute a SAS macro model.
+PARAMS: macro (string, required — name without %), scenario (string, optional — "x=1,y=2" or %let syntax)
+RETURNS: log, ODS output, and tables created by macro
+` : `
+macro-score — submit and execute a SAS macro model on SAS Viya server.
+
+USE when: score macro, execute macro with parameters
+DO NOT USE for: arbitrary SAS code (use program-score), jobs (use job-score), jobdefs (use jobdef-score)
+
+PARAMETERS
+- macro: string — macro name without "%" (required)
+- scenario: string — parameters or setup code (optional). Accepts: "x=1, y=abc" or "%let x=1; %let y=abc;"
+
+ROUTING RULES
+- "score macro abc" → { macro: "abc", scenario: "" }
+- "score macro abc with x=1, y=2" → { macro: "abc", scenario: "x=1, y=2" }
+- "score macro xyz with %let a=1; %let b=2;" → { macro: "xyz", scenario: "%let a=1; %let b=2;" }
+
+EXAMPLES
+- "score macro abc" → { macro: "abc", scenario: "" }
+- "score macro summarize with x=1, y=2" → { macro: "summarize", scenario: "x=1, y=2" }
+
+NEGATIVE EXAMPLES (do not route here)
+- "score SAS code" (use program-score)
+- "score job X" (use job-score)
+- "score jobdef X" (use jobdef-score)
+
+ERRORS
+Returns log, ods, tables created by macro. Auto-converts "x=1, y=2" to "%let x=1; %let y=2;" format.
+  `;
+
+  let spec = {
+    name: 'macro-score',
+    description: description,
+
+    inputSchema: z.object({
+      macro: z.string(),
+      scenario: z.string().optional()
+    }),
+
+    handler: async (params) => {
+      const scenarioRaw = (params.scenario || '').trim();
+      let setup = '';
+      if (scenarioRaw) {
+        // If the scenario already contains macro syntax, send it through unchanged
+        const hasMacroSyntax = /%let\b|%[a-zA-Z_]\w*\s*\(|%[a-zA-Z_]\w*\s*;/.test(scenarioRaw) || scenarioRaw.includes('%');
+        if (hasMacroSyntax) {
+          setup = scenarioRaw;
+        } else {
+          // Convert "x=1,y=abc" -> "%let x=1; %let y=abc;"
+          setup = scenarioRaw.split(',')
+            .map(p => p.trim())
+            .filter(Boolean)
+            .map(p => {
+              const [k, ...rest] = p.split('=');
+              if (!k) return '';
+              const key = k.trim();
+              const val = rest.join('=').trim();
+              return `%let ${key}=${val};`;
+            })
+            .filter(Boolean)
+            .join(' ');
+        }
+      }
+      const src = `${setup} %${params.macro};`;
+      params.src = src;
+      let r = await _submitCode(params);
+      return r;
+    }
+  }
+  return spec;
+}
+
+export default macroScore;

package/src/toolSet/makeTools.js

@@ -3,67 +3,81 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import listModels from './listModels.js';
-import listTables from './listTables.js';
-import modelScore from './modelScore.js';
-import modelInfo from './modelInfo.js';
+import listMas from './listMas.js';
+
+
+import masScore from './masScore.js';
+import masDescribe from './masDescribe.js';
+import findMas from './findMas.js';
+
 import findLibrary from './findLibrary.js';
-import readTable from './readTable.js';
-import tableInfo from './tableInfo.js';
 import listLibraries from './listLibraries.js';
 
-import scrInfo from './scrInfo.js';
+import listTables from './listTables.js';
+import findTable from './findTable.js';
+import tableDescribe from './tableDescribe.js';
+import readTable from './readTable.js';
+
+import findScr from './findScr.js';
+import listScr from './listScr.js';
+import scrDescribe from './scrDescribe.js';
 import scrScore from './scrScore.js';
 
 import devaScore from './devaScore.js';
 
-import findTable from './findTable.js';
-import findModel from './findModel.js';
-import runProgram from './runProgram.js';
-import runMacro from './runMacro.js';
-import runJob from './runJob.js';
+import programScore from './programScore.js';
+import casProgramScore from './casProgramScore.js';
+import casModelScore from './casModelScore.js';
+import macroScore from './macroScore.js';
+import jobScore from './jobScore.js';
 import listJobs from './listJobs.js';
-import runJobdef from './runJobdef.js';
+import jobdefScore from './jobdefScore.js';
 import findJob from './findJob.js';
 import listJobdefs from './listJobdefs.js';
 import findJobdef from './findJobdef.js';
+import jobDescribe from './jobDescribe.js';
+import jobdefDescribe from './jobdefDescribe.js';
 
 import sasQuery from './sasQuery.js';
 import setContext from './setContext.js';
 
-
 function makeTools(_appContext) {
   // wrap all tools with 
   let customTools = [];
 
   // get the tool definitions and handler 
   let list = [
-    listModels(_appContext),
-    
-    findModel(_appContext),
-    modelInfo(_appContext),
-    modelScore(_appContext),
+    listMas(_appContext),
+    listScr(_appContext),
+    findMas(_appContext),
+    masDescribe(_appContext),
+    masScore(_appContext),
 
-    scrInfo(_appContext),
+    scrDescribe(_appContext),
     scrScore(_appContext),
+    findScr(_appContext),
 
     findLibrary(_appContext),
     listLibraries(_appContext),
     findTable(_appContext),
-    tableInfo(_appContext),
+    tableDescribe(_appContext),
     listTables(_appContext),
     readTable(_appContext),
     sasQuery(_appContext),
 
-    runProgram(_appContext),
-    runMacro(_appContext),
+    programScore(_appContext),
+    casProgramScore(_appContext),
+    casModelScore(_appContext),
+    macroScore(_appContext),
 
     findJob(_appContext),
     listJobs(_appContext),
-    runJob(_appContext),
+    jobScore(_appContext),
     listJobdefs(_appContext),
     findJobdef(_appContext),
-    runJobdef(_appContext),
+    jobDescribe(_appContext),
+    jobdefDescribe(_appContext),
+    jobdefScore(_appContext),
 
     devaScore(_appContext),
     setContext(_appContext)

package/src/toolSet/masDescribe.js

@@ -0,0 +1,67 @@
+/*
+ * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { z } from 'zod';
+import debug from 'debug';
+import _masDescribe from '../toolHelpers/_masDescribe.js';
+const log = debug('tools');
+
+function masDescribe(_appContext) {
+  const isAgent = _appContext && _appContext.agent;
+  let description = isAgent ? `
+mas-describe — return input/output schema for a MAS model.
+PARAMS: intent ('describe', required), name (string, required)
+RETURNS: input variables, output variables, model type, description
+` : `
+mas-describe — return detailed information about a specific MAS model, including its inputs, outputs, and metadata.
+
+USE when: what inputs does model need, describe model, show variables for model, model inputs/outputs
+DO NOT USE for: find model, list models, score model, table/job operations
+
+PARAMETERS
+- intent: must be 'describe' — only pass if user explicitly asked to describe/inspect a MAS model. Do NOT use for find or verify existence.
+- model: string — model name (required, exact match)
+
+ROUTING RULES
+- "what inputs does mas X need?" → { model: "X" }
+- "describe mas Y" → { model: "Y" }
+- "describe mas Y.mas" → { model: "Y" }
+- "show variables for mas Z" → { model: "Z" }
+
+EXAMPLES
+- "What inputs does mas churnRisk need?" → { model: "churnRisk" }
+- "Describe mas creditScore" → { model: "creditScore" }
+- "Show variables for myModel" → { model: "myModel" }
+
+NEGATIVE EXAMPLES (do not route here)
+- "list mas" (use list-models)
+- "find mas X" (use find-model)
+- "score with mas X" (use model-score)
+
+ERRORS
+Returns model metadata: inputs (name, type, role), outputs (name, type, possible_values), model_type, description.
+  `;
+
+  let spec = {
+    name: 'mas-describe',
+    description: description,
+    inputSchema: z.object({
+      intent: z.literal('describe'),
+      model: z.string()
+    }),
+    handler: async (params) => {
+      const { intent, ...rest } = params;
+      if (rest.model != null && rest.model.endsWith('.mas')) {
+        rest.model = rest.model.slice(0, -4);
+      }
+      let r = await _masDescribe(rest);
+      return r;
+    }
+  }
+  return spec;
+}
+
+export default masDescribe;
+

package/src/toolSet/masScore.js

@@ -0,0 +1,95 @@
+/*
+ * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { z } from 'zod';
+import debug from 'debug';
+import _masScoring from '../toolHelpers/_masScoring.js';
+const log = debug('tools');
+
+function masScore(_appContext) {
+  const isAgent = _appContext && _appContext.agent;
+  let description = isAgent ? `
+mas-score — score data using a deployed MAS model.
+PARAMS: model (string, required), scenario (object, optional key=value pairs)
+RETURNS: predictions merged with input values
+` : `
+mas-score — score data using a deployed model on MAS.
+
+USE when: score with model, predict using model, batch scoring, model predictions
+DO NOT USE for: find model, model metadata, list models, run programs/jobs, query tables
+
+PARAMETERS
+- model: string — model name (required, exact match)
+- scenario: object — input data as JSON (optional, defaults to {}). Example: {age:45, income:60000}
+
+
+ROUTING RULES
+- "score with mas model X using a=1, b=2" → { model: "X", scenario: {a:1, b:2} }
+- "score Y.mas for a=1, b=2" → { model: "Y", scenario: {a:1, b:2} }
+- "predict using mas model Y with age=45, income=60000" → { model: "Y", scenario: {age:45, income:60000} }
+
+EXAMPLES
+- "score with mas model churn using age=45, income=60000" → { model: "churn", scenario: {age:45, income:60000} }
+- "predict mas model creditScore for credit=700, debt=20000" → { model: "creditScore", scenario: {credit:700, debt:20000} }
+
+NEGATIVE EXAMPLES (do not route here)
+- "find model X" (use find-model)
+- "what inputs does model need" (use model-info)
+- "list models" (use list-models)
+- "score job X" (use job-score)
+
+ERRORS
+Returns predictions, probabilities, scores merged with input data. Returns error if model not found or scoring fails.
+  `;
+
+ 
+  let spec = {
+    name: 'mas-score',
+    description: description,
+    inputSchema: z.object({
+      model: z.string(),
+      scenario: z.any()
+    }),
+      
+    handler: async (iparams) => {
+      let params = {...iparams};
+      let scenario = params.scenario;
+
+      // Convert the scenario string to an object
+      // Example: "x=1, y=2, z=3" to { x: 1, y: 2, z: 3 }
+      let scenarioObj = {};
+      let count = 0;
+      if (typeof scenario === 'object') {
+        scenarioObj = scenario;
+      } else if (Array.isArray(scenario)) {
+        scenarioObj = scenario[0];
+      } else {
+        //console.error('Incoming scenario', scenario);
+        scenarioObj = scenario.split(',').reduce((acc, pair) => {
+          let [key, value] = pair.split('=');
+          acc[key.trim()] = value;
+          count++;
+          return acc;
+        }, {});
+      }
+      params.scenario = scenarioObj;
+      // Drop model extension (e.g., .job, .model)
+     if (params.model != null) {    
+        if (params.model.endsWith('.mas'))   {
+          params.model = params.model.slice(0, -4);
+        }
+      }
+  
+      log('masScore params', params);
+      // Check if the params.scenario is a string and parse it
+      let r = await _masScoring(params)
+      return r;
+    }
+  }
+  return spec;
+}
+
+export default masScore;
+

package/src/toolSet/{runProgram.js → programScore.js}

@@ -6,12 +6,17 @@
 import { z } from 'zod';
 import _submitCode from '../toolHelpers/_submitCode.js';
 
-function runProgram(_appContext) {
-  let description = `
-run-sas-program — execute SAS code or programs on SAS Viya server.
+function programScore(_appContext) {
+  const isAgent = _appContext && _appContext.agent;
+  let description = isAgent ? `
+program-score — execute a SAS program model.
+PARAMS: src (string, required), folder (string, optional), scenario (string|object, optional), output (string, optional), limit (number, optional)
+RETURNS: log, ODS output, optional output table rows
+` : `
+program-score — execute a SAS program model on SAS Viya server.
 
-USE when: run program, execute SAS code, run .sas file
-DO NOT USE for: macros (use run-macro), jobs (use run-job), jobdefs (use run-jobdef), SQL queries (use sas-query), read data (use read-table)
+USE when: score program, execute SAS code, run .sas file
+DO NOT USE for: macros (use macro-score), jobs (use job-score), jobdefs (use jobdef-score), SQL queries (use sas-query), read data (use read-table)
 
 PARAMETERS
 - src: string — SAS code or .sas filename (required)
@@ -21,18 +26,18 @@ PARAMETERS
 - limit: number (default: 100) — max rows from output
 
 ROUTING RULES
-- "run program 'data a; x=1; run;'" → { src: "data a; x=1; run;", folder: "", output: "", limit: 100 }
-- "run sas program sample folder=/Public/models" → { src: "sample", folder: "/Public/models", output: "", limit: 100 }
-- "run program with name=John, age=45" → { src: "<code>", scenario: {name:"John", age:45}, output: "", limit: 100 }
+- "score program 'data a; x=1; run;'" → { src: "data a; x=1; run;", folder: "", output: "", limit: 100 }
+- "score sas program sample folder=/Public/models" → { src: "sample", folder: "/Public/models", output: "", limit: 100 }
+- "score program with name=John, age=45" → { src: "<code>", scenario: {name:"John", age:45}, output: "", limit: 100 }
 
 EXAMPLES
-- "run program 'data a; x=1; run;'" → { src: "data a; x=1; run;", folder: "", output: "", limit: 100 }
-- "run sas file sample in /Public" → { src: "sample", folder: "/Public", output: "", limit: 100 }
+- "score program 'data a; x=1; run;'" → { src: "data a; x=1; run;", folder: "", output: "", limit: 100 }
+- "score sas file sample in /Public" → { src: "sample", folder: "/Public", output: "", limit: 100 }
 
 NEGATIVE EXAMPLES (do not route here)
-- "run macro X" (use run-macro)
-- "run job X" (use run-job)
-- "run jobdef X" (use run-jobdef)
+- "score macro X" (use macro-score)
+- "score job X" (use job-score)
+- "score jobdef X" (use jobdef-score)
 - "SQL query" (use sas-query)
 - "read table" (use read-table)
 
@@ -41,7 +46,7 @@ Returns log, ods, tables array, data (if output specified). Error if execution f
   `;
 
   let spec = {
-    name: 'run-program',
+    name: 'program-score',
     description: description,
     inputSchema: z.object({
       src: z.string(),
@@ -65,7 +70,7 @@ Returns log, ods, tables array, data (if output specified). Error if execution f
         `;
       }
       // figure out macros
-  
+
       if (typeof scenario === 'string' && scenario.includes('=')) {
         scenario = scenario.split(',').reduce((acc, pair) => {
           const [k, ...rest] = pair.split('=');
@@ -81,7 +86,6 @@ Returns log, ods, tables array, data (if output specified). Error if execution f
         src: isrc,
         _appContext: _appContext
       }
-     // console.error('iparms', iparms);
       let r = await _submitCode(iparms);
       return r;
     }
@@ -89,5 +93,4 @@ Returns log, ods, tables array, data (if output specified). Error if execution f
   return spec;
 }
 
-export default runProgram;
-
+export default programScore;