@sassoftware/sas-score-mcp-serverjs 0.4.1-1 → 0.4.1-17

package/scripts/optimize_final.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+import re
+
+# Read and replace listJobs
+with open('src/toolSet/listJobs.js', 'r') as f:
+    content = f.read()
+
+# Find and replace listJobs description - find the full description block
+pattern = r'let description = `\n  ## list-jobs.*?  `;'
+replacement = r'''let description = `
+list-jobs — enumerate SAS Viya job assets.
+
+USE when: list jobs, show jobs, browse jobs, list available jobs, next page of jobs
+DO NOT USE for: find single job (use find-job), execute job (use run-job), run jobdef (use run-jobdef), sas code (use run-sas-program)
+
+PARAMETERS
+- limit: number (default: 10) — number of jobs per page
+- start: number (default: 1) — 1-based page offset
+- where: string (default: '') — optional filter expression
+
+ROUTING RULES
+- "list jobs" → { start: 1, limit: 10 }
+- "show me 25 jobs" → { start: 1, limit: 25 }
+- "list jobs limit 50" → { start: 1, limit: 50 }
+- "next jobs" (after prior page) → { start: previousStart + previousLimit, limit: previousLimit }
+
+EXAMPLES
+- "list jobs" → { start: 1, limit: 10 }
+- "list 25 jobs" → { start: 1, limit: 25 }
+- "next jobs" → { start: 11, limit: 10 }
+
+NEGATIVE EXAMPLES (do not route here)
+- "find job abc" (use find-job)
+- "run job abc" (use run-job)
+- "list models" (use list-models)
+
+PAGINATION
+If returned length === limit, hint: next start = start + limit. Empty result with start > 1 means paged past end.
+
+ERRORS
+Surface backend error directly; never fabricate job names.
+  `;'''
+
+if re.search(pattern, content, re.DOTALL):
+    content = re.sub(pattern, replacement, content, flags=re.DOTALL)
+    with open('src/toolSet/listJobs.js', 'w') as f:
+        f.write(content)
+    print("✓ Updated listJobs.js")
+else:
+    print("✗ Pattern not found in listJobs.js")
+
+# Read and replace listJobdefs  
+with open('src/toolSet/listJobdefs.js', 'r') as f:
+    content = f.read()
+
+pattern = r'let description = `\n  ## list-jobdefs.*?  `;'
+replacement = r'''let description = `
+list-jobdefs — enumerate SAS Viya job definitions (jobdefs) assets.
+
+USE when: list jobdefs, show jobdefs, browse jobdefs, list available jobdefs, next page
+DO NOT USE for: find single jobdef (use find-jobdef), execute jobdef (use run-jobdef), find job (use find-job), sas code (use run-sas-program)
+
+PARAMETERS
+- limit: number (default: 10) — number of jobdefs per page
+- start: number (default: 1) — 1-based page offset
+- where: string (default: '') — optional filter expression
+
+ROUTING RULES
+- "list jobdefs" → { start: 1, limit: 10 }
+- "show me 25 jobdefs" → { start: 1, limit: 25 }
+- "next jobdefs" → { start: previousStart + previousLimit, limit: previousLimit }
+
+EXAMPLES
+- "list jobdefs" → { start: 1, limit: 10 }
+- "list 25 jobdefs" → { start: 1, limit: 25 }
+- "next jobdefs" → { start: 11, limit: 10 }
+
+NEGATIVE EXAMPLES (do not route here)
+- "find jobdef abc" (use find-jobdef)
+- "list jobs" (use list-jobs)
+- "run jobdef abc" (use run-jobdef)
+
+PAGINATION
+If returned length === limit, hint: next start = start + limit.
+
+ERRORS
+Surface backend error directly; never fabricate jobdef names.
+  `;'''
+
+if re.search(pattern, content, re.DOTALL):
+    content = re.sub(pattern, replacement, content, flags=re.DOTALL)
+    with open('src/toolSet/listJobdefs.js', 'w') as f:
+        f.write(content)
+    print("✓ Updated listJobdefs.js")
+else:
+    print("✗ Pattern not found in listJobdefs.js")
+
+# Read and replace runCasProgram
+with open('src/toolSet/runCasProgram.js', 'r') as f:
+    content = f.read()
+
+pattern = r'let description = `\n## run-cas-program.*?Response\n`'
+replacement = r'''let description = `
+run-cas-program — execute a CAS program on SAS Viya server.
+
+USE when: run cas program, execute cas, submit cas, run cas code, cas action
+DO NOT USE for: macros (use run-macro), sas code (use run-sas-program), jobs (use run-job/find-job), jobdefs (use run-jobdef/find-jobdef), models (use find-model)
+
+PARAMETERS
+- src: string (required) — CAS program code to execute verbatim
+- scenario: string | object (optional) — input parameters. Accepts: "x=1, y=2" or {x:1, y:2}
+
+ROUTING RULES
+- "run cas program 'action echo / code=\"xyz\"'" → { src: "action echo / code=\"xyz\"" }
+- "submit cas action echo" → { src: "action echo" }
+- "cas program with param1=10" → { src: "...", scenario: {param1: 10} }
+
+EXAMPLES
+- "run cas program 'action echo / code=\"hello\"'" → { src: "action echo / code=\"hello\"" }
+- "execute cas action simple.summary" → { src: "action simple.summary" }
+
+NEGATIVE EXAMPLES (do not route here)
+- "run sas macro" (use run-macro)
+- "submit sas code" (use run-sas-program)
+- "run job X" (use run-job)
+
+NOTES
+Sends src verbatim without validation. For SAS macros use run-macro. For arbitrary SAS code use run-sas-program.
+
+RESPONSE
+Log output, listings, tables from CAS execution. Error if execution fails.
+`'''
+
+if re.search(pattern, content, re.DOTALL):
+    content = re.sub(pattern, replacement, content, flags=re.DOTALL)
+    with open('src/toolSet/runCasProgram.js', 'w') as f:
+        f.write(content)
+    print("✓ Updated runCasProgram.js")
+else:
+    print("✗ Pattern not found in runCasProgram.js")

