@sassoftware/sas-score-mcp-serverjs 0.0.2

package/src/toolSet/runMacro.js

@@ -0,0 +1,82 @@
+/*
+ * 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 a SAS Viya server by generating and sending SAS code.
+
+Inputs
+- macro (string, required): The name of the macro to execute (provide the macro identifier without the leading "%").
+- scenario (string, optional): Parameters or SAS setup code to send before invoking the macro. Accepted formats:
+  - Comma-separated key=value pairs (e.g. "x=1, y=abc") — converted to SAS %let statements.
+  - Raw SAS macro code (e.g. "%let x=1; %let y=abc;") — passed through unchanged when it already contains SAS macro syntax.
+
+Behavior
+- If \`scenario\` contains SAS macro syntax (contains \`%let\` or other macro markers), it is sent unchanged.
+- Otherwise the tool converts comma-separated parameters into \`%let\` statements (e.g. "x=1,y=abc" → "%let x=1; %let y=abc;") and appends a macro invocation \`%<macro>;\`.
+- The resulting SAS code is submitted via the internal \`_submitCode\` helper and the submission result is returned.
+
+Output
+- Returns the response produced by \`_submitCode\`, typically including ods, log, list of tables created by the macro
+
+Usage notes
+- Ensure the target SAS environment has the macro defined
+- This helper does not perform advanced input validation or type coercion — validate parameters before calling when needed.
+
+Examples
+- run macro \`abc\` with scenario \`x=1, y=2\`
+- run macro \`summarize\` with raw SAS code \`%let x=1; %let y=2;\` (the helper will pass it through unchanged)
+`;
+
+  let spec = {
+    name: 'run-macro',
+    aliases: ['runMacro','run macro','run_macro'],
+    description: description,
+    
+     schema: {
+      macro: z.string(),
+      scenario: z.string()
+    },
+    required: ['macro'],
+    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;

package/src/toolSet/runProgram.js

@@ -0,0 +1,145 @@
+/*
+ * 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 runProgram(_appContext) {
+  let description = `
+## run-sas-program — execute SAS code or programs on SAS Viya server
+
+LLM Invocation Guidance (When to use)
+Use THIS tool when the user wants to run a SAS program on the server:
+- "run program 'data a; x=1; run;'"
+- "execute this SAS code: proc print data=sashelp.cars; run;"
+- "program 'data work.a; x=1; run;' output=a limit=50"
+- "run sas program sample folder=/Public/models output=A limit=50"
+- "run sas program with parameters name=John, age=45"
+- "execute SAS file myprogram.sas from /Public folder"
+
+Do NOT use this tool when the user wants:
+- run macro -> use run-macro
+- run job -> use run-job
+- run jobdef -> use run-jobdef
+- list jobs -> use list-jobs
+- list jobdefs -> use list-jobdefs
+- find job -> use find-job
+- find jobdef -> use find-jobdef
+- find model -> use find-model
+- Query tables with SQL -> use sas-query
+- Read table data -> use read-table
+
+Purpose
+Execute SAS code or programs on a SAS Viya server. Can run inline SAS code or execute .sas files stored on the server. Supports parameter passing via scenario values and can return output tables.
+
+Parameters
+- src (string, required): The SAS program to execute. Can be either:
+  - Inline SAS code as a string (e.g., "data a; x=1; run;")
+  - Name of a .sas file stored on the server (used with folder parameter)
+- folder (string, default ''): Server folder path where the .sas file is located (e.g., "/Public/models")
+- scenario (string | object, optional): Input parameter values. Accepts:
+  - Comma-separated key=value string (e.g., "x=1, y=2")
+  - JSON object with field names and values (recommended)
+- output (string, default ''): Table name to return in response (case-sensitive)
+- limit (number, default 100): Maximum number of rows to return from output table
+
+Response Contract
+Returns a JSON object containing:
+- log: Execution log from SAS
+- ods: ODS output if generated
+- tables: Array of table names created during execution
+- data: If output parameter specified, returns the table data (up to limit rows)
+- error: Error message if execution fails
+- Empty content if no results produced
+
+Disambiguation & Clarification
+- Missing SAS code: ask "What SAS program or code would you like to execute?"
+- Inline code vs file unclear: ask "Do you want to run inline SAS code or execute a .sas file from the server?"
+- If output table not returned: clarify "The output table name is case-sensitive. Did you specify the exact name?"
+- If unclear about parameters: ask "What parameter values should I pass to the program?"
+
+Examples (→ mapped params)
+- "run program 'data a; x=1; run;'" → { src: "data a; x=1; run;", folder: "", output: "", limit: 100 }
+- "program 'data work.a; x=1; run;' output=a limit=50" → { src: "data work.a; x=1; run;", folder: "", output: "a", limit: 50 }
+- "run sas program sample folder=/Public/models output=A limit=50" → { src: "sample", folder: "/Public/models", output: "A", limit: 50 }
+- "run program mycode.sas in /Public with name=John, age=45" → { src: "mycode", folder: "/Public", scenario: { name: "John", age: 45 }, output: "", limit: 100 }
+
+Negative Examples (should NOT call run-sas-program)
+- "run macro summarize" (use run-macro instead)
+- "run job monthly_report" (use run-job instead)
+- "run jobdef etl_process" (use run-jobdef instead)
+- "how many customers by region in Public.customers" (use sas-query instead)
+- "read 10 rows from cars" (use read-table instead)
+
+Behavior & Usage Notes
+- Sends the supplied src verbatim to the SAS execution helper
+- For .sas files, specify the file name (with or without .sas extension) and the folder path
+- For invoking pre-defined SAS macros, prefer run-macro which handles %let statements automatically
+- Scenario values are converted to macro variables when provided
+- Be cautious when executing arbitrary code in production environments
+
+Related Tools
+- run-macro — for executing predefined SAS macros with parameters
+- run-job — for executing registered Job Execution assets
+- sas-query — for natural language SQL queries
+- read-table — for simple data retrieval
+`;
+
+  let spec = {
+    name: 'run-sas-program',
+    aliases: ['Program','run program'],
+    description: description,
+    schema: {
+      src: z.string(),
+      scenario: z.any().default(''),
+      output: z.string().default(''),
+      folder: z.string().default(''),
+      limit: z.number().default(100)
+    },
+  // NOTE: Previously 'required' incorrectly listed 'program' which does not
+  // exist in the schema. This prevented execution in some orchestrators that
+  // enforce required parameter presence, causing only descriptions to appear.
+  // Corrected to 'src'.
+  required: ['src'],
+    handler: async (params) => {
+      let {src, folder, scenario, _appContext} = params;
+      // figure out src
+      let isrc = src;
+      if (folder != null && folder.trim().length > 0) {
+        if (isrc.indexOf('.sas') < 0) {
+          isrc = isrc + '.sas';
+        }
+        isrc = `
+          filename mcptemp filesrvc folderpath="${folder}";
+          %include mcptemp("${isrc}");
+          filename mcptemp clear;
+        `;
+      }
+      // figure out macros
+  
+      if (typeof scenario === 'string' && scenario.includes('=')) {
+        scenario = scenario.split(',').reduce((acc, pair) => {
+          const [k, ...rest] = pair.split('=');
+          if (!k) return acc;
+          acc[k.trim()] = rest.join('=').trim();
+          return acc;
+        }, {});
+      }
+      let iparms = {
+        args: scenario,
+        output: params.output,
+        limit: params.limit,
+        src: isrc,
+        _appContext: _appContext
+      }
+     // console.error('iparms', iparms);
+      let r = await _submitCode(iparms);
+      return r;
+    }
+  }
+  return spec;
+}
+
+export default runProgram;

package/src/toolSet/sasQuery.js

@@ -0,0 +1,126 @@
+/*
+ * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import {z} from 'zod';
+import _jobSubmit from '../toolHelpers/_jobSubmit.js';
+
+
+function sasQuery() {
+ 
+    let description = `
+## sas-query — convert natural language questions into SQL queries and execute them
+
+LLM Invocation Guidance (When to use)
+Use THIS tool when:
+- User asks a natural language question about table data: "how many customers by region?"
+- User wants aggregated analytics: "show total sales by year"
+- User needs complex filtering: "find all orders over $1000 from last month"
+- User requests joined data: "show products with their category names"
+- User wants statistical summaries: "average, min, max salary by department"
+- User asks for specific calculations: "percentage of customers by state"
+
+Do NOT use this tool for:
+- Reading raw table data without filtering (use read-table)
+- Getting table structure or column info (use table-info)
+- Running pre-written SAS programs (use run-sas-program)
+- Running jobs or job definitions (use run-job or run-jobdef)
+- Executing macros (use run-macro)
+- Simple table reads with no aggregation (use read-table)
+
+Purpose
+Convert natural language queries into SAS PROC SQL SELECT statements and execute them to retrieve analyzed data. The LLM generates the SQL from the natural language query, and this tool executes it against the specified table.
+
+Parameters
+- table (string, required): Table name in lib.table format (e.g., "Public.cars", "sashelp.class")
+- query (string, required): Natural language description of what data you want
+- sql (string, optional): Pre-generated SQL SELECT statement (LLM should generate this from the query)
+- job (string, default 'program'): Job name to execute the query (default is 'program')
+
+Behavior & Processing
+- LLM converts the natural language query into a valid SAS PROC SQL SELECT statement
+- Do not add semicolons to the end of SQL statements
+- SQL reference: https://go.documentation.sas.com/doc/en/pgmsascdc/v_067/sqlproc/n0w2pkrm208upln11i9r4ogwyvow.htm
+- Tool executes the generated SQL against the specified table
+- Returns data in JSON format
+
+Response Contract
+Returns a JSON object containing:
+- rows: Array of row objects with query results
+- columns: Column metadata from the query result
+- log: Execution log if available
+- If error: structured error message
+- If more than 10 rows: only first 10 displayed (ask user if they want more)
+
+Disambiguation & Clarification
+- If table missing: ask "Which table should I query (format: lib.tablename)?"
+- If query too vague: ask "Can you be more specific about what data or calculation you want?"
+- If table format unclear: ask "Please specify table as library.tablename (e.g., Public.cars)"
+- If ambiguous calculation: ask for clarification on what to aggregate or filter
+
+Examples (→ mapped params)
+- "how many cars by make in sashelp.cars" → { table: "sashelp.cars", query: "how many cars by make", sql: "SELECT make, COUNT(*) AS count FROM sashelp.cars GROUP BY make" }
+- "average horsepower by origin" → { table: "sashelp.cars", query: "average horsepower by origin", sql: "SELECT origin, AVG(horsepower) AS avg_hp FROM sashelp.cars GROUP BY origin" }
+- "total sales over $1000 by region" → { table: "mylib.sales", query: "total sales over $1000 by region", sql: "SELECT region, SUM(amount) AS total FROM mylib.sales WHERE amount > 1000 GROUP BY region" }
+- "percentage of students by year in Public.students" → { table: "Public.students", query: "percentage by year", sql: "SELECT year, COUNT(*) * 100.0 / (SELECT COUNT(*) FROM Public.students) AS pct FROM Public.students GROUP BY year" }
+
+Negative Examples (should NOT call sas-query)
+- "read table cars from sashelp" (use read-table instead)
+- "show me 10 rows from customers" (use read-table instead)
+- "what columns are in the sales table?" (use table-info instead)
+- "run this SAS code: proc sql; select * from..." (use run-sas-program instead)
+- "execute job monthly_report" (use run-job instead)
+- "run macro summarize_data" (use run-macro instead)
+
+Usage Tips
+- Ensure table is specified in lib.tablename format
+- Be specific in natural language queries for better SQL generation
+- Use table-info first to understand column names and types
+- For simple reads without filtering/aggregation, prefer read-table
+
+Related Tools
+- read-table — for simple data reading without SQL queries
+- table-info — to inspect table schema before querying
+- run-sas-program — for executing pre-written SAS/SQL code
+- find-table — to verify table exists before querying
+`;
+
+
+    let spec = {
+        name: 'sas-query',
+        aliases: ['sasQuery','sas query','sas_query'],
+        description: description,
+        schema: {
+            query: z.string(),
+            table: z.string(),
+            sql: z.string().optional(),
+            job: z.string().default('program')
+        },
+        required: ['query', 'table'],
+        handler: async (params) => {
+            let {table,query, sql, job, _appContext} = params;
+            let sqlinput = (sql == null) ? ' ' : sql.replaceAll(';', ' ').replaceAll('\n', ' ').replaceAll('\r', ' ');
+            
+            let iparams = {
+                scenario: {
+                    table: table,
+                    prompt: query,
+                    sql: sqlinput
+                },
+                name: (job == null) ? 'program' : job,
+                type: 'job',
+                query: true,
+                _appContext: _appContext
+            };
+            if (sql == null || sql.trim().length === 0) {
+                return { content: [{ type: 'text', text: 'Error: The SQL statement generated is blank. Please provide a valid natural language query that can be converted to SQL.' }] };
+            }
+         
+            let r = await _jobSubmit(iparams);
+            return r;
+            
+           }
+        }
+    return spec;
+}
+export default sasQuery;

package/src/toolSet/sasQueryTemplate.js

@@ -0,0 +1,148 @@
+/*
+ * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import _jobSubmit from '../toolHelpers/_jobSubmit.js';
+import _tableColumns from '../toolHelpers/_tableColumns.js';
+
+
+async function sasQueryTemplate(uparams) {
+
+    let toolname = uparams.name;
+    let uTable = uparams.table;
+    let selectColumns = uparams.selectColumns;
+    let selectColumns2 = (selectColumns == null) ? '_All_' : selectColumns.replace(',', ' ');
+    let uJob = (uparams.job == null) ? 'run_sql_query' : uparams.job;
+    
+    // let allColumns = await _tableColumns(uTable, uparams.server);
+    
+    let selcols = (selectColumns == null) ? ' ' :  'and the columns ${selectColumns}';
+    let instruction1 = 'The valid columns in the table ${uTable} are: ${allColumns}. ';
+
+    let description = `
+    You are an expert at translating natural language filter into SAS PROC SQL SELECT statement for the table ${uTable}.
+    You will then convert the user's query to a valid SAS PROC SQL SELECT statement  and pass this string 
+    as the query. 
+
+    Instructions to LLM: 
+     
+    If the user does not select any columns assume they want to select these columns ${selectColumns}.
+    The handler will return the data that was queried from the table.
+
+    User can optionally specify a SAS job to run the query on the SAS Server. If not specified, the default job 'run_sql_query' will be used.
+
+    The desired flow:
+    Instructions to LLM: Show the progress of how you are thinking about converting the natural language query to SQL.
+    Step 1:  User provides the following prompt:
+    ${toolname} <natural language query>
+    
+    Step 2: Convert the user's natural language query into a valid SAS PROC SQL SELECT statement. A good reference for
+    the SQL syntax is this [link](https://go.documentation.sas.com/doc/en/pgmsascdc/v_067/sqlproc/n0w2pkrm208upln11i9r4ogwyvow.htm)
+    Instructions to LLM: 
+   - Do not add a semicolon to the end of the SQL statement.
+      - Use only the columns from the table ${uTable} in the SELECT and WHERE clauses.
+      - If the user query is ambiguous, ask for clarification instead of guessing.
+    
+    Step 3:  Pass these as parameters to the handler:
+    { table: ${uTable}, 
+      query: <user's natural language query>,
+      sql: <generated SQL query> }
+     
+    If the user specified a job, include that in the parameters:
+    { table: ${uTable}, 
+      query: <user's natural language query>,
+      sql: <generated SQL query>,
+      job: <job name> }
+
+    Example 1:
+    
+    Step 1: User prompt:
+    
+    User prompt:
+    ${toolname} Total paid amount, unique patients, and unique claims by procedure code for diagnosis code Z1100, Z10119, Z1020
+    
+    Step 2: Convert the query to a SQL Select statement 
+    
+    sql = "
+    SELECT prcdr_cd, SUM(pd_amt) AS total_paid_amount, COUNT(DISTINCT mdcd_id) AS unique_patients, COUNT(DISTINCT icn) AS unique_claims
+    FROM ${uTable}
+    WHERE diag_cd IN ('Z1100', 'Z10119', 'Z1020')
+    GROUP BY prcdr_cd
+    "
+    
+    Step 3: Pass these to the handler
+    { table: ${uTable},
+      query: "Total paid amount, unique patients, and unique claims by procedure code for diagnosis code Z1100, Z10119, Z1020",
+      sql: "SELECT prcdr_cd, SUM(pd_amt) AS total_paid_amount, COUNT(DISTINCT mdcd_id) AS unique_patients, COUNT(DISTINCT icn) AS unique_claims
+           FROM ${uTable}
+           WHERE diag_cd IN ('Z1100', 'Z10119', 'Z1020')
+           GROUP BY prcdr_cd",
+     selectColumns: ${selectColumns}
+    }
+    
+    Step 4: Handler returns the results of the query to the user. The output has a json representation of the table.
+    
+    Example 2:
+    Input: ${toolname} How many students are in each year and show me in percentage
+    
+    
+    The parameters passed to the handler are:
+    {
+        table: ${uTable},
+        query: "How many students are in each year and show me in percentage"
+        sql: "SELECT year,
+                COUNT(DISTINCT student_id) AS number_of_students,
+                COUNT(*) / (SELECT COUNT(DISTINCT student_id) FROM ${uTable}) AS Percent FORMAT=percent8.2
+                FROM ${uTable}
+                GROUP BY year",
+        selectColumns: ${selectColumns}
+    }
+
+    ## Desired Output Display Format
+    If the query is successful and returns rows, display the rows as a markdown table.
+
+`;
+   
+    let spec = {
+        name: toolname,
+        description: description,
+       
+        schema: {
+            query: z.string(),
+            table: z.string().default(uTable),
+            sql: z.string().optional()
+        },
+        required: ['query', 'table'],
+        handler: async (params) => {
+            
+          
+            let { table, query, sql, _appContext} = params;
+            let sqlinput = (sql == null) ? ' ' : sql.replaceAll(';', ' ').replaceAll('\n', ' ').replaceAll('\r', ' ');
+            
+            let iparams = { 
+                scenario: {
+                    table: table,
+                    prompt: query,
+                    sql: sqlinput,
+                    selectcolumns: `${selectColumns2}`
+                },
+                name: `${uJob}`,
+                type: 'job',
+                _appContext: _appContext
+            };
+        
+            if (sql == null || sql.trim().length === 0) {
+                return { content: [{ type: 'text', text: 'Error: The SQL statement generated is blank. Please provide a valid natural language query that can be converted to SQL.' }] };
+            }
+
+            let r = await _jobSubmit(iparams);
+            return r;
+
+        }
+    };
+    return spec;
+  
+   
+}
+export default sasQueryTemplate;

package/src/toolSet/sasQueryTemplate2.js

@@ -0,0 +1,140 @@
+/*
+ * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import _jobSubmit from '../toolHelpers/_jobSubmit.js';
+import _tableColumns from '../toolHelpers/_tableColumns.js';
+
+async function sasQueryTemplate2(uparams) {
+
+    let toolname = uparams.name;
+    let uTable = uparams.table;
+    let selectColumns = uparams.selectColumns;
+    let selectColumns2 = (selectColumns == null) ? '_All_' : selectColumns.replaceAll(',', ' ');
+    let uJob = (uparams.job == null) ? 'run_sql_query' : uparams.job;
+    
+    let allColumns = await _tableColumns(uTable, uparams.server);
+    
+    let selcols = (selectColumns == null) ? ' ' :  'and the columns ${selectColumns}';
+    let instruction1 = 'The valid columns in the table ${uTable} are: ${allColumns}. ';
+
+    let description = `
+    You are an expert in SAS Viya PROC SQL syntax.
+    You are tasked with creating a SAS PROC SQL SELECT statement  based on the user's natural language filter for the table ${uTable}.
+    The Select statement you create will have the following syntax:
+
+    SELECT ${selectColumns} from ${uTable} AS <SQL expressions>
+
+    You will then convert the user's query to a valid SAS PROC SQL SELECT expressions
+
+    The valid non-columns in the table ${uTable} are: ${allColumns}. If others are specified inform the user of the error.
+    
+    Example:
+
+    User query: Origin ='Asia'
+    SQL expressions: WHERE Origin = 'Asia'
+    sql:  SELECT ${selectColumns} from ${uTable} AS WHERE Origin = 'Asia'
+
+    as the query to be executed on the server.
+
+
+    User can optionally specify a SAS job to run the query on the SAS Server. If not specified, the default job 'run_sql_query' will be used.
+
+    The desired flow:
+    Instructions to LLM: Show the progress of how you are thinking about converting the natural language query to SQL.
+    Step 1:  User provides the following prompt:
+    ${toolname} <natural language query>
+    
+    Step 2: Convert the user's natural language query into a valid SAS PROC SQL SELECT expression to complete the following sql :
+    
+      SELECT ${selectColumns} from ${uTable} AS <sql expression the LLM generated>
+        
+    A good reference for
+    the SQL syntax is this [link](https://go.documentation.sas.com/doc/en/pgmsascdc/v_067/sqlproc/n0w2pkrm208upln11i9r4ogwyvow.htm)
+
+    Instructions to LLM: 
+   - Do not add a semicolon to the end of the SQL statement.
+      - Use only the columns from the table ${uTable} in the SELECT and SQL expression.
+      - If the user query is ambiguous, ask for clarification instead of guessing.
+    
+    Step 3:  Pass these as parameters to the handler:
+    { table: ${uTable}, 
+      query: <user's natural language query>,
+      sql: <generated SQL> 
+    }
+     
+    If the user specified a job, include that in the parameters:
+    { table: ${uTable}, 
+      query: <user's natural language query>,
+      sql: <generated SQL query>,
+      job: <job name> }
+
+    Example 1:
+    
+    Step 1: User prompt:
+    
+    User prompt:
+    ${toolname} origin='Asia' and make='Toyota'
+    
+    Step 2: Convert the query to a SQL Select statement 
+    
+    sql = "
+    SELECT ${selectColumns} from ${uTable} AS WHERE origin='Asia' and make='Toyota'
+    "
+    
+    Step 3: Pass these to the handler
+    { table: ${uTable},
+      query: "origin='Asia' and make='Toyota",
+      sql: "SELECT ${selectColumns} from ${uTable} AS WHERE origin='Asia' and make='Toyota'"
+    
+    }
+    
+    Step 4: Handler returns the results of the query to the user. The output has a json representation of the table.
+    
+
+    ## Desired Output Display Format
+    If the query is successful and returns rows, display the rows as a markdown table.
+
+`;
+   
+    let spec = {
+        name: toolname,
+        description: description,
+       
+        schema: {
+            query: z.string(),
+            table: z.string().default(uTable),
+            sql: z.string().optional(),
+          
+        },
+        required: ['query', 'table'],
+        handler: async (params) => {
+            
+            let { table, query, sql } = params;
+            let sqlinput = (sql == null) ? ' ' : sql.replaceAll(';', ' ').replaceAll('\n', ' ').replaceAll('\r', ' ');
+            
+            let iparams = { 
+                scenario: {
+                    table: table,
+                    prompt: query,
+                    sql: sqlinput,
+                    selectcolumns: `${selectColumns2}`
+                },
+                name: `${uJob}`,
+                type: 'job'
+            };
+        
+            if (sql == null || sql.trim().length === 0) {
+                return { content: [{ type: 'text', text: 'Error: The SQL statement generated is blank. Please provide a valid natural language query that can be converted to SQL.' }] };
+            }
+            let r = await _jobSubmit(iparams);
+            return r;
+
+        }
+    };
+    return spec;
+  
+   
+}
+export default sasQueryTemplate2;