@sassoftware/sas-score-mcp-serverjs 0.4.1 → 1.0.1-0

package/src/toolSet/devaScore.js

@@ -1,69 +1,61 @@
-/*
- * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-import {z} from 'zod';
-
-function devaScore(_appContext) {
-
-    let description = `
-## deva-score — compute a numeric score based on two input values
-
-LLM Invocation Guidance (When to use)
-Use THIS tool when:
-- User wants to calculate the deva score: "Calculate deva score for 5 and 10"
-- User provides two numbers for scoring: "Score these values: 3 and 7"
-- User wants to compute a score in a series: "Calculate scores for [list of numbers]"
-
-Do NOT use this tool for:
-- Scoring models (use model-score)
-- Statistical calculations beyond deva scoring
-- Looking up data or metadata
-
-Purpose
-Compute a numeric deva score by applying the formula (a + b) * 42 to two input numbers. For scoring more than two numbers, call this tool multiple times using the previous result as the first input (left-to-right fold).
-
-Parameters
-- a (number, required): First numeric input value
-- b (number, required): Second numeric input value
-
-Response Contract
-Returns a numeric result: (a + b) * 42
-The result is always a number representing the computed deva score.
-
-Disambiguation & Clarification
-- If user provides more than two numbers without clear instructions: "Do you want to calculate the deva score by combining these numbers left-to-right?"
-- If user provides non-numeric input: "Please provide numeric values"
-
-Examples (→ mapped params)
-- "Calculate deva score for 5 and 10" → { a: 5, b: 10 } returns 630
-- "Score 1 and 2" → { a: 1, b: 2 } returns 126
-- For multiple numbers, chain calls: devaScore(1,2)→126, then devaScore(126,3)→5418
-
-Negative Examples (should NOT call deva-score)
-- "Score this customer with the credit model" (use model-score instead)
-- "Calculate the mean of these values" (use run-sas-program or sas-query instead)
-
-Related Tools
-- None directly related (this is a specialized scoring tool)
-
-Notes
-For sequences of numbers, use a left-to-right fold: call devaScore(first, second), then use that result as the first parameter for devaScore(result, third), and so on.
-`;
-    let spec = {
-        name: 'deva-score',
-        aliases: ['devaScore','deva score','deva_score'],
-        description: description,
-        schema: {
-            a: z.number(),
-            b: z.number()
-        },
-        handler: async ({ a, b }) => {
-            console.error( a, b);
-            return `MagicScore ${ (a + b) * 42 }`;
-        }
-        
-    }
-    return spec;
-}
-export default devaScore;
+/*
+ * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+
+function devaScore(_appContext) {
+
+    let description = `
+deva-score — compute a numeric score based on two input values.
+
+USE when: calculate deva score, score these values, compute score for numbers
+DO NOT USE for: model scoring (use model-score), statistical calculations, data lookup
+
+PARAMETERS
+- a: number (required) — first input value
+- b: number (required) — second input value
+
+FORMULA: (a + b) * 42
+
+ROUTING RULES
+- "calculate deva score for 5 and 10" → { a: 5, b: 10 }
+- "score 1 and 2" → { a: 1, b: 2 }
+- "deva score a=3, b=7" → { a: 3, b: 7 }
+- Multiple numbers → chain calls left-to-right: call(first, second), then call(result, third)
+
+EXAMPLES
+- "Calculate deva score for 5 and 10" → { a: 5, b: 10 } returns 630
+- "Score 1 and 2" → { a: 1, b: 2 } returns 126
+- "Deva score 20 and 30" → { a: 20, b: 30 } returns 2100
+
+NEGATIVE EXAMPLES (do not route here)
+- "Score this customer with credit model" (use model-score)
+- "Calculate the mean of these values" (use run-sas-program or sas-query)
+- "Statistical analysis of numbers" (use sas-query)
+
+RESPONSE
+Returns { score: (a + b) * 42 }
+    `;
+    let spec = {
+        name: 'deva-score',
+        description: description,
+        inputSchema: z.object({
+            a: z.number(),
+            b: z.number(),
+        }),
+        handler: async ({ a, b }) => {
+            console.error(a, b);
+            let r = { score: (a + b) * 42 };
+            console.error('deva score result', r);
+            return {
+                content: [{ type: 'text', text: 'deva score result: ' + JSON.stringify(r) }],
+                structuredContent: r
+            };
+        }
+    }
+
+    return spec;
+}
+export default devaScore;
+

package/src/toolSet/findJob.js

@@ -5,88 +5,55 @@
 import { z } from 'zod';
 import _listJobs from '../toolHelpers/_listJobs.js';
 function findJob(_appContext) {
-  let llmDescription= {
-  "purpose": "Map natural language requests to find a job in SAS Viya and return structured results.",
-  "param_mapping": {
-    "name": "required - single name. If missing, ask 'Which job name would you like to find?'.",
-    "_userPrompt": "the original user prompt that triggered this tool."
-
-  },
-  "response_schema": "{ jobs: Array<string|object> }",
-  "behavior": "Return only JSON matching response_schema when invoked by an LLM. If no matches, return { jobs: [] }"
-};
+  
   let description = `
-  ## find-job — locate a specific SAS Viya job
-
-  LLM Invocation Guidance
-  Use THIS tool when the user intent is to check if ONE job exists or retrieve its metadata:
-  - "find job cars_job_v4"
-  - "does job sales_summary exist"
-  - "is there a job named churnScorer"
-  - "lookup job forecast_monthly"
-  - "verify job ETL_Daily" 
-
-  Do NOT use this tool when the user asks for:
-  - A list or browse of many jobs (use listJobs)
-  - Do not use this tool if the user want to find lib, find table, find model and similar requests
-  - Executing a job (use job)
-  - Running a job definition (use jobdef)
-  - Submitting arbitrary code (use program)
-
-  Purpose
-  Quickly determine whether a named job asset is present in the Viya environment and return its entry (or an empty result if not found).
-
-  Parameters
-  - name (string, required): Exact job name (case preserved). If multiple tokens/names supplied, take the first and ignore the rest; optionally ask for a single name.
-
-  Behavior & Matching
-  - Attempt exact match first (backend determines sensitivity).
-  - Returns { jobs: [...] } where array length is 0 (not found) or 1+ (if backend returns multiple with the same display name).
-  - No fuzzy guesses—never fabricate a job.
-  - If no name provided: ask "Which job name would you like to find?".
-
-  Response Contract
-  - Always: { jobs: Array<string|object> }
-  - On error: propagate structured server error (do not wrap in prose when invoked programmatically).
-
-  Disambiguation Rules
-  - Input only "find job" → ask for missing name.
-  - Input contains verbs like "run" or "execute" → use run-job or run-jobdef instead.
-  - Input requesting many (e.g., "find all jobs") → use list-jobs.
-
-  Examples (→ mapped params)
-  - "find job cars_job_v4" → { name: "cars_job_v4" }
-  - "does job ETL exist" → { name: "ETL" }
-  - "is there a job named metricsRefresh" → { name: "metricsRefresh" }
-
-  Negative Examples (should NOT call find-job)
-  - "list jobs" (list-jobs)
-  - "run job cars_job_v4" (run-job)
-  - "execute jobdef cars_job_v4" (run-jobdef)
-
-  Clarifying Question Template
-  - Missing name: "Which job name would you like to find?"
-  - Multiple names: "Please provide just one job name (e.g. 'cars_job_v4')."
-
-  Notes
-  - For bulk existence checks loop over names and call find-job per name.
-  - Combine with run-job tool if user wants to execute after confirming existence.
+find-job — locate a specific SAS Viya job.
+
+USE when: find job, does job exist, is there a job named, lookup job, verify job exists
+DO NOT USE for: list jobs (use list-jobs), run job (use run-job), execute jobdef (use run-jobdef), find lib/table/model (use respective tools)
+
+PARAMETERS
+- name: string (required) — job name to locate; if multiple supplied, use first
+
+ROUTING RULES
+- "find job <name>" → { name: "<name>" }
+- "does job <name> exist" → { name: "<name>" }
+- "is there a job named <name>" → { name: "<name>" }
+- "lookup/verify job <name>" → { name: "<name>" }
+- "find job" with no name → ask "Which job name would you like to find?"
+- "find all jobs / list jobs" → use list-jobs instead
+- "run job <name>" → use run-job instead
+
+EXAMPLES
+- "find job cars_job_v4" → { name: "cars_job_v4" }
+- "does job ETL exist" → { name: "ETL" }
+- "is there a job named metricsRefresh" → { name: "metricsRefresh" }
+
+NEGATIVE EXAMPLES (do not route here)
+- "list jobs" (use list-jobs)
+- "run job cars_job_v4" (use run-job)
+- "execute jobdef cars_job_v4" (use run-jobdef)
+
+ERRORS
+Returns { jobs: [] } if not found; { jobs: [name, ...] } if found. Never hallucinate job names.
   `;
 
   let spec = {
     name: 'find-job',
-    aliases: ['findJob','find job','find_job'],
     description: description,
-    schema: {
-      name: z.string(),
-      _userPrompt: z.string()
-    },
-    required: ['name'],
+    inputSchema: z.object({
+      name: z.string()
+    }),
     handler: async (params) => {
       let r = await _listJobs(params);
       return r;
     }
   }
+    
+
+  /* correct spec for registerTool with inputSchema */
+  
   return spec;
 }
 export default findJob;