package/scripts/optimize_tools.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+import re
+
+# DevaScore optimization
+deva_old = '''    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.
+`;'''
+
+deva_new = '''    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 }
+    `;'''
+
+files = {
+    'src/toolSet/devaScore.js': (deva_old, deva_new),
+}
+
+for filepath, (old, new) in files.items():
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        if old in content:
+            content = content.replace(old, new)
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(content)
+            print(f"✓ Updated {filepath}")
+        else:
+            print(f"✗ Pattern not found in {filepath}")
+    except Exception as e:
+        print(f"✗ Error updating {filepath}: {e}")

package/scripts/setup-skills.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { parseArgs } from "node:util";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Recursive copy function
+function copyRecursiveSync(src, dest) {
+  const stat = fs.statSync(src);
+  
+  if (stat.isDirectory()) {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+    const files = fs.readdirSync(src);
+    files.forEach(file => {
+      copyRecursiveSync(path.join(src, file), path.join(dest, file));
+    });
+  } else {
+    fs.copyFileSync(src, dest);
+  }
+}
+
+// Get folder name from command line arguments or environment variable
+const args = parseArgs({
+  options: {
+    'skills-folder': {
+      type: 'string',
+      short: 'f',
+      description: 'Skills folder name'
+    }
+  }});
+
+let folderName = args.values['skills-folder'] || process.env.SKILLS_FOLDER_NAME;
+if (folderName == null) {
+  folderName = '.github';
+}
+folderName = folderName + '/skills';
+// If no folder name provided, show usage
+if (!folderName) {
+  console.error('Usage:');
+  console.error('  npm run setup-skills -f <folder-name>');
+  console.error('  or set SKILLS_FOLDER_NAME environment variable');
+  console.error('\nExample:');
+  console.error('  npm run setup-skills -f my-skills-folder');
+  process.exit(0);
+}
+console.error(`Setting up skills in folder: ${folderName}`);
+// Resolve paths
+const skillsSourcePath = path.join(__dirname, '../skills');
+const targetPath = path.join(process.cwd(), folderName);
+
+// Check if skills folder exists
+if (!fs.existsSync(skillsSourcePath)) {
+  console.error(`Error: Skills folder not found at ${skillsSourcePath}`);
+  process.exit(1);
+}
+
+try {
+  // Create target directory if it doesn't exist
+  if (!fs.existsSync(targetPath)) {
+    fs.mkdirSync(targetPath, { recursive: true });
+    console.error(`✓ Created folder: ${targetPath}`);
+  } else {
+    console.error(`✓ Folder already exists: ${targetPath}`);
+  }
+
+  // Copy skills folder contents to target
+  copyRecursiveSync(skillsSourcePath, targetPath);
+  console.error(`✓ Successfully copied skills to: ${targetPath}`);
+} catch (error) {
+  console.error('Error during setup:', error.message);
+  process.exit(1);
+}

