@sassoftware/sas-score-mcp-serverjs 0.3.29-0 → 0.4.1-1

package/src/toolSet/runMacro.js

@@ -9,43 +9,41 @@ import _submitCode from '../toolHelpers/_submitCode.js';
 
 function runMacro(_appContext) {
   let description = `
-## run-macro
+run-macro — submit and execute a SAS macro on SAS Viya server.
 
-Submit and execute a SAS macro on a SAS Viya server by generating and sending SAS code.
+USE when: run macro, execute macro with parameters
+DO NOT USE for: arbitrary SAS code (use run-sas-program), jobs, jobdefs
 
-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.
+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;"
 
-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.
+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;" }
 
-Output
-- Returns the response produced by \`_submitCode\`, typically including ods, log, list of tables created by the macro
+EXAMPLES
+- "run macro abc" → { macro: "abc", scenario: "" }
+- "run macro summarize with x=1, y=2" → { macro: "summarize", scenario: "x=1, y=2" }
 
-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.
+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)
 
-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)
-`;
+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',
-    aliases: ['runMacro','run macro','run_macro'],
     description: description,
     
-     schema: {
+     inputSchema: z.object({
       macro: z.string(),
       scenario: z.string()
-    },
-    required: ['macro'],
+    }),
     handler: async (params) => {
       const scenarioRaw = (params.scenario || '').trim();
       let setup = '';
@@ -80,3 +78,4 @@ Examples
 }
 
 export default runMacro;
+

package/src/toolSet/runProgram.js

@@ -8,101 +8,52 @@ import _submitCode from '../toolHelpers/_submitCode.js';
 
 function runProgram(_appContext) {
   let description = `
-## run-sas-program — execute SAS code or programs on SAS Viya server
+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"
+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)
 
-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
+PARAMETERS
+- src: string — SAS code or .sas filename (required)
+- folder: string (default: '') — server folder path for .sas files
+- scenario: string | object — parameter values. Accepts: "x=1, y=2" or {x:1, y:2}
+- output: string (default: '') — table name to return (case-sensitive)
+- limit: number (default: 100) — max rows from output
 
-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)
+ROUTING RULES
 - "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 }
+- "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 }
 
-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)
+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 }
 
-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
+NEGATIVE EXAMPLES (do not route here)
+- "run macro X" (use run-macro)
+- "run job X" (use run-job)
+- "run jobdef X" (use run-jobdef)
+- "SQL query" (use sas-query)
+- "read table" (use read-table)
 
-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
-`;
+ERRORS
+Returns log, ods, tables array, data (if output specified). Error if execution fails.
+  `;
 
   let spec = {
-    name: 'run-sas-program',
-    aliases: ['Program','run program'],
+    name: 'run-program',
     description: description,
-    schema: {
+    inputSchema: z.object({
       src: z.string(),
-      scenario: z.any().default(''),
-      output: z.string().default(''),
-      folder: z.string().default(''),
-      limit: z.number().default(100)
-    },
+      scenario: z.any(),
+      output: z.string(),
+      folder: z.string(),
+      limit: z.number()
+    }),
   // 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
@@ -143,3 +94,4 @@ Related Tools
 }
 
 export default runProgram;
+

package/src/toolSet/sasQuery.js

@@ -5,99 +5,50 @@
 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.
+sas-query — convert natural language questions into SQL queries and execute them.
 
-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')
+USE when: how many/count/total/average by, aggregated analytics, complex filtering, statistical summaries
+DO NOT USE for: raw reads without filtering (use read-table), table structure (use table-info), SAS programs (use run-sas-program), jobs/jobdefs
 
-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
+PARAMETERS
+- table: string — table in lib.table format (required), e.g. "Public.cars" or "sashelp.class"
+- query: string — natural language question (required)
+- sql: string — pre-generated SQL SELECT (optional, LLM generates)
+- job: string (default: 'program') — job name to execute
 
-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)
+ROUTING RULES
+- "how many cars by make in sashelp.cars" → { table: "sashelp.cars", query: "how many cars by make", sql: "SELECT make, COUNT(*) FROM sashelp.cars GROUP BY make" }
+- "average salary by department in Public.employees" → { table: "Public.employees", query: "average salary by department", sql: "SELECT department, AVG(salary) FROM Public.employees GROUP BY department" }
 
-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
+- "how many cars by make in sashelp.cars" → { table: "sashelp.cars", query: "how many cars by make", sql: "SELECT make, COUNT(*) FROM sashelp.cars GROUP BY make" }
+- "total sales by region from mylib.sales" → { table: "mylib.sales", query: "total sales by region", sql: "SELECT region, SUM(amount) FROM mylib.sales GROUP BY region" }
 
-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 (do not route here)
+- "read table cars" (use read-table)
+- "show 10 rows" (use read-table)
+- "table structure" (use table-info)
+- "run SAS code" (use run-sas-program)
+- "run job/macro" (use run-job/run-macro)
 
-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
-`;
+ERRORS
+Returns rows array, columns metadata, log. Returns error if SQL invalid or table not found.
+  `;
 
 
     let spec = {
-        name: 'sas-query',
-        aliases: ['sasQuery','sas query','sas_query'],
-        description: description,
-        schema: {
+    name: 'sas-query',
+    description: description,
+        inputSchema: z.object({
             query: z.string(),
             table: z.string(),
-            sql: z.string().optional(),
-            job: z.string().default('program')
-        },
-        required: ['query', 'table'],
-        handler: async (params) => {
+            sql: z.string(),
+            job: z.string()
+        }),
+    handler: async (params) => {
             let {table,query, sql, job, _appContext} = params;
             let sqlinput = (sql == null) ? ' ' : sql.replaceAll(';', ' ').replaceAll('\n', ' ').replaceAll('\r', ' ');
             
@@ -124,3 +75,4 @@ Related Tools
     return spec;
 }
 export default sasQuery;
+

package/src/toolSet/sasQueryTemplate.js

@@ -108,13 +108,12 @@ async function sasQueryTemplate(uparams) {
         name: toolname,
         description: description,
        
-        schema: {
+        inputSchema: z.object({
             query: z.string(),
             table: z.string().default(uTable),
-            sql: z.string().optional()
-        },
-        required: ['query', 'table'],
-        handler: async (params) => {
+            sql: z.string()
+        }),
+    handler: async (params) => {
             
           
             let { table, query, sql, _appContext} = params;

package/src/toolSet/sasQueryTemplate2.js

@@ -102,14 +102,13 @@ async function sasQueryTemplate2(uparams) {
         name: toolname,
         description: description,
        
-        schema: {
+        inputSchema: z.object({
             query: z.string(),
             table: z.string().default(uTable),
-            sql: z.string().optional(),
+            sql: z.string(),
           
-        },
-        required: ['query', 'table'],
-        handler: async (params) => {
+        }),
+    handler: async (params) => {
             
             let { table, query, sql } = params;
             let sqlinput = (sql == null) ? ' ' : sql.replaceAll(';', ' ').replaceAll('\n', ' ').replaceAll('\r', ' ');

package/src/toolSet/scrInfo.js

@@ -15,7 +15,7 @@ Purpose
 Return the input/output schema and metadata for an SCR (Score Code Runtime) model.
 
 Inputs
-- name (string): The SCR model identifier. 
+- url (string): The SCR model identifier. 
 What it returns
 - A JSON object describing the model's interface, typically including:
   - Input variables (names, types, required/optional)
@@ -23,7 +23,6 @@ What it returns
   
 
 Usage notes
-- If no local mapping exists and \`name\` looks like a URL, the tool will attempt to fetch the schema from that URL.
 - Ensure network connectivity and credentials for the remote SCR service when needed.
 - Use scr-score to score data after inspecting the schema.
 
@@ -34,12 +33,10 @@ Examples
 
   let spec = {
     name: 'scr-info',
-    aliases: ['scrInfo','scr info','scr_info'],
     description: description,
-    schema: {
-      name: z.string(),
-    },
-    required: ['name'],
+    inputSchema: z.object({
+      url: z.string(),
+    }),
     handler: async (params) => {
       let {url, _appContext} = params;
       if (url === null) {

package/src/toolSet/scrScore.js

@@ -36,13 +36,11 @@ Examples
 
   let spec = {
     name: 'scr-score',
-    aliases: ['scrScore','scr score','scr_score'],
     description: description,
-    schema: {
+    inputSchema: z.object({
       url: z.string(),
       scenario: z.any()
-    },
-    required: ['url'],
+    }),
     handler: async (params) => {
       let {url, scenario,_appContext} = params;
   

package/src/toolSet/searchAssets.js

@@ -30,16 +30,15 @@ function searchAssets(_appContext) {
 `;
 
   let specs = {
-    name: 'searchAssets',
+    name: 'search-assets',
     description: description,
-    schema: {
+    inputSchema: z.object({
       searchstring: z.string(),
       assetType: z.string(),
-      start: z.number().default(0),
-      limit: z.number().default(10),
+      start: z.number(),
+      limit: z.number()
 
-    },
-    required: ['assetType'],
+    }),
     handler: async (params) => {
       log('searchAssets params', params);
       return await _catalogSearch(params, 'search');

package/src/toolSet/setContext.js

@@ -7,71 +7,43 @@ import {z} from 'zod';
 
 function setContext(_appContext) {
     let description = `
-## set-context — set the CAS and SAS server contexts for subsequent tool calls
+set-context — set the CAS and SAS server contexts for subsequent tool calls.
 
-LLM Invocation Guidance (When to use)
-Use THIS tool when:
-- User wants to switch to a different CAS server: "Use the finance-cas-server"
-- User wants to change the compute context: "Switch to 'SAS Studio Compute Context'"
-- User wants to check current context: "What context am I using?"
-- User wants to set both: "Use finance-cas-server for CAS and my-compute for SAS"
+USE when: switch to CAS server, change compute context, check current context, set both
+DO NOT USE for: get variables (use get-env), read data (use read-table), run programs (use run-sas-program)
 
-Do NOT use this tool for:
-- Retrieving variable values (use get-env)
-- Reading table data (use read-table)
-- Running programs or queries (use run-sas-program or sas-query)
-- Listing available servers or contexts (no tool for this; would require backend support)
+PARAMETERS
+- cas: string — CAS server name (optional), e.g. 'cas-shared-default', 'finance-cas-server'
+- sas: string — SAS compute context (optional), e.g. 'SAS Studio Compute Context', 'batch-compute'
 
-Purpose
-Set the active CAS server and/or SAS compute context for all subsequent tool calls in this session. This allows switching between different server environments. If neither parameter is provided, the tool returns the current context values.
+ROUTING RULES
+- "use finance-cas-server" → { cas: "finance-cas-server" }
+- "switch to SAS Studio Compute Context" → { sas: "SAS Studio Compute Context" }
+- "use finance-cas for CAS and batch-compute for SAS" → { cas: "finance-cas", sas: "batch-compute" }
+- "what context am I using" → { } (no params, returns current)
 
-Parameters
-- cas (string, optional): The name of the CAS server to use for subsequent CAS operations. Examples: 'cas-shared-default', 'finance-cas-server', 'analytics-cas'
-- sas (string, optional): The name of the SAS compute context to use for subsequent SAS operations. Examples: 'SAS Studio Compute Context', 'my-compute', 'batch-compute'
+EXAMPLES
+- "use finance-cas-server" → { cas: "finance-cas-server" }
+- "switch to batch-compute" → { sas: "batch-compute" }
+- "what's my current context" → { }
 
-Response Contract
-Returns a JSON object containing:
-- cas: The current/new CAS server name (string or null)
-- sas: The current/new SAS compute context name (string or null)
-- If no parameters provided, returns the current context values
-- If parameters provided, updates and returns the new context values
-- On error: error message if context cannot be set (e.g., invalid server name)
+NEGATIVE EXAMPLES (do not route here)
+- "read table cars" (use read-table)
+- "what's the value of X" (use get-env)
+- "run program" (use run-sas-program)
 
-Disambiguation & Clarification
-- If user says "switch servers" without specifying which: ask "Which server would you like to use: CAS, SAS, or both?"
-- If user provides a server name that may not exist: proceed with setting it (the backend will validate)
-- If user says "reset context": ask "Should I reset the CAS context, SAS context, or both?"
-- If user only says "context": ask "Would you like to check the current context or set a new one?"
-
-Examples (→ mapped params)
-- "Use the finance-cas-server" → { cas: "finance-cas-server" }
-- "Switch to SAS Studio Compute Context" → { sas: "SAS Studio Compute Context" }
-- "Set CAS to prod-cas and SAS to batch-compute" → { cas: "prod-cas", sas: "batch-compute" }
-- "What's my current context?" → { } (no parameters returns current context)
-- "Show me the active CAS server" → { } (no parameters returns current context)
-
-Negative Examples (should NOT call set-context)
-- "Read 10 rows from the customers table" (use read-table instead)
-- "What's the value of myVariable?" (use get-env instead)
-- "Run this SAS program" (use run-sas-program instead)
-
-Related Tools
-- get-env — to retrieve individual environment variable values
-- read-table — to read data using the current context
-- run-sas-program — to execute SAS programs in the current context
-- sas-query — to execute SQL queries in the current context
-`;
+ERRORS
+Returns current or updated context values {cas, sas}. Error if server not found or invalid name.
+  `;
   
     let spec = {
-        name: 'set-context',
-        aliases: ['setContext','set context','set_context'],
-        description: description,
-        schema: {
-            cas: z.string().optional(),
-            sas: z.string().optional()
-        },
-       
-        handler: async (params) => {
+    name: 'set-context',
+    description: description,
+        inputSchema: z.object({
+            cas: z.string(),
+            sas: z.string()
+        }),
+    handler: async (params) => {
             
             let {cas, sas} = params;
             if (typeof cas === 'string' && cas.trim().length > 0) {
@@ -90,3 +62,4 @@ Related Tools
     return spec;
 }
 export default setContext;
+

package/src/toolSet/superstat.js

@@ -33,11 +33,10 @@ function superstat(_appContext) {
   let spec = {
     name: 'superstat',
     description: desc,
-    schema: {
+    inputSchema: z.object({
       a: z.number(),
       b: z.number()
-    },
-    required: ['a', 'b'],
+    }),
     handler: async (params) => {
       let src = `
           ods html style=barrettsblue;