+

package/src/toolSet/findJobdef.js

@@ -15,76 +15,44 @@ function findJobdef(_appContext) {
   "behavior": "Return only JSON matching response_schema when invoked by an LLM. If no matches, return { jobs: [] }"
 };
   let description = `
-  ## find-jobdef — locate a specific SAS Viya job
+find-jobdef — locate a specific SAS Viya job definition.
 
-  LLM Invocation Guidance
-  Use THIS tool when the user intent is to check if ONE job exists or retrieve its metadata:
-  - "find jobdef cars_job_v4"
-  - "does jobdef sales_summary exist"
-  - "is there a jobdef named churnScorer"
-  - "lookup jobdef forecast_monthly"
-  - "verify jobdef ETL_Daily" 
+USE when: find jobdef, does jobdef exist, is there a jobdef named, lookup jobdef, verify jobdef exists
+DO NOT USE for: list jobdefs (use list-jobdefs), run jobdef (use run-jobdef), find job/lib/table/model (use respective tools)
 
-  Do NOT use this tool when the user asks for:
-  - find job  (use find-job)
-  - find table (use find-table
-  - find model (use find-model)
-  - find lib (use find-library)
-  - Executing a job (use job)
-  - Running a job definition (use jobdef)
-  - Submitting arbitrary code (use program)
+PARAMETERS
+- name: string (required) — jobdef name to locate; if multiple supplied, use first
 
-  Purpose
-  Quickly determine whether a named jobdef asset is present in the Viya environment and return its entry (or an empty result if not found).
+ROUTING RULES
+- "find jobdef <name>" → { name: "<name>" }
+- "does jobdef <name> exist" → { name: "<name>" }
+- "is there a jobdef named <name>" → { name: "<name>" }
+- "lookup/verify jobdef <name>" → { name: "<name>" }
+- "find jobdef" with no name → ask "Which jobdef name would you like to find?"
+- "find all jobdefs / list jobdefs" → use list-jobdefs instead
+- "run jobdef <name>" → use run-jobdef instead
 
-  Parameters
-  - name (string, required): Exact jobdef name (case preserved). If multiple tokens/names supplied, take the first and ignore the rest; optionally ask for a single name.
+EXAMPLES
+- "find jobdef cars_job_v4" → { name: "cars_job_v4" }
+- "does jobdef ETL exist" → { name: "ETL" }
+- "is there a jobdef named metricsRefresh" → { name: "metricsRefresh" }
 
-  Behavior & Matching
-  - Attempt exact match first (backend determines sensitivity).
-  - Returns { jobdefs: [...] } where array length is 0 (not found) or 1+ (if backend returns multiple with the same display name).
-  - No fuzzy guesses—never fabricate a job.
-  - If no name provided: ask "Which jobdef name would you like to find?".
+NEGATIVE EXAMPLES (do not route here)
+- "list jobdefs" (use list-jobdefs)
+- "run jobdef cars_job_v4" (use run-jobdef)
+- "find job ETL" (use find-job)
+- "find table cars" (use find-table)
 
-  Response Contract
-  - Always: { jobdefs: Array<string|object> }
-  - On error: propagate structured server error (do not wrap in prose when invoked programmatically).
-
-  Disambiguation Rules
-  - Input only "find job" → ask for missing name.
-  - Input contains verbs like "run" or "execute" → use run-job or run-jobdef instead.
-  - Input requesting many (e.g., "find all jobs") → use list-jobs.
-
-  Examples (→ mapped params)
-  - "find jobdef cars_job_v4" → { name: "cars_job_v4" }
-  - "does jobdef ETL exist" → { name: "ETL" }
-  - "is there a jobdef named metricsRefresh" → { name: "metricsRefresh" }
-
-  Negative Examples (should NOT call find-jobdef)
-  - find lib (use find-library)
-  - find table (use find-table)
-  - find model (use find-model)
-  - "list job" (list-jobdefs)
-  - "run job cars_job_v4" (run-job)
-  - "execute jobdef cars_job_v4" (run-jobdef)
-
-  Clarifying Question Template
-  - Missing name: "Which jobdef name would you like to find?"
-  - Multiple names: "Please provide just one jobdef name (e.g. 'cars_job_v4')."
-
-  Notes
-  - For bulk existence checks loop over names and call find-jobdef per name.
-  - Combine with run-jobdef tool if user wants to execute after confirming existence.
+ERRORS
+Returns { jobdefs: [] } if not found; { jobdefs: [name, ...] } if found. Never hallucinate jobdef names.
   `;
 
   let spec = {
     name: 'find-jobdef',
-    aliases: ['findJobdef','find jobdef','find_jobdef'],
     description: description,
-    schema: {
-      name: z.string()
-    },
-    required: ['name'],
+    inputSchema: z.object({
+        name: z.string()
+    }),
     handler: async (params) => {
       let r = await _listJobdefs(params);
       return r;
@@ -93,3 +61,4 @@ function findJobdef(_appContext) {
   return spec;
 }
 export default findJobdef;
+

package/src/toolSet/findLibrary.js

@@ -1,100 +1,68 @@
-/*
- * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { z } from 'zod';
-import _listLibrary from '../toolHelpers/_listLibrary.js';
-function findLibrary(_appContext) {
-  
-  let description = `
-  ## find-library — locate a specific CAS or SAS library
-
-  LLM Invocation Guidance
-  Use THIS tool when the user asks any of the following (intent = existence / lookup of ONE library):
-  - "find library Public"
-  - "find lib Public"
-  - "does library SASHELP exist"
-  - "is PUBLIC library available in cas"
-  - "lookup library sasuser in sas"
-  - "show me library metadata for Models"
-
-  Aliases for lib are: library, caslib, libref
-  
-  Do NOT use this tool when the user wants:
-  - find model -> use find-model
-  - find table -> use find-table
-  - find job -> use find-job
-  - find jobdef -> use find-jobdef
-  - Columns or schema of a table (use table-info)
-  - Creating/assigning libraries (use run-sas-program or another admin tool)
-
-  Purpose
-  Quickly verify whether a single named library exists on CAS or SAS and return its entry (or empty if not found).
-
-  Parameters
-  - name (string, required) : Exact library (caslib) name to locate. If multiple names provided (comma/space separated), use the first and ignore the rest; optionally ask for one name.
-  - server (cas|sas, default 'cas') : Target environment. If omitted or ambiguous default to 'cas'.
-
-  Behavior & Matching
-  - Performs an exact name match (case-insensitive where backend supports it).
-  - Returns an object: { libraries: [...] } where the array contains zero or one items (backend may still return richer metadata).
-  - If no match: { libraries: [] } (do NOT fabricate suggestions).
-  - If user supplies no name: ask a clarifying question: "Which library name would you like to find?".
-  - If user clearly wants a list ("list", "show all", "enumerate") route to listLibrary instead.
-
-  Response Contract
-  - Always: { libraries: Array<string|object> }
-  - Never include prose when invoked programmatically; only the JSON structure.
-
-  Disambiguation Rules
-  - Input only "find library" → ask for the missing name.
-  - Input with both library name and words like "tables" → prefer listTables.
-  - Input like "find libraries" (plural) → prefer listLibrary unless user clarifies to a single name.
-
-  Examples (→ mapped params)
-  - "find lib Public" → { name: "Public", server: "cas" }
-  - "find library sasuser in sas" → { name: "sasuser", server: "sas" }
-  - "does library Formats exist" → { name: "Formats", server: "cas" }
-  - "is SystemData library in cas" → { name: "SystemData", server: "cas" }
-
-  Negative Examples (should NOT call find-library)
-  - "list libs" (list-libraries)
-  -  Do not use this tool if the user want to find table, find job, find model, find job, find jobdef  and similar requests
-  - "show tables in Public" (list-tables)
-  - "describe table cars in sashelp" (table-info)
-
-  Clarifying Question Template
-  - Missing name: "Which library name would you like to find?"
-  - Multiple names: "Please provide just one library name to look up (e.g. 'Public')."
-
-  Notes
-  - For bulk validation of many names, call this tool repeatedly per name.
-  - For pagination or discovery, switch to list-libraries.
-  `;
-
-  let spec = {
-    name: 'find-library',
-    aliases: ['findLibrary','find library','find_library'],
-    description: description,
-    schema: {
-      name: z.string(),
-      server: z.string().default('cas')
-    },
-    required: ['name'],
-    handler: async (params) => {
-      // normalize server to lowercase & default
-      if (!params.server) params.server = 'cas';
-      params.server = params.server.toLowerCase();
-
-      // If multiple names passed (comma or space separated), take the first token (defensive)
-      if (params.name && /[,\s]+/.test(params.name.trim())) {
-        params.name = params.name.split(/[,\s]+/).filter(Boolean)[0];
-      }
-
-      let r = await _listLibrary(params);
-      return r;
-    }
-  }
-  return spec;
-}
-export default findLibrary;
+/*
+ * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import _listLibrary from '../toolHelpers/_listLibrary.js';
+function findLibrary(_appContext) {
+  
+  let description = `
+find-library — locate a specific CAS or SAS library.
+
+USE when: find library, find lib, does library exist, is library available, lookup library
+DO NOT USE for: list libraries (use list-libraries), find table/job/jobdef/model (use respective tools), table structure (use table-info), create library (use run-sas-program)
+
+PARAMETERS
+- name: string (required) — library/caslib name; if multiple supplied, use first
+- server: 'cas' | 'sas' (default: 'cas') — target environment
+
+ROUTING RULES
+- "find lib <name>" → { name: "<name>", server: "cas" }
+- "find lib <name> in cas" → { name: "<name>", server: "cas" }
+- "find library <name> in sas" → { name: "<name>", server: "sas" }
+- "does library <name> exist" → { name: "<name>", server: "cas" }
+- "find lib" with no name → ask "Which library name would you like to find?"
+- "list libraries / list libs" → use list-libraries instead
+- "tables in <lib>" → use list-tables instead
+
+EXAMPLES
+- "find lib Public" → { name: "Public", server: "cas" }
+- "find library sasuser in sas" → { name: "sasuser", server: "sas" }
+- "does library Formats exist" → { name: "Formats", server: "cas" }
+
+NEGATIVE EXAMPLES (do not route here)
+- "list libs" (use list-libraries)
+- "show tables in Public" (use list-tables)
+- "find table cars in sashelp" (use find-table)
+- "find job cars_job" (use find-job)
+
+ERRORS
+Returns { libraries: [] } if not found; { libraries: [name, ...] } if found. Never hallucinate library names.
+  `;
+
+  let spec = {
+    name: 'find-library',
+    description: description,
+    inputSchema: z.object({
+      name: z.string(),
+      server: z.string().optional()
+    }),
+    
+    handler: async (params) => {
+      // normalize server to lowercase & default
+      if (!params.server) params.server = 'cas';
+      params.server = params.server.toLowerCase();
+
+      // If multiple names passed (comma or space separated), take the first token (defensive)
+      if (params.name && /[,\s]+/.test(params.name.trim())) {
+        params.name = params.name.split(/[,\s]+/).filter(Boolean)[0];
+      }
+
+      let r = await _listLibrary(params);
+      return r;
+    }
+  }
+  return spec;
+}
+export default findLibrary;
+