@sassoftware/sas-score-mcp-serverjs 1.0.1-32 → 1.0.1-34

package/.skills/decision-trees/table.yaml

@@ -0,0 +1,57 @@
+---
+resource: "table"
+description: "Decision tree for table operations. Use sas-score-sas-query for aggregation/query requests; otherwise use sas-score-read-table for raw rows."
+intents:
+  list:
+    parse:
+      lib: "$lib"
+    exec:
+      tool: "list-tables"
+      args:
+        lib: "$lib"
+        start: 1
+        limit: 10
+    format: "list of tables"
+  find:
+    parse:
+      lib: "$lib"
+      name: "$name"
+    exec:
+      tool: "find-table"
+      args:
+        lib: "$lib"
+        name: "$name"
+    format: "find response"
+  read:
+    parse:
+      lib: "$lib"
+      table: "$table"
+      where: "$where"
+      aggregation_requested: "$aggregation_requested" # boolean inferred from request
+      aggregation_query: "$aggregation_query"
+    verify:
+      tool: "find-table"
+      args:
+        lib: "$lib"
+        name: "$table"
+    decision:
+      - condition: "aggregation_requested == true"
+        exec:
+          tool: "sas-score-sas-query"
+          args:
+            table: "$lib.$table"
+            query: "$aggregation_query"
+      - condition: "default"
+        exec:
+          tool: "sas-score-read-table"
+          args:
+            lib: "$lib"
+            table: "$table"
+            where: "$where"
+    format: "rows or aggregated result"
+  read_and_score:
+    description: "Compose read then score (read decision chooses sas-query vs read-table)."
+    compose:
+      - step: "table.read"
+      - step: "mas.score"
+    format: "rows with appended predictions"

package/.skills/skills/README.md