package/scripts/update_descriptions.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+import re
+import os
+
+os.chdir('c:/dev/github/sas-score-mcp-serverjs')
+
+# Update runJob.js
+file_path = 'src/toolSet/runJob.js'
+with open(file_path, 'r', encoding='utf-8') as f:
+    content = f.read()
+
+new_desc = """run-job — execute a deployed SAS Viya job.
+
+USE when: run job, execute job, run with parameters
+DO NOT USE for: arbitrary SAS code (use run-sas-program), macros (use run-macro), list/find jobs
+
+PARAMETERS
+- name: string — job name (required)
+- scenario: string | object — input parameters. Accepts: "x=1, y=2" or {x:1, y:2}
+
+ROUTING RULES
+- "run job xyz" → { name: "xyz" }
+- "run job xyz with param1=10, param2=val2" → { name: "xyz", scenario: {param1:10, param2:"val2"} }
+
+EXAMPLES
+- "run job xyz" → { name: "xyz" }
+- "run job monthly_etl with month=10, year=2025" → { name: "monthly_etl", scenario: {month:10, year:2025} }
+
+NEGATIVE EXAMPLES (do not route here)
+- "run SAS code" (use run-sas-program)
+- "run macro X" (use run-macro)
+- "list jobs" (use list-jobs)
+- "find job X" (use find-job)
+
+ERRORS
+Returns log output, listings, tables from job. Error if job not found."""
+
+# Use a more flexible pattern
+pattern = r'let description = `\n## run-job.*?`;\n'
+replacement = f'let description = `\n{new_desc}\n`;\n'
+updated = re.sub(pattern, replacement, content, flags=re.DOTALL)
+
+with open(file_path, 'w', encoding='utf-8') as f:
+    f.write(updated)
+
+print(f"✓ Updated {file_path}")

package/scripts/viyatls.sh

@@ -0,0 +1,3 @@
+kubectl cp $(kubectl get pod | grep "sas-consul-server-0" | awk -F" " '{print $1}'):security/ca.crt ./ca.crt
+kubectl cp $(kubectl get pod | grep "sas-consul-server-0" | awk -F" " '{print $1}'):security/tls.crt ./tls.crt
+kubectl cp $(kubectl get pod | grep "sas-consul-server-0" | awk -F" " '{print $1}'):security/tls.key ./tls.key

package/skills/sas-find-library-smart/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: sas-find-library-smart
+description: >
+  Find a SAS Viya library (libref or caslib) with intelligent server detection. Automatically checks 
+  CAS first, then SAS if not found. Use this skill when the user needs to verify a library exists,
+  before accessing tables within it. Trigger phrases include: "find library", "does library exist",
+  "check if library", "locate library", "is there a library named", "verify library", or any request 
+  to confirm a library's availability across servers.
+---
+
+# Smart Library Lookup (Find Library)
+
+Intelligently locates a SAS Viya library by checking CAS first, then SAS if the library is not found 
+in CAS. Provides the user with clear information about library availability and location.
+
+**If the user specifies the server explicitly** (e.g., "find library Public in cas"):
+- Use the specified server: `server: "cas"` or `server: "sas"`
+- Proceed directly to finding the library
+
+**If the server is NOT specified:**
+1. **First attempt**: Check CAS (`server: "cas"`)
+2. **If not found in CAS**: Check SAS with uppercase library name (`server: "sas"`)
+3. **If not found in either**:
+   - Inform user: *"The library '<lib>' was not found in CAS or SAS servers. Please verify the library name."*
+   - Suggest: *"Would you like to list available libraries?"* (suggest `sas-score-list-libraries`)
+4. **If found**:
+   - Inform user which server contains the library: *"Found library '<lib>' in CAS"* or *"Found library '<lib>' in SAS"*
+   - Offer next steps: *"Would you like to list tables in this library?"* (suggest `sas-score-list-tables`)
+
+---
+
+## Using sas-score-find-library
+
+**When:**
+- User wants to verify a library exists
+- User needs to determine which server contains a library
+- User wants to check library availability before accessing it
+- User wants to explore available libraries (before querying)
+
+**How:**
+```
+sas-score-find-library({
+  name: "libraryname",          // required
+  server: "cas" or "sas"        // optional; determined by server check if not specified
+})
+```
+
+**Rules:**
+- Always determine the correct server first (cas → sas → neither)
+- **For SAS server: always uppercase the library name** (e.g., "public" → "PUBLIC")
+- If library name is missing, ask: *"Which library name would you like to find?"*
+- Return the server where the library was found
+- If not found in either server, clearly inform the user and offer to list available libraries
+- Do not proceed with table access until library existence is confirmed
+
+---
+
+## Smart server detection logic
+
+```
+IF server specified by user
+  → IF server is "sas"
+      → uppercase lib
+  → use that server, call sas-score-find-library
+ELSE
+  → TRY sas-score-find-library(lib, server="cas")
+    IF library found
+      → success, inform user: library found in CAS
+    ELSE
+      → uppercase lib
+      → TRY sas-score-find-library(lib.toUpperCase(), server="sas")
+        IF library found
+          → success, inform user: library found in SAS
+        ELSE
+          → inform user library not found in either server
+          → offer to list available libraries
+```
+
+---
+
+## Common patterns
+
+**Pattern 1 — Find library, server unspecified**
+> "Find library Public"
+
+1. Try CAS: `sas-score-find-library({ name: "Public", server: "cas" })`
+2. If not found, try SAS with uppercase: `sas-score-find-library({ name: "PUBLIC", server: "sas" })`
+3. If found in CAS → *"Found library 'Public' in CAS. Would you like to list tables in it?"*
+4. If found in SAS → *"Found library 'PUBLIC' in SAS. Would you like to list tables in it?"*
+5. If not found → *"The library 'Public' was not found in CAS or SAS. Would you like to list available libraries?"*
+
+**Pattern 2 — Find library with explicit server (CAS)**
+> "Find library MyData in cas"
+
+1. Skip server detection
+2. Call: `sas-score-find-library({ name: "MyData", server: "cas" })`
+3. Result → *"Found library 'MyData' in CAS"* or *"Library 'MyData' not found in CAS"*
+
+**Pattern 3 — Find library with explicit server (SAS)**
+> "Does library SASHELP exist in sas"
+
+1. Skip server detection
+2. Uppercase lib: `sas-score-find-library({ name: "SASHELP", server: "sas" })`
+3. Result → *"Found library 'SASHELP' in SAS"* or *"Library 'SASHELP' not found in SAS"*
+
+**Pattern 4 — Library not found, offer next steps**
+> "Check if library staging exists"
+
+1. Try CAS: `sas-score-find-library({ name: "staging", server: "cas" })` → not found
+2. Try SAS: `sas-score-find-library({ name: "STAGING", server: "sas" })` → not found
+3. Respond:
+   - *"The library 'staging' was not found in CAS or SAS."*
+   - *"Would you like to:"*
+     - *"List all available libraries? (use `sas-score-list-libraries`))"*
+     - *"Check a different library name?"*
+
+**Pattern 5 — Library found, follow-up action**
+> "Verify library samples exists"
+
+1. Try CAS: `sas-score-find-library({ name: "samples", server: "cas" })` → found
+2. Respond:
+   - *"Found library 'samples' in CAS."*
+   - *"Would you like to list tables in this library? (use `sas-score-list-tables`))"*
+
+---
+
+## Output presentation
+
+**When library is found:**
+```
+✓ Found library '<lib>' in <SERVER>
+
+Would you like to:
+• List tables in this library (use sas-list-tables-smart skill)
+• Read data from a specific table (use sas-read-strategy skill)
+```
+
+**When library is not found:**
+```
+✗ Library '<lib>' not found in either CAS or SAS
+
+Suggestions:
+• Check the spelling of the library name
+• List available libraries (use list-libraries tool)
+• Try a different library name
+```
+
+---
+
+## Integration with other skills
+
+- **After finding library → List tables**: Use `sas-list-tables-smart` skill to browse available tables
+- **After finding library → Read data**: Use `sas-read-strategy` skill to retrieve data from tables
+- **Library not found → Explore**: Use `sas-score-list-libraries` tool to see all available libraries