@@ -66,7 +66,7 @@ Always verify resources exist before executing (except SCR which has no pre-chec
 |---|---|
 | Find library | sas-score-find-library |
 | Find table | sas-score-find-table |
-| Find model (MAS) | sas-score-find-model |
+| Find model (MAS) | sas-score-find-mas |
 | Find job | sas-score-find-job |
 | Find jobdef | sas-score-find-jobdef |
 | Read table | sas-score-read-table |

package/.skills/skills/detail-strategy/SKILL.md

@@ -14,15 +14,14 @@ If the specified resource is ambiguous, ask the user for clarification (e.g. "Ar
 
 **Model**: If user just says "model X" without specifying type, default to MAS model (this is an explicit exception to the 'never invent' rule, but it is a predefined convention in SAS).
 
-Verification vs Retrieval (simplified)
+Verification rules
+- Always verify the target resource exists using the appropriate `find-*` tool before attempting retrieval, except for SCR models (see Exceptions below).
+- For tables, determine server (CAS vs SAS) during verification; if ambiguous, ask the user for the full `lib.table` or server.
+- For models, strip suffixes such as `.mas`, `.job`, `.jobdef` or `.scr` before lookup to avoid lookup failures.
 
-- We separate the workflow into two clear, sequential phases to reduce branching and cognitive load:
-  1. Verification phase — confirm the resource exists and determine its exact type and server. Use the appropriate "find" tool for all resource types except SCR models.
-  2. Retrieval phase — after successful verification, call the detail/read tool appropriate for the identified resource type to fetch metadata or content.
-
-- Exception for SCR models: document the exception inline — SCR models may be queried directly with `sas-score-scr-info` when the user provides a specific SCR endpoint. Even when skipping verification, still validate the endpoint/URL format before calling the tool.
-
-Apply this separation consistently across MAS models, Job models, JobDef models, SCR models, and tables.
+Defaults & exceptions
+- Default model type: MAS when the user says `model X` without specifying a type.
+- If verification fails, inform the user and ask for corrected or more specific identifiers.
 
 ---
 
@@ -98,7 +97,7 @@ sas-score-mas-info({
 ```
 User: "What inputs does mas model churnRisk need?"
 
-1. Find: sas-score-find-model({ name: "churnRisk" })
+1. Find: sas-score-find-mas({ name: "churnRisk" })
 2. Get info: sas-score-mas-info({ model: "churnRisk" })
 3. Return: { inputs: [...], outputs: [...], description: "..." }
 ```
@@ -267,7 +266,7 @@ If a request fails:
 **Workflow**:
 1. Classify: MAS model detail request
 2. Verify: Find model creditScore → Found ✓
-3. Execute: `sas-score-model-info({ model: "creditScore" })`
+3. Execute: `sas-score-mas-info({ model: "creditScore" })`
 4. Return: Model inputs, outputs, and description
 
 ### Example 2: SCR Model Schema

package/.skills/skills/find-resources/SKILL.md

@@ -9,6 +9,12 @@ description: >
 
 Use this strategy to verify that a resource exists before executing any action.
 
+Verification rules
+- Use `find-*` tools to confirm resource existence; do not use `list-*` tools for verification.
+- For tables, determine server (CAS vs SAS) from the library; if unknown, try CAS first then SAS (uppercase lib for SAS).
+- For models with no explicit type, default to MAS unless the user specifies otherwise.
+- SCR models require a URL/endpoint; ask the user for the endpoint rather than attempting a find.
+
 Do **not** use list tools for verifying or finding specific resources. List tools are for discovery and exploration only, not for confirming the existence of a specific resource.
 
 ## Resource Types and Find Tools
@@ -66,7 +72,7 @@ Do **not** use list tools for verifying or finding specific resources. List tool
 
 ### 3. Find Scoring Model
 
-**Trigger**: "find model X", "find mas model X", "find job model X", "find jobdef model X",
+**Trigger**: "find model X.mas", "find mas model X", "find job model X", "find jobdef model X",
 "find scr model X", "does model X exist", "locate model X", "find job X", "does job X exist",
 "find jobdef X", "does jobdef X exist"
 
@@ -74,19 +80,19 @@ Do **not** use list tools for verifying or finding specific resources. List tool
 
 | User phrase / suffix                           | Model type | Find Tool              |
 |------------------------------------------------|------------|------------------------|
-| `find mas model X` / `X.mas` / `mas X`         | MAS        | `sas-score-find-model` |
+| `find mas model X` / `X.mas` / `mas X`         | MAS        | `sas-score-find-mas` |
 | `find job model X` / `X.job` / `job X`         | Job        | `sas-score-find-job`   |
 | `find jobdef model X` / `X.jobdef` / `jobdef X`| JobDef     | `sas-score-find-jobdef`|
 | `find scr model X` / `X.scr` / `scr X`         | SCR        | *(no tool — ask for URL)*|
-| `find model X` (no type)                       | MAS (default) | `sas-score-find-model` |
+
 
 #### MAS Model
 
-**Tool**: `sas-score-find-model`
+**Tool**: `sas-score-find-mas`
 
 **Logic**: Strip `.mas` suffix if present, use base name.
 ```
-sas-score-find-model({ name: "<model>" })
+sas-score-find-mas({ name: "<model>" })
 ```
 
 #### Job Model
@@ -123,11 +129,11 @@ If user says "find model X" without a type qualifier, infer the type from the su
 
 | Pattern                              | Type    | Find Tool               |
 |--------------------------------------|---------|-------------------------|
-| `X.mas` / `mas model X` / `mas X`    | MAS     | `sas-score-find-model`  |
+| `X.mas` / `mas model X` / `mas X`    | MAS     | `sas-score-find-mas`  |
 | `X.job` / `job model X` / `job X`    | Job     | `sas-score-find-job`    |
 | `X.jobdef` / `jobdef model X` / `jobdef X` | JobDef | `sas-score-find-jobdef` |
 | `X.scr` / `scr model X` / `scr X`    | SCR     | Skip (no find tool)     |
-| (none)                               | Default to MAS | `sas-score-find-model` |
+| (none)                               | Default to MAS | `sas-score-find-mas` |
 
 ---
 

package/.skills/skills/list-resource/SKILL.md

@@ -8,8 +8,15 @@ description: >
 # Unified Resource Listing Strategy
 
 
+
 Use this strategy to list available resources (libraries, tables, models, jobs, jobdefs).
 
+Listing rules
+- Use `list-*` tools for discovery and browsing only; do not use `list-*` to verify a specific resource's existence.
+- If the user specifies a server, list from that server; otherwise list from all servers when appropriate.
+- When a library is ambiguous for table listing, attempt both CAS and SAS and label results by server, or ask the user to clarify.
+
+
 ## Resource Type to Tool Mapping
 
 | Resource Type        | Aliases / Adjective Form               | List Tool                  |

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

@@ -8,6 +8,11 @@ description: >
 
 Use this strategy when the user requests to read, fetch, or query data from a table.
 
+Rules summary
+- Verification rules: verify the table exists using `find-*` and determine the server (CAS vs SAS); ask the user if ambiguous. Do not assume a default server unless explicitly instructed.
+- Execution rules: choose `sas-score-read-table` for raw row reads and `sas-score-sas-query` for aggregations/joins/groupings; if intent is ambiguous, ask the user.
+- Error handling: surface clear guidance when table or column names are missing or misspelled.
+
 ## Prerequisites
 
 Before reading:
@@ -100,7 +105,7 @@ If the user's intent is ambiguous or mixes aggregation and raw reads, ask the us
 
 ## Table Name Format
 
-- **CAS tables**: `Caslib.table` or `Public.customers` (lowercase caslib, mixed case table)
+- **CAS tables**: `Caslib.table` or `Public.customers` (mixed case table)
 - **SAS tables**: `LIBREF.table` or `SASHELP.cars` (uppercase libref, case-insensitive table)
 
 ---

package/.skills/skills/request-routing/SKILL.md

@@ -1,108 +1,82 @@
 ---
 name: request-routing
 description: >
-  Universal routing strategy for all SAS Viya requests. Every request follows the same three-step workflow.
+  Canonical, compact request-routing strategy for SAS Viya requests.
 ---
 
-# Universal Request Routing Strategy
-
-All SAS Viya requests follow this three-step workflow:
-
-## Step 1: Verify Resources Exist
-
-Before executing any action, verify that the target resources exist.
-
-| Resource Type | Find Tool | Notes |
-|---|---|---|
-| Library | `sas-score-find-library` | For tables, if server is not specified (cas or sas), determine server here. Other resource types do not require server specification. |
-| Table | `sas-score-find-table` | Requires library name and server. |
-| MAS Model | `sas-score-find-model` | No server selection. |
-| Job | `sas-score-find-job` | No server selection. |
-| JobDef | `sas-score-find-jobdef` | No server selection. |
-| SCR Model | Skip verification | SCR models do not require pre-verification. |
-
-**Rule**: Always verify before executing. Exception: SCR models can be scored directly.
-
----
-
-## Step 2: Execute the Request
-
-Once resources are verified to exist, select the appropriate execution tool:
-
-| Request Type | Tool | Input |
-|---|---|---|
-| Read table rows | `sas-score-read-table` | lib, table, server (from Step 1) |
-| Query table (aggregation) | `sas-score-sas-query` | lib.table, SQL query |
-| Score with MAS model / `mas model X` | `sas-score-mas-score` | model name, scenario data |
-| Score with Job model / `job model X` | `sas-score-run-job` | job name, scenario parameters |
-| Score with JobDef model / `jobdef model X` | `sas-score-run-jobdef` | jobdef name, scenario parameters |
-| Score with SCR model / `scr model X` | `sas-score-scr-score` | SCR URL, scenario data |
-| Describe MAS model / `mas model X` | `sas-score-mas-info` | model name |
-| Describe Job model / `job model X` | `sas-score-job-info` | job name |
-| Describe JobDef model / `jobdef model X` | `sas-score-jobdef-info` | jobdef name |
-| Describe SCR model / `scr model X` | `sas-score-scr-info` | SCR URL |
-| Describe table | `sas-score-table-info` | lib, table, server |
-
----
-
-## Step 3: Merge Results
-
-Combine verification and execution results:
-
-- For **read/query**: Return rows as-is.
-- For **scoring**: Merge predictions with input scenario data.
-- For **jobs/jobdefs**: Return execution results (tables, logs).
-
+# Request Routing — Canonical SKILL
+
+Purpose: single source-of-truth for routing SAS Viya actions (read, query, score, describe, list).
+
+Quick workflow
+- Verify — confirm resources exist (use find-*).
+- Execute — run the mapped execution tool (read, query, score, describe, list).
+- Format — return results and append a short Strategy Summary.
+
+**Important Reminder**: If the category is "Find resource" do not use the list-* rules below, use the specific find-* tool for that resource type. The list-* tools are for discovery when the user does not have a specific resource in mind.
+
+Classification
+| Category | Triggers | Primary Action | Primary Tool(s) |
+|---|---|---|---|
+| Find resource | "find", "does X exist", "locate", "verify" | Verify resource | `sas-score-find-library`, `sas-score-find-table`, `sas-score-find-mas`, `sas-score-find-job`, `sas-score-find-jobdef` |
+| Read / Query | "read", "show rows", "how many", "count", "average", "query" | Read / aggregate | `sas-score-read-table`, `sas-score-sas-query` |
+| Score | "score", "predict", "run model" | Score inputs | `sas-score-mas-score`, `sas-score-run-job`, `sas-score-run-jobdef`, `sas-score-scr-score` |
+| List / Discover | "list", "show all", "browse" | List resources | `list-*` tools (e.g., `list-mas`, `list-jobs`) |
+| Describe | "describe", "what inputs", "metadata" | Return metadata | `sas-score-*-info` (mas/job/jobdef/scr), `sas-score-table-info` |
+
+Verification rules
+- Always verify resources using the appropriate `find-*` tool before executing actions
+
+Execution rules
+- Execute only after verification; choose the execution tool per the Execute mapping section.
+- Scoring flows:
+  - Inline scenario: verify model → call scoring tool.
+  - Table rows: verify model + table → read rows → map columns to model inputs → score → merge predictions with rows.
+- Read/query flows:
+  - Use `sas-score-sas-query` for aggregations and groupings.
+  - Use `sas-score-read-table` for row reads.
+  - When mapping between table columns and model inputs is ambiguous, ask the user for explicit mapping.
+
+Defaults & exceptions
+- Default model type: MAS unless the user specifies otherwise.
+- Skip `find-*` verification for SCR models; SCR endpoints may be scored directly.
+- If server determination is ambiguous, prompt the user for clarification.
+
+Execute mapping (concise)
+- Read rows: `sas-score-read-table` (lib, table, server)
+- Aggregation/query: `sas-score-sas-query` (lib.table, query)
+- MAS scoring: `sas-score-mas-score` (mas, scenario)
+- Job scoring: `sas-score-run-job` (job, scenario)
+- JobDef scoring: `sas-score-run-jobdef` (jobdef, scenario)
+- SCR scoring: `sas-score-scr-score` (url, scenario)
+- Describe: `sas-score-*-info`, `sas-score-table-info`
+
+Combined Read + Score (short)
+1. Verify: find table (server) and find the model (mas,job,jobdef,scr). If table/model not found, ask user to clarify resource and server.  
+2. Read: fetch rows (read-table or sas-query).
+3. Map: ensure table columns match model inputs; ask for mapping if needed.
+4. Score: call the appropriate scoring tool.
+5. Merge: attach predictions to rows and return.
+
+Strategy Summary (append to responses)
 ---
-
-
-## Special Case: Read + Score (Combined Workflow)
-
-When the user requests scoring records from a table, follow these sub-workflows in order:
-
-1. **Verify**
-  - Find the table (determine server as described above)
-  - Find the model
-2. **Read**
-  - Fetch rows from the table using `sas-score-read-table` or `sas-score-sas-query`
-3. **Map**
-  - Check if table columns match model input variables
-  - If not, ask user for mapping
-4. **Score**
-  - Score each row using `sas-score-mas-score` (for MAS) or `sas-score-scr-score` (for SCR)
-5. **Merge**
-  - Combine predictions with original rows
-
----
-
-## Error Handling
-
-| Error | Action |
-|---|---|
-| Resource not found | Ask user to verify name and server (for tables). |
-| Column/input mismatch | Ask user to map table columns to model inputs. |
-| Empty result | Ask whether to adjust filter/criteria. |
-
+**Strategy Summary:**
+- Classification: [Find / Read / Score / List / Describe]
+- Verification: [Resources verified / skipped]
+- Tool(s): [Primary tool(s) invoked]
+- Decision: [Server chosen, model type, mapping]
+- Next steps: [Follow-ups or clarifications]
 ---
 
-## Examples
-
-### Example 1: Read a table
-**Request**: "read customers in Public"
-1. Find library Public → Verified (CAS)
-2. Read table customers in Public (CAS)
-3. Return rows
+Error handling (short)
+- Resource not found → ask for exact resource name and server (for tables).
+- Column/input mismatch → request mapping from user.
+- Empty result → ask to relax filters or confirm criteria.
+- Execution error → return tool error verbatim.
 
-### Example 2: Score with inline scenario
-**Request**: "score a=1, b=2 with model simplejob.job"
-1. Find job simplejob → Verified
-2. Run simplejob with scenario {a: 1, b: 2}
-3. Return result
+Examples (minimal)
+- Read: "read customers in Public" → find Public (CAS) → read-table → return rows.
+- Score inline: "score a=1,b=2 with job simplejob" → find job → run-job → return merged result.
+- Score table: "score Public.customers with model risk" → find table (CAS) & model (MAS) → read rows → score → return merged.
 
-### Example 3: Score records from table
-**Request**: "score records from Public.customers with model risk_model.mas"
-1. Find table customers in Public → Verified (CAS)
-2. Find model risk_model → Verified (MAS)
-3. Read rows from Public.customers
-4. Score each row with risk_model
-5. Return merged predictions + original data
+Notes: Keep this SKILL as the canonical, compact router; agent wrappers should be short and reference this document for details and examples.

package/.skills/skills/score-strategy/SKILL.md

@@ -11,6 +11,11 @@ description: >
 
 Use this strategy when the user requests model scoring, predictions, or running jobs/jobdefs.
 
+Rules summary
+- Verification rules: always verify model existence with `find-*` (except SCR); for table scoring verify both model and table and determine server.
+- Execution rules: inline scenarios → verify model → score; table rows → verify table → read → score (batch). Ask for column-to-input mapping when needed.
+- Defaults & exceptions: default model type to MAS when unspecified; skip pre-verification for SCR models and require a valid SCR endpoint.
+
 ## Prerequisites
 
 1. Verify the model/job exists using find-resources skill

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sassoftware/sas-score-mcp-serverjs",
-  "version": "1.0.1-32",
+  "version": "1.0.1-34",
   "description": "A mcp server for SAS Viya",
   "author": "Deva Kumar <deva.kumar@sas.com>",
   "license": "Apache-2.0",

package/scripts/plot_msrp_usa.py

@@ -1,49 +1,49 @@
-import matplotlib
-matplotlib.use('Agg')
-import matplotlib.pyplot as plt
-from pathlib import Path
-
-data = [
-    ("Cadillac", 50474.375),
-    ("Hummer", 49995.0),
-    ("Lincoln", 42875.555556),
-    ("Buick", 30537.777778),
-    ("GMC", 29560.5),
-    ("Mercury", 27972.777778),
-    ("Chrysler", 27252.0),
-    ("Chevrolet", 26587.037037),
-    ("Dodge", 26253.846154),
-    ("Jeep", 24518.333333),
-    ("Pontiac", 24156.363636),
-    ("Ford", 24015.869565),
-    ("Oldsmobile", 23763.333333),
-    ("Saturn", 17234.375),
-]
-
-# Sort by value descending
-data.sort(key=lambda x: x[1], reverse=True)
-makes = [d[0] for d in data]
-values = [d[1] for d in data]
-
-out_dir = Path('outputs')
-out_dir.mkdir(parents=True, exist_ok=True)
-out_file = out_dir / 'make_avg_msrp_usa.png'
-
-plt.figure(figsize=(12, 6))
-bars = plt.bar(makes, values, color='tab:blue')
-plt.title('Average MSRP by Make (Origin = USA)')
-plt.ylabel('Average MSRP')
-plt.xticks(rotation=45, ha='right')
-plt.tight_layout()
-
-# Annotate bars
-for bar in bars:
-    height = bar.get_height()
-    plt.annotate(f'{height:,.0f}',
-                 xy=(bar.get_x() + bar.get_width() / 2, height),
-                 xytext=(0, 3),
-                 textcoords='offset points',
-                 ha='center', va='bottom', fontsize=8)
-
-plt.savefig(out_file)
-print(f'Plot saved to {out_file}')
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+from pathlib import Path
+
+data = [
+    ("Cadillac", 50474.375),
+    ("Hummer", 49995.0),
+    ("Lincoln", 42875.555556),
+    ("Buick", 30537.777778),
+    ("GMC", 29560.5),
+    ("Mercury", 27972.777778),
+    ("Chrysler", 27252.0),
+    ("Chevrolet", 26587.037037),
+    ("Dodge", 26253.846154),
+    ("Jeep", 24518.333333),
+    ("Pontiac", 24156.363636),
+    ("Ford", 24015.869565),
+    ("Oldsmobile", 23763.333333),
+    ("Saturn", 17234.375),
+]
+
+# Sort by value descending
+data.sort(key=lambda x: x[1], reverse=True)
+makes = [d[0] for d in data]
+values = [d[1] for d in data]
+
+out_dir = Path('outputs')
+out_dir.mkdir(parents=True, exist_ok=True)
+out_file = out_dir / 'make_avg_msrp_usa.png'
+
+plt.figure(figsize=(12, 6))
+bars = plt.bar(makes, values, color='tab:blue')
+plt.title('Average MSRP by Make (Origin = USA)')
+plt.ylabel('Average MSRP')
+plt.xticks(rotation=45, ha='right')
+plt.tight_layout()
+
+# Annotate bars
+for bar in bars:
+    height = bar.get_height()
+    plt.annotate(f'{height:,.0f}',
+                 xy=(bar.get_x() + bar.get_width() / 2, height),
+                 xytext=(0, 3),
+                 textcoords='offset points',
+                 ha='center', va='bottom', fontsize=8)
+
+plt.savefig(out_file)
+print(f'Plot saved to {out_file}')

package/src/toolHelpers/_findMas.js

@@ -1,12 +1,12 @@
-/*
- * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import _listMas from './_listMas.js';  
-async function _findMas(params) {
-    let r = await _listMas(params);
-    console.log ("findMas result:" , r);
-    return r;
-}
+/*
+ * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import _listMas from './_listMas.js';  
+async function _findMas(params) {
+    let r = await _listMas(params);
+    console.log ("findMas result:" , r);
+    return r;
+}
 export default _findMas;

package/src/toolHelpers/_findScr.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright © 2025, SAS Institute Inc., Cary, NC, USA.  All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import axios from 'axios';
+
+async function _findScr(params) {
+  let {url} = params;
+  let config = {
+    method: 'HEAD',
+    url: url + '/apiMeta/api',
+    headers: {
+      'Accept': 'application/json'
+    }
+  }
+  try {
+    console.error('[Note] Config:', config);
+    let response = await axios(config);
+    console.error('[Note] Response status:', response.status);
+    if (response.status !== 200) {
+      return {isError: true, content: [{ type: 'text', text: `SCR model ${url} not found` }]};
+    } else if (response.status === 200) {
+      return { content: [{ type: 'text', text: `Model ${url} is available` }]};
+    }
+  }
+  catch (error) {
+    return {isError: true,content: [{ type: 'text', text: JSON.stringify(error) }]};  
+  }
+}
+export default _findScr;

package/src/toolSet/devaScore.js

@@ -5,12 +5,12 @@
 import { z } from 'zod';
 
 function devaScore(_appContext) {
-
+let brand = _appContext.brand + '-';
     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
+DO NOT USE for: model scoring (use ${brand}model-score), statistical calculations, data lookup
 
 PARAMETERS
 - a: number (required) — first input value
@@ -30,9 +30,9 @@ EXAMPLES
 - "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)
+- "Score this customer with credit model" (use ${brand}model-score)
+- "Calculate the mean of these values" (use ${brand}run-sas-program or ${brand}sas-query)
+- "Statistical analysis of numbers" (use ${brand}sas-query)
 
 RESPONSE
 Returns { score: (a + b) * 42 }

package/src/toolSet/findJob.js

@@ -11,19 +11,22 @@ function findJob(_appContext) {
 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)
+DO NOT USE for: list jobs (use ${_appContext.brand}-list-jobs), run job (use ${_appContext.brand}-run-job), execute jobdef (use ${_appContext.brand}-run-jobdef), find lib/table/model (use respective tools)
 
 PARAMETERS
 - name: string (required) — job name to locate; if multiple supplied, use first
 
+Naming Rules: 
+- If user provides name with "job" suffix ".job", strip the suffix (e.g., "cars_job_v4.job"), and look for "cars_job_v4".
+
 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
+- "find all jobs / list jobs" → use ${_appContext.brand}-list-jobs instead
+- "run job <name>" → use ${_appContext.brand}-run-job instead
 
 EXAMPLES
 - "find job cars_job_v4" → { name: "cars_job_v4" }
@@ -31,9 +34,9 @@ EXAMPLES
 - "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)
+- "list jobs" (use ${_appContext.brand}-list-jobs)
+- "run job cars_job_v4" (use ${_appContext.brand}-run-job)
+- "execute jobdef cars_job_v4" (use ${_appContext.brand}-run-jobdef)
 
 ERRORS
 Returns { jobs: [] } if not found; { jobs: [name, ...] } if found. Never hallucinate job names.