package/skills/sas-list-tables-smart/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: sas-list-tables-smart
+description: >
+  List all tables in a SAS Viya library with intelligent server detection. When the server is not
+  specified, automatically checks CAS first, then SAS if not found. Informs the user if the library
+  does not exist in either server. Use this skill when the user wants to browse or explore available
+  tables. Trigger phrases include: "list tables in", "show tables in", "what tables are in",
+  "browse tables in", "tables in library", "enumerate tables", or any request to explore data sources.
+---
+
+# Smart Data Access in SAS Library (List, Read, Query)
+
+Intelligently enumerates tables in a SAS Viya library, automatically determining the correct server
+when not explicitly specified.
+
+> **Pre-flight check**: Before listing tables, verify the library exists using the `sas-find-library-smart` skill.
+> This ensures consistent server detection across all data operations.
+
+**If the user specifies the server explicitly** (e.g., "list tables in Public in cas"):
+- Use the specified server: `server: "cas"` or `server: "sas"`
+- Proceed directly to listing tables
+
+**If the server is NOT specified:**
+1. **First attempt**: Check CAS (`server: "cas"`)
+2. **If no tables found in CAS**: Check SAS (`server: "sas"`)
+3. **If no tables found in either**:
+   - Inform user: *"The library '<lib>' was not found in CAS or SAS. Please verify the library name is correct."*
+   - Ask: *"Would you like to list available libraries?"* (suggest `sas-score-list-libraries`)
+
+---
+
+## Using sas-score-list-tables
+
+**When:**
+- User wants to browse all tables in a library
+- User wants to see what data is available
+- User wants to explore library contents before querying
+
+**How:**
+```
+sas-score-list-tables({
+  lib: "libraryname",           // required
+  server: "cas" or "sas",       // required; determined by server check
+  limit: 10,                    // optional; default 10, adjust for pagination
+  start: 1                      // optional; default 1, use for pagination
+})
+```
+
+**Rules:**
+- Always determine the correct server first (cas → sas → neither)
+- **For SAS server: always uppercase the library name** (e.g., "maps" → "MAPS")
+- If library name is missing, ask: *"Which library should I list tables from?"*
+- Default page size is 10; adjust based on user request ("show me all", "25 tables", etc.)
+- If returned table count equals the limit, suggest pagination: *"There may be more tables. Use `start: {next_offset}` to see more."*
+- If no tables are found despite library existing, report: *"No tables found in {lib} on {server} server."*
+- Return table names only; do not fetch table metadata unless explicitly requested
+
+---
+
+## Smart server detection logic
+
+```
+IF server specified by user
+  → IF server is "sas"
+      → uppercase lib
+  → use that server
+ELSE
+  → TRY sas-score-list-tables(lib, server="cas")
+    IF tables found
+      → success, return tables
+    ELSE
+      → uppercase lib
+      → TRY sas-score-list-tables(lib.toUpperCase(), server="sas")
+        IF tables found
+          → success, return tables
+        ELSE
+          → inform user library not found in either server
+```
+
+---
+
+## Common patterns
+
+**Pattern 1 — List tables, server unspecified**
+> "List tables in Public"
+
+1. Try CAS: `sas-score-list-tables({ lib: "Public", server: "cas" })`
+2. If empty, try SAS with uppercase: `sas-score-list-tables({ lib: "PUBLIC", server: "sas" })`
+3. If still empty → inform user
+
+**Pattern 2 — List tables with explicit server (SAS)**
+> "List tables in sashelp in sas"
+
+1. Skip server detection
+2. Call with uppercase lib: `sas-score-list-tables({ lib: "SASHELP", server: "sas" })`
+
+**Pattern 3 — List tables with explicit server (CAS)**
+> "List tables in Public in cas"
+
+1. No uppercase needed for CAS
+2. Call: `sas-score-list-tables({ lib: "Public", server: "cas" })`
+
+**Pattern 4 — Pagination**
+> "Show me 25 tables in Samples, then the next batch"
+
+1. First call: `sas-score-list-tables({ lib: "Samples", limit: 25, start: 1 })`
+2. Next call: `sas-score-list-tables({ lib: "Samples", limit: 25, start: 26 })`
+
+**Pattern 5 — Library not found**
+> "List tables in foo"
+
+1. Try CAS: empty
+2. Try SAS with uppercase: empty
+3. Response: *"The library 'foo' was not found in CAS or SAS. Please verify the library name."*
+
+---
+
+## Error handling
+
+| Scenario | Action |
+|---|---|
+| Library not found in either server | Inform user and ask to verify library name |
+| Empty result on first server | Automatically check second server |
+| User specifies invalid server | Return error; ask user to clarify: `"cas"` or `"sas"` |
+| Missing library name | Ask: *"Which library should I list tables from?"* |
+| Library verification needed | Use `sas-find-library-smart` skill to verify library exists first |
+