@robinmordasiewicz/f5xc-xcsh 1.0.90-2601021717 → 1.0.90-2601022257

package/completions/_xcsh

@@ -44,7 +44,7 @@ _xcsh() {
             'data_intelligence:Data Intelligence API'
             'ddos:Volumetric attack mitigation and traffic scrubbing.'
             'dns:Zones, record types, and load balancing.'
-            'generative_ai:AI assistant queries and feedback collection.'
+            'generative_ai:AI assistant queries and feedback'
             'login:Authentication and session management'
             'managed_kubernetes:Cluster RBAC, pod security, and container registries.'
             'marketplace:Add-on services, connectors, and TPM policies.'
@@ -113,9 +113,6 @@ _xcsh() {
             'ddos-protect:Alias for ddos'
             'dns-zone:Alias for dns'
             'zones:Alias for dns'
-            'ai:Alias for generative_ai'
-            'genai:Alias for generative_ai'
-            'assistant:Alias for generative_ai'
             'mk8s:Alias for managed_kubernetes'
             'appstack:Alias for managed_kubernetes'
             'k8s-mgmt:Alias for managed_kubernetes'
@@ -193,6 +190,9 @@ _xcsh() {
         (completion)
             _values 'command' 'bash:Generate bash completion script' 'zsh:Generate zsh completion script' 'fish:Generate fish completion script'
             ;;
+        (generative_ai)
+            _values 'command' 'query:Query the AI assistant' 'chat:Interactive AI chat mode' 'feedback:Submit feedback for AI responses' 'eval:RBAC testing mode commands'
+            ;;
         (login)
             _values 'command' 'banner:Display xcsh banner with logo' 'profile:Manage saved connection profiles' 'context:Manage default namespace context'
             ;;

package/completions/xcsh.bash

@@ -6,7 +6,7 @@ _xcsh_completions() {
   local cur prev words cword
   _init_completion || return
 
-  local commands="admin_console_and_ui api authentication bigip billing_and_usage blindfold bot_and_threat_defense cdn ce_management certificates cloud_infrastructure cloudstatus completion container_services data_and_privacy_security data_intelligence ddos dns generative_ai login managed_kubernetes marketplace network network_security nginx_one object_storage observability rate_limiting secops_and_incident_response service_mesh shape sites statistics support telemetry_and_insights tenant_and_identity threat_campaign users virtual vpm_and_node_management waf console-ui ui-assets static-components apisec api-discovery authn oidc sso f5-bigip irule ltm billing-usage quotas usage-tracking bf encrypt secrets threat-defense tpm shape-bot cache content ce-mgmt edge-management ce-lifecycle cert certs ssl tls cloud infra provider vk8s containers workloads data-privacy pii sensitive-data lma di intelligence insights dos ddos-protect dns-zone zones ai genai assistant mk8s appstack k8s-mgmt market addons extensions net routing bgp netsec nfw nginx nms nginx-plus storage s3 buckets obs monitoring synth ratelimit throttle policer secops incident-response mitigation mesh svc-mesh shape-sec safeap site deployment stats metrics logs tickets help-desk telemetry ti tenant-identity idm user-settings threats campaigns threat-intel user accounts iam lb loadbalancer vhost vpm nodes node-mgmt firewall appfw help quit exit clear history"
+  local commands="admin_console_and_ui api authentication bigip billing_and_usage blindfold bot_and_threat_defense cdn ce_management certificates cloud_infrastructure cloudstatus completion container_services data_and_privacy_security data_intelligence ddos dns generative_ai login managed_kubernetes marketplace network network_security nginx_one object_storage observability rate_limiting secops_and_incident_response service_mesh shape sites statistics support telemetry_and_insights tenant_and_identity threat_campaign users virtual vpm_and_node_management waf console-ui ui-assets static-components apisec api-discovery authn oidc sso f5-bigip irule ltm billing-usage quotas usage-tracking bf encrypt secrets threat-defense tpm shape-bot cache content ce-mgmt edge-management ce-lifecycle cert certs ssl tls cloud infra provider vk8s containers workloads data-privacy pii sensitive-data lma di intelligence insights dos ddos-protect dns-zone zones mk8s appstack k8s-mgmt market addons extensions net routing bgp netsec nfw nginx nms nginx-plus storage s3 buckets obs monitoring synth ratelimit throttle policer secops incident-response mitigation mesh svc-mesh shape-sec safeap site deployment stats metrics logs tickets help-desk telemetry ti tenant-identity idm user-settings threats campaigns threat-intel user accounts iam lb loadbalancer vhost vpm nodes node-mgmt firewall appfw help quit exit clear history"
   local actions="list get create delete replace apply status patch add-labels remove-labels"
   local builtins="help quit exit clear history context ctx"
   local global_flags="--help -h --version -v --no-color --output -o --namespace -ns --spec"
@@ -34,6 +34,14 @@ _xcsh_completions() {
           COMPREPLY=($(compgen -W "bash zsh fish" -- "${cur}"))
           return 0
           ;;
+        generative_ai)
+          COMPREPLY=($(compgen -W "query chat feedback eval" -- "${cur}"))
+          return 0
+          ;;
+        generative_ai/eval)
+          COMPREPLY=($(compgen -W "query feedback" -- "${cur}"))
+          return 0
+          ;;
         login)
           COMPREPLY=($(compgen -W "banner profile context" -- "${cur}"))
           return 0

package/completions/xcsh.fish

@@ -40,7 +40,7 @@ complete -c xcsh -n "__fish_use_subcommand" -a "data_and_privacy_security" -d 'P
 complete -c xcsh -n "__fish_use_subcommand" -a "data_intelligence" -d 'Data Intelligence API'
 complete -c xcsh -n "__fish_use_subcommand" -a "ddos" -d 'Volumetric attack mitigation and traffic scrubbing.'
 complete -c xcsh -n "__fish_use_subcommand" -a "dns" -d 'Zones, record types, and load balancing.'
-complete -c xcsh -n "__fish_use_subcommand" -a "generative_ai" -d 'AI assistant queries and feedback collection.'
+complete -c xcsh -n "__fish_use_subcommand" -a "generative_ai" -d 'AI assistant queries and feedback'
 complete -c xcsh -n "__fish_use_subcommand" -a "login" -d 'Authentication and session management'
 complete -c xcsh -n "__fish_use_subcommand" -a "managed_kubernetes" -d 'Cluster RBAC, pod security, and container registries.'
 complete -c xcsh -n "__fish_use_subcommand" -a "marketplace" -d 'Add-on services, connectors, and TPM policies.'
@@ -111,9 +111,6 @@ complete -c xcsh -n "__fish_use_subcommand" -a "dos" -d 'Alias for ddos'
 complete -c xcsh -n "__fish_use_subcommand" -a "ddos-protect" -d 'Alias for ddos'
 complete -c xcsh -n "__fish_use_subcommand" -a "dns-zone" -d 'Alias for dns'
 complete -c xcsh -n "__fish_use_subcommand" -a "zones" -d 'Alias for dns'
-complete -c xcsh -n "__fish_use_subcommand" -a "ai" -d 'Alias for generative_ai'
-complete -c xcsh -n "__fish_use_subcommand" -a "genai" -d 'Alias for generative_ai'
-complete -c xcsh -n "__fish_use_subcommand" -a "assistant" -d 'Alias for generative_ai'
 complete -c xcsh -n "__fish_use_subcommand" -a "mk8s" -d 'Alias for managed_kubernetes'
 complete -c xcsh -n "__fish_use_subcommand" -a "appstack" -d 'Alias for managed_kubernetes'
 complete -c xcsh -n "__fish_use_subcommand" -a "k8s-mgmt" -d 'Alias for managed_kubernetes'
@@ -180,6 +177,12 @@ complete -c xcsh -n "__fish_seen_subcommand_from cloudstatus" -a "maintenance" -
 complete -c xcsh -n "__fish_seen_subcommand_from completion" -a "bash" -d 'Generate bash completion script'
 complete -c xcsh -n "__fish_seen_subcommand_from completion" -a "zsh" -d 'Generate zsh completion script'
 complete -c xcsh -n "__fish_seen_subcommand_from completion" -a "fish" -d 'Generate fish completion script'
+complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "query" -d 'Query the AI assistant'
+complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "chat" -d 'Interactive AI chat mode'
+complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "feedback" -d 'Submit feedback for AI responses'
+complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "eval" -d 'RBAC testing mode commands'
+complete -c xcsh -n "__fish_seen_subcommand_from generative_ai; and __fish_seen_subcommand_from eval" -a "query" -d 'Eval mode AI query'
+complete -c xcsh -n "__fish_seen_subcommand_from generative_ai; and __fish_seen_subcommand_from eval" -a "feedback" -d 'Eval mode feedback submission'
 complete -c xcsh -n "__fish_seen_subcommand_from login" -a "banner" -d 'Display xcsh banner with logo'
 complete -c xcsh -n "__fish_seen_subcommand_from login" -a "profile" -d 'Manage saved connection profiles'
 complete -c xcsh -n "__fish_seen_subcommand_from login; and __fish_seen_subcommand_from profile" -a "list" -d 'List all saved profiles'
@@ -353,16 +356,6 @@ complete -c xcsh -n "__fish_seen_subcommand_from dns" -a "status" -d 'Get resour
 complete -c xcsh -n "__fish_seen_subcommand_from dns" -a "patch" -d 'Patch a resource'
 complete -c xcsh -n "__fish_seen_subcommand_from dns" -a "add-labels" -d 'Add labels to a resource'
 complete -c xcsh -n "__fish_seen_subcommand_from dns" -a "remove-labels" -d 'Remove labels from a resource'
-complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "list" -d 'List resources'
-complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "get" -d 'Get a specific resource'
-complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "create" -d 'Create a new resource'
-complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "delete" -d 'Delete a resource'
-complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "replace" -d 'Replace a resource'
-complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "apply" -d 'Apply configuration from file'
-complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "status" -d 'Get resource status'
-complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "patch" -d 'Patch a resource'
-complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "add-labels" -d 'Add labels to a resource'
-complete -c xcsh -n "__fish_seen_subcommand_from generative_ai" -a "remove-labels" -d 'Remove labels from a resource'
 complete -c xcsh -n "__fish_seen_subcommand_from managed_kubernetes" -a "list" -d 'List resources'
 complete -c xcsh -n "__fish_seen_subcommand_from managed_kubernetes" -a "get" -d 'Get a specific resource'
 complete -c xcsh -n "__fish_seen_subcommand_from managed_kubernetes" -a "create" -d 'Create a new resource'

package/dist/index.js

@@ -46630,8 +46630,8 @@ function getLogoModeFromEnv(envPrefix) {
 var CLI_NAME = "xcsh";
 var CLI_FULL_NAME = "F5 Distributed Cloud Shell";
 function getVersion() {
-  if ("v1.0.90-2601021717") {
-    return "v1.0.90-2601021717";
+  if ("v1.0.90-2601022257") {
+    return "v1.0.90-2601022257";
   }
   if (process.env.XCSH_VERSION) {
     return process.env.XCSH_VERSION;
@@ -47025,9 +47025,9 @@ var APIError = class extends Error {
 
 // src/api/client.ts
 var DEFAULT_RETRY_CONFIG = {
-  maxRetries: 3,
-  initialDelayMs: 1e3,
-  maxDelayMs: 1e4,
+  maxRetries: 2,
+  initialDelayMs: 500,
+  maxDelayMs: 5e3,
   backoffMultiplier: 2,
   jitter: true
 };
@@ -47069,7 +47069,7 @@ var APIClient = class {
   constructor(config) {
     this.serverUrl = config.serverUrl.replace(/\/+$/, "");
     this.apiToken = config.apiToken ?? "";
-    this.timeout = config.timeout ?? 3e4;
+    this.timeout = config.timeout ?? 15e3;
     this.debug = config.debug ?? false;
     this.retryConfig = {
       ...DEFAULT_RETRY_CONFIG,
@@ -47176,13 +47176,20 @@ var APIClient = class {
   }
   /**
    * Check if an error is retryable
+   *
+   * Permanent network errors (connection refused, DNS not found) are NOT retried
+   * since retrying won't help if the server is unreachable.
    */
   isRetryableError(error) {
     if (error instanceof APIError) {
       return RETRYABLE_STATUS_CODES.has(error.statusCode);
     }
     if (error instanceof Error) {
-      return error.name === "AbortError" || error.message.includes("fetch failed") || error.message.includes("network") || error.message.includes("ECONNREFUSED") || error.message.includes("ENOTFOUND") || error.message.includes("ETIMEDOUT");
+      const message = error.message.toLowerCase();
+      if (message.includes("econnrefused") || message.includes("enotfound") || message.includes("ehostunreach") || message.includes("enetunreach")) {
+        return false;
+      }
+      return error.name === "AbortError" || message.includes("etimedout") || message.includes("econnreset") || message.includes("socket hang up");
     }
     return false;
   }
@@ -147143,10 +147150,1076 @@ var completionDomain = {
   subcommands: /* @__PURE__ */ new Map()
 };
 
+// src/domains/generative_ai/client.ts
+var GenAIClient = class {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  /**
+   * Query the AI assistant
+   *
+   * @param namespace - The namespace context for the query
+   * @param query - The natural language query
+   * @returns The AI assistant response with query_id and response data
+   */
+  async query(namespace, query) {
+    const request = {
+      current_query: query,
+      namespace
+    };
+    const response = await this.apiClient.post(
+      `/api/gen-ai/namespaces/${namespace}/query`,
+      request
+    );
+    if (!response.ok) {
+      throw new Error(
+        `GenAI query failed: ${response.statusCode} - ${JSON.stringify(response.data)}`
+      );
+    }
+    return response.data;
+  }
+  /**
+   * Submit feedback for a query
+   *
+   * @param request - The feedback request with query_id and feedback type
+   */
+  async feedback(request) {
+    const response = await this.apiClient.post(
+      `/api/gen-ai/namespaces/${request.namespace}/query_feedback`,
+      request
+    );
+    if (!response.ok) {
+      throw new Error(
+        `GenAI feedback failed: ${response.statusCode} - ${JSON.stringify(response.data)}`
+      );
+    }
+  }
+  /**
+   * Query the AI assistant in eval mode (for RBAC testing)
+   *
+   * @param namespace - The namespace context for the query
+   * @param query - The natural language query
+   * @returns The AI assistant response
+   */
+  async evalQuery(namespace, query) {
+    const request = {
+      current_query: query,
+      namespace
+    };
+    const response = await this.apiClient.post(
+      `/api/gen-ai/namespaces/${namespace}/eval_query`,
+      request
+    );
+    if (!response.ok) {
+      throw new Error(
+        `GenAI eval query failed: ${response.statusCode} - ${JSON.stringify(response.data)}`
+      );
+    }
+    return response.data;
+  }
+  /**
+   * Submit feedback for an eval query
+   *
+   * @param request - The feedback request with query_id and feedback type
+   */
+  async evalFeedback(request) {
+    const response = await this.apiClient.post(
+      `/api/gen-ai/namespaces/${request.namespace}/eval_query_feedback`,
+      request
+    );
+    if (!response.ok) {
+      throw new Error(
+        `GenAI eval feedback failed: ${response.statusCode} - ${JSON.stringify(response.data)}`
+      );
+    }
+  }
+};
+var cachedClient = null;
+function getGenAIClient(apiClient) {
+  if (!cachedClient) {
+    cachedClient = new GenAIClient(apiClient);
+  }
+  return cachedClient;
+}
+
+// src/domains/generative_ai/types.ts
+function getResponseType(response) {
+  if (response.generic_response) return "generic_response";
+  if (response.explain_log) return "explain_log";
+  if (response.gen_dashboard_filter) return "gen_dashboard_filter";
+  if (response.list_response) return "list_response";
+  if (response.site_analysis_response) return "site_analysis_response";
+  if (response.widget_response) return "widget_response";
+  return null;
+}
+var FEEDBACK_TYPE_MAP = {
+  other: "OTHER",
+  inaccurate: "INACCURATE_DATA",
+  irrelevant: "IRRELEVANT_CONTENT",
+  poor_format: "POOR_FORMAT",
+  slow: "SLOW_RESPONSE"
+};
+function getValidFeedbackTypes() {
+  return Object.keys(FEEDBACK_TYPE_MAP);
+}
+
+// src/domains/generative_ai/response-renderer.ts
+function renderResponse(response) {
+  const lines = [];
+  const responseType = getResponseType(response);
+  switch (responseType) {
+    case "generic_response":
+      lines.push(...renderGenericResponse(response.generic_response));
+      break;
+    case "explain_log":
+      lines.push(...renderExplainLog(response.explain_log));
+      break;
+    case "gen_dashboard_filter":
+      lines.push(
+        ...renderDashboardFilter(response.gen_dashboard_filter)
+      );
+      break;
+    case "list_response":
+      lines.push(...renderListResponse(response.list_response));
+      break;
+    case "site_analysis_response":
+      lines.push(...renderSiteAnalysis(response.site_analysis_response));
+      break;
+    case "widget_response":
+      lines.push(...renderWidgetResponse(response.widget_response));
+      break;
+    default:
+      lines.push("No response content.");
+  }
+  if (response.follow_up_queries && response.follow_up_queries.length > 0) {
+    lines.push("");
+    lines.push("Suggested follow-up questions:");
+    response.follow_up_queries.forEach((q, i) => {
+      lines.push(`  ${i + 1}. ${q}`);
+    });
+  }
+  return lines;
+}
+function renderGenericResponse(response) {
+  const lines = [];
+  if (response.error) {
+    lines.push(`Error: ${response.error}`);
+    return lines;
+  }
+  if (response.text) {
+    lines.push(...response.text.split("\n"));
+  }
+  if (response.links && response.links.length > 0) {
+    lines.push("");
+    lines.push("Related links:");
+    for (const link3 of response.links) {
+      lines.push(`  - ${link3.title}: ${link3.url}`);
+    }
+  }
+  return lines;
+}
+function renderExplainLog(response) {
+  const lines = [];
+  lines.push("=== Security Event Analysis ===");
+  lines.push("");
+  if (response.summary) {
+    lines.push("Summary:");
+    lines.push(`  ${response.summary}`);
+    lines.push("");
+  }
+  if (response.action) {
+    lines.push(`Action Taken: ${response.action}`);
+  }
+  if (response.accuracy) {
+    lines.push(`Accuracy: ${response.accuracy}`);
+  }
+  if (response.violations && response.violations.length > 0) {
+    lines.push("");
+    lines.push("Violations Detected:");
+    for (const v of response.violations) {
+      lines.push(`  - ${v.name}: ${v.description}`);
+    }
+  }
+  if (response.threat_campaigns && response.threat_campaigns.length > 0) {
+    lines.push("");
+    lines.push("Threat Campaigns:");
+    for (const campaign of response.threat_campaigns) {
+      lines.push(`  - ${campaign}`);
+    }
+  }
+  if (response.request_details) {
+    lines.push("");
+    lines.push("Request Details:");
+    lines.push(`  ${JSON.stringify(response.request_details, null, 2)}`);
+  }
+  return lines;
+}
+function renderDashboardFilter(response) {
+  const lines = [];
+  lines.push("=== Dashboard Filter ===");
+  lines.push("");
+  if (response.filter_expression) {
+    lines.push("Filter Expression:");
+    lines.push(`  ${response.filter_expression}`);
+  }
+  if (response.dashboard_context) {
+    lines.push("");
+    lines.push("Dashboard Context:");
+    lines.push(`  ${response.dashboard_context}`);
+  }
+  return lines;
+}
+function renderListResponse(response) {
+  const lines = [];
+  if (response.formatted_list) {
+    lines.push(response.formatted_list);
+    return lines;
+  }
+  if (response.items && response.items.length > 0) {
+    if (response.total_count !== void 0) {
+      lines.push(`Total: ${response.total_count} items`);
+      lines.push("");
+    }
+    for (const item of response.items) {
+      lines.push(JSON.stringify(item, null, 2));
+      lines.push("");
+    }
+  } else {
+    lines.push("No items found.");
+  }
+  return lines;
+}
+function renderSiteAnalysis(response) {
+  const lines = [];
+  lines.push("=== Site Analysis ===");
+  lines.push("");
+  if (response.site_name) {
+    lines.push(`Site: ${response.site_name}`);
+  }
+  if (response.health_status) {
+    lines.push(`Health: ${response.health_status}`);
+  }
+  if (response.metrics) {
+    lines.push("");
+    lines.push("Metrics:");
+    for (const [key, value] of Object.entries(response.metrics)) {
+      lines.push(`  ${key}: ${JSON.stringify(value)}`);
+    }
+  }
+  if (response.recommendations && response.recommendations.length > 0) {
+    lines.push("");
+    lines.push("Recommendations:");
+    for (const rec of response.recommendations) {
+      lines.push(`  - ${rec}`);
+    }
+  }
+  return lines;
+}
+function renderWidgetResponse(response) {
+  const lines = [];
+  if (response.display_type) {
+    lines.push(`Widget Type: ${response.display_type}`);
+    lines.push("");
+  }
+  if (response.table) {
+    for (const row of response.table.rows) {
+      const cells = row.cells.map((cell) => {
+        let value = cell.value;
+        if (cell.properties?.status_style) {
+          value = `[${cell.properties.status_style}] ${value}`;
+        }
+        return value;
+      });
+      lines.push(cells.join(" | "));
+    }
+  }
+  if (response.links && response.links.length > 0) {
+    lines.push("");
+    lines.push("Links:");
+    for (const link3 of response.links) {
+      lines.push(`  - ${link3.title}: ${link3.url}`);
+    }
+  }
+  return lines;
+}
+
+// src/domains/generative_ai/query.ts
+var lastQueryState = {
+  namespace: "",
+  lastQueryId: null,
+  lastQuery: null,
+  followUpQueries: [],
+  isActive: false
+};
+function getLastQueryState() {
+  return lastQueryState;
+}
+function updateLastQueryState(partial) {
+  lastQueryState = { ...lastQueryState, ...partial };
+}
+function clearLastQueryState() {
+  lastQueryState = {
+    namespace: "",
+    lastQueryId: null,
+    lastQuery: null,
+    followUpQueries: [],
+    isActive: false
+  };
+}
+function parseQueryArgs(args, session) {
+  const { options, remainingArgs } = parseDomainOutputFlags(
+    args,
+    session.getOutputFormat()
+  );
+  let spec = false;
+  let namespace = session.getNamespace();
+  const questionParts = [];
+  let i = 0;
+  while (i < remainingArgs.length) {
+    const arg = remainingArgs[i];
+    if (arg === "--spec") {
+      spec = true;
+    } else if (arg === "--namespace" || arg === "-ns") {
+      if (i + 1 < remainingArgs.length) {
+        namespace = remainingArgs[i + 1] ?? namespace;
+        i++;
+      }
+    } else {
+      questionParts.push(arg ?? "");
+    }
+    i++;
+  }
+  return {
+    format: options.format,
+    noColor: options.noColor,
+    spec,
+    namespace,
+    question: questionParts.join(" ")
+  };
+}
+var queryCommand = {
+  name: "query",
+  description: "Send a natural language query to the F5 Distributed Cloud AI assistant. Ask about load balancers, WAF configurations, site status, security events, or any platform topic. Returns AI-generated responses with optional follow-up suggestions. Use --namespace to specify the context for namespace-scoped resources.",
+  descriptionShort: "Query the AI assistant",
+  descriptionMedium: "Send natural language queries to the AI assistant for help with F5 XC platform operations, configurations, and troubleshooting.",
+  usage: "<question> [--namespace <ns>]",
+  aliases: ["ask", "q"],
+  async execute(args, session) {
+    const { format, noColor, spec, namespace, question } = parseQueryArgs(
+      args,
+      session
+    );
+    if (spec) {
+      const cmdSpec = getCommandSpec("generative_ai query");
+      if (cmdSpec) {
+        return successResult([formatSpec(cmdSpec)]);
+      }
+    }
+    if (!question.trim()) {
+      return errorResult(
+        "Please provide a question. Usage: ai query <question>"
+      );
+    }
+    const apiClient = session.getAPIClient();
+    if (!apiClient) {
+      return errorResult(
+        "Not connected to API. Please configure connection first."
+      );
+    }
+    if (!session.isTokenValidated()) {
+      return errorResult(
+        "Not authenticated. Please check your API token."
+      );
+    }
+    try {
+      const client = getGenAIClient(apiClient);
+      const response = await client.query(namespace, question);
+      updateLastQueryState({
+        namespace,
+        lastQueryId: response.query_id,
+        lastQuery: question,
+        followUpQueries: response.follow_up_queries ?? [],
+        isActive: true
+      });
+      if (format === "none") {
+        return successResult([]);
+      }
+      if (format === "json" || format === "yaml" || format === "tsv") {
+        return successResult(
+          formatDomainOutput(response, { format, noColor })
+        );
+      }
+      const lines = renderResponse(response);
+      return successResult(lines);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return errorResult(`Query failed: ${message}`);
+    }
+  }
+};
+
+// src/domains/generative_ai/chat.ts
+import * as readline from "readline";
+function parseChatArgs(args, session) {
+  const { remainingArgs } = parseDomainOutputFlags(
+    args,
+    session.getOutputFormat()
+  );
+  let spec = false;
+  let namespace = session.getNamespace();
+  let i = 0;
+  while (i < remainingArgs.length) {
+    const arg = remainingArgs[i];
+    if (arg === "--spec") {
+      spec = true;
+    } else if (arg === "--namespace" || arg === "-ns") {
+      if (i + 1 < remainingArgs.length) {
+        namespace = remainingArgs[i + 1] ?? namespace;
+        i++;
+      }
+    }
+    i++;
+  }
+  return { spec, namespace };
+}
+function showChatHelp() {
+  return [
+    "",
+    "=== AI Chat Commands ===",
+    "",
+    "  /exit, /quit, /q    - Exit chat mode",
+    "  /help, /h           - Show this help",
+    "  /clear, /c          - Clear conversation context",
+    "  /feedback <type>    - Submit feedback for last response",
+    "                        Types: positive, negative",
+    "  1, 2, 3...          - Select a follow-up question by number",
+    "",
+    "Just type your question to query the AI assistant.",
+    ""
+  ];
+}
+async function handleFeedback(input, session) {
+  const state = getLastQueryState();
+  if (!state.lastQueryId || !state.lastQuery) {
+    return ["No previous query to provide feedback for."];
+  }
+  const parts = input.split(/\s+/);
+  const feedbackType = parts[1]?.toLowerCase();
+  if (!feedbackType) {
+    return [
+      "Usage: /feedback <positive|negative>",
+      "  Optional: /feedback negative <type> [comment]",
+      "  Types: other, inaccurate, irrelevant, poor_format, slow"
+    ];
+  }
+  const apiClient = session.getAPIClient();
+  if (!apiClient) {
+    return ["Not connected to API."];
+  }
+  try {
+    const client = getGenAIClient(apiClient);
+    if (feedbackType === "positive" || feedbackType === "+") {
+      await client.feedback({
+        query: state.lastQuery,
+        query_id: state.lastQueryId,
+        namespace: state.namespace,
+        positive_feedback: {}
+      });
+      return ["Positive feedback submitted. Thank you!"];
+    }
+    if (feedbackType === "negative" || feedbackType === "-") {
+      const negType = parts[2]?.toLowerCase();
+      const mappedType = negType ? FEEDBACK_TYPE_MAP[negType] : void 0;
+      const comment = parts.slice(3).join(" ") || void 0;
+      await client.feedback({
+        query: state.lastQuery,
+        query_id: state.lastQueryId,
+        namespace: state.namespace,
+        negative_feedback: {
+          remarks: mappedType ? [mappedType] : ["OTHER"]
+        },
+        comment
+      });
+      return [
+        "Negative feedback submitted. Thank you for helping improve the AI."
+      ];
+    }
+    return [
+      `Unknown feedback type: ${feedbackType}`,
+      "Use 'positive' or 'negative'."
+    ];
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return [`Feedback failed: ${message}`];
+  }
+}
+async function runChatLoop(session, namespace) {
+  const apiClient = session.getAPIClient();
+  if (!apiClient) {
+    return ["Not connected to API. Please configure connection first."];
+  }
+  if (!session.isTokenValidated()) {
+    return ["Not authenticated. Please check your API token."];
+  }
+  const client = getGenAIClient(apiClient);
+  const output = [];
+  output.push("");
+  output.push("=== F5 XC AI Assistant Chat ===");
+  output.push(`Namespace: ${namespace}`);
+  output.push("Type /help for commands, /exit to quit.");
+  output.push("");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: process.stdin.isTTY ?? false
+  });
+  let interrupted = false;
+  rl.on("SIGINT", () => {
+    interrupted = true;
+    console.log("\n(Use /exit to leave chat mode)");
+    rl.prompt();
+  });
+  const askQuestion = (prompt) => {
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer) => {
+        resolve(answer);
+      });
+    });
+  };
+  for (const line of output) {
+    console.log(line);
+  }
+  let running = true;
+  while (running && !interrupted) {
+    const input = await askQuestion("ai> ");
+    if (interrupted) {
+      break;
+    }
+    const trimmed = input.trim();
+    if (!trimmed) {
+      continue;
+    }
+    if (trimmed === "/exit" || trimmed === "/quit" || trimmed === "/q") {
+      console.log("Exiting chat mode.");
+      running = false;
+      break;
+    }
+    if (trimmed === "/help" || trimmed === "/h") {
+      for (const line of showChatHelp()) {
+        console.log(line);
+      }
+      continue;
+    }
+    if (trimmed === "/clear" || trimmed === "/c") {
+      clearLastQueryState();
+      console.log("Conversation context cleared.");
+      continue;
+    }
+    if (trimmed.startsWith("/feedback")) {
+      const feedbackLines = await handleFeedback(trimmed, session);
+      for (const line of feedbackLines) {
+        console.log(line);
+      }
+      continue;
+    }
+    if (/^\d+$/.test(trimmed)) {
+      const num = parseInt(trimmed, 10);
+      const state = getLastQueryState();
+      if (state.followUpQueries.length > 0 && num >= 1 && num <= state.followUpQueries.length) {
+        const followUp = state.followUpQueries[num - 1];
+        if (followUp) {
+          console.log(`
+Following up: ${followUp}
+`);
+          try {
+            const response = await client.query(
+              namespace,
+              followUp
+            );
+            updateLastQueryState({
+              namespace,
+              lastQueryId: response.query_id,
+              lastQuery: followUp,
+              followUpQueries: response.follow_up_queries ?? []
+            });
+            const lines = renderResponse(response);
+            for (const line of lines) {
+              console.log(line);
+            }
+            console.log("");
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.log(`Query failed: ${message}`);
+          }
+          continue;
+        }
+      }
+      console.log(
+        `Invalid selection. Choose 1-${state.followUpQueries.length} from suggested follow-ups.`
+      );
+      continue;
+    }
+    if (trimmed.startsWith("/")) {
+      console.log(
+        `Unknown command: ${trimmed}. Type /help for commands.`
+      );
+      continue;
+    }
+    try {
+      const response = await client.query(namespace, trimmed);
+      updateLastQueryState({
+        namespace,
+        lastQueryId: response.query_id,
+        lastQuery: trimmed,
+        followUpQueries: response.follow_up_queries ?? []
+      });
+      console.log("");
+      const lines = renderResponse(response);
+      for (const line of lines) {
+        console.log(line);
+      }
+      console.log("");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`Query failed: ${message}`);
+    }
+  }
+  rl.close();
+  return ["Chat session ended."];
+}
+var chatCommand = {
+  name: "chat",
+  description: "Start an interactive conversation with the F5 XC AI assistant. Enter a multi-turn dialog where you can ask questions, receive responses with follow-up suggestions, and navigate through topics naturally. Use numbered responses to quickly select suggested follow-up questions. Supports in-chat feedback submission. Type /exit to return to the main CLI.",
+  descriptionShort: "Interactive AI chat mode",
+  descriptionMedium: "Start an interactive multi-turn conversation with the AI assistant. Supports follow-up suggestions and in-chat commands.",
+  usage: "[--namespace <ns>]",
+  aliases: ["interactive", "i"],
+  async execute(args, session) {
+    const { spec, namespace } = parseChatArgs(args, session);
+    if (spec) {
+      const cmdSpec = getCommandSpec("generative_ai chat");
+      if (cmdSpec) {
+        return successResult([formatSpec(cmdSpec)]);
+      }
+    }
+    if (!process.stdin.isTTY) {
+      return errorResult(
+        "Chat mode requires an interactive terminal. Use 'ai query' for non-interactive queries."
+      );
+    }
+    try {
+      const result = await runChatLoop(session, namespace);
+      return successResult(result);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return errorResult(`Chat session failed: ${message}`);
+    }
+  }
+};
+
+// src/domains/generative_ai/feedback.ts
+function parseFeedbackArgs(args, session) {
+  const { remainingArgs } = parseDomainOutputFlags(
+    args,
+    session.getOutputFormat()
+  );
+  let spec = false;
+  let namespace = session.getNamespace();
+  let positive = false;
+  let negativeType = null;
+  let comment = null;
+  let queryId = null;
+  let i = 0;
+  while (i < remainingArgs.length) {
+    const arg = remainingArgs[i];
+    if (arg === "--spec") {
+      spec = true;
+    } else if (arg === "--namespace" || arg === "-ns") {
+      if (i + 1 < remainingArgs.length) {
+        namespace = remainingArgs[i + 1] ?? namespace;
+        i++;
+      }
+    } else if (arg === "--positive" || arg === "-p") {
+      positive = true;
+    } else if (arg === "--negative" || arg === "-n") {
+      if (i + 1 < remainingArgs.length) {
+        const typeArg = remainingArgs[i + 1]?.toLowerCase();
+        if (typeArg && FEEDBACK_TYPE_MAP[typeArg]) {
+          negativeType = FEEDBACK_TYPE_MAP[typeArg] ?? null;
+          i++;
+        } else {
+          negativeType = "OTHER";
+        }
+      } else {
+        negativeType = "OTHER";
+      }
+    } else if (arg === "--comment" || arg === "-c") {
+      if (i + 1 < remainingArgs.length) {
+        comment = remainingArgs[i + 1] ?? null;
+        i++;
+      }
+    } else if (arg === "--query-id" || arg === "-q") {
+      if (i + 1 < remainingArgs.length) {
+        queryId = remainingArgs[i + 1] ?? null;
+        i++;
+      }
+    }
+    i++;
+  }
+  return {
+    spec,
+    namespace,
+    positive,
+    negativeType,
+    comment,
+    queryId
+  };
+}
+var feedbackCommand = {
+  name: "feedback",
+  description: "Submit feedback on AI assistant responses to help improve future answers. Provide positive feedback when responses are helpful, or negative feedback with a reason type when improvements are needed. Feedback is associated with the most recent query unless a specific query ID is provided. Negative feedback types include: inaccurate (wrong information), irrelevant (off-topic), poor_format (hard to read), slow (response time), or other.",
+  descriptionShort: "Submit feedback for AI responses",
+  descriptionMedium: "Provide positive or negative feedback for AI assistant responses. Use --negative with a type: inaccurate, irrelevant, poor_format, slow, or other.",
+  usage: "--positive | --negative <type> [--comment <text>] [--query-id <id>]",
+  aliases: ["fb", "rate"],
+  async execute(args, session) {
+    const { spec, namespace, positive, negativeType, comment, queryId } = parseFeedbackArgs(args, session);
+    if (spec) {
+      const cmdSpec = getCommandSpec("generative_ai feedback");
+      if (cmdSpec) {
+        return successResult([formatSpec(cmdSpec)]);
+      }
+    }
+    if (!positive && !negativeType) {
+      const validTypes = getValidFeedbackTypes().join(", ");
+      return errorResult(
+        `Please specify feedback type:
+  --positive (-p)       Rate the response positively
+  --negative (-n) <type> Rate negatively with reason
+
+Negative types: ${validTypes}`
+      );
+    }
+    const state = getLastQueryState();
+    const targetQueryId = queryId ?? state.lastQueryId;
+    const targetQuery = state.lastQuery;
+    if (!targetQueryId) {
+      return errorResult(
+        "No query to provide feedback for. Make a query first, or use --query-id to specify one."
+      );
+    }
+    if (!targetQuery && !queryId) {
+      return errorResult(
+        "Could not find the original query. Use --query-id to specify the query ID."
+      );
+    }
+    const apiClient = session.getAPIClient();
+    if (!apiClient) {
+      return errorResult(
+        "Not connected to API. Please configure connection first."
+      );
+    }
+    if (!session.isTokenValidated()) {
+      return errorResult(
+        "Not authenticated. Please check your API token."
+      );
+    }
+    try {
+      const client = getGenAIClient(apiClient);
+      if (positive) {
+        await client.feedback({
+          query: targetQuery ?? "",
+          query_id: targetQueryId,
+          namespace: state.namespace || namespace,
+          positive_feedback: {},
+          comment: comment ?? void 0
+        });
+        return successResult([
+          "Positive feedback submitted successfully.",
+          `Query ID: ${targetQueryId}`
+        ]);
+      }
+      await client.feedback({
+        query: targetQuery ?? "",
+        query_id: targetQueryId,
+        namespace: state.namespace || namespace,
+        negative_feedback: {
+          remarks: negativeType ? [negativeType] : ["OTHER"]
+        },
+        comment: comment ?? void 0
+      });
+      return successResult([
+        "Negative feedback submitted successfully.",
+        `Query ID: ${targetQueryId}`,
+        `Reason: ${negativeType ?? "OTHER"}`,
+        ...comment ? [`Comment: ${comment}`] : []
+      ]);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return errorResult(`Feedback submission failed: ${message}`);
+    }
+  }
+};
+
+// src/domains/generative_ai/eval.ts
+function parseEvalQueryArgs(args, session) {
+  const { options, remainingArgs } = parseDomainOutputFlags(
+    args,
+    session.getOutputFormat()
+  );
+  let spec = false;
+  let namespace = session.getNamespace();
+  const questionParts = [];
+  let i = 0;
+  while (i < remainingArgs.length) {
+    const arg = remainingArgs[i];
+    if (arg === "--spec") {
+      spec = true;
+    } else if (arg === "--namespace" || arg === "-ns") {
+      if (i + 1 < remainingArgs.length) {
+        namespace = remainingArgs[i + 1] ?? namespace;
+        i++;
+      }
+    } else {
+      questionParts.push(arg ?? "");
+    }
+    i++;
+  }
+  return {
+    format: options.format,
+    noColor: options.noColor,
+    spec,
+    namespace,
+    question: questionParts.join(" ")
+  };
+}
+var evalQueryCommand = {
+  name: "query",
+  description: "Send a query to the AI assistant using the eval endpoint. This endpoint is used for RBAC testing and validation purposes, allowing administrators to test permission scenarios without affecting production query analytics.",
+  descriptionShort: "Eval mode AI query",
+  descriptionMedium: "Query the AI assistant in eval mode for RBAC testing and permission validation.",
+  usage: "<question> [--namespace <ns>]",
+  aliases: ["q"],
+  async execute(args, session) {
+    const { format, noColor, spec, namespace, question } = parseEvalQueryArgs(args, session);
+    if (spec) {
+      const cmdSpec = getCommandSpec("generative_ai eval query");
+      if (cmdSpec) {
+        return successResult([formatSpec(cmdSpec)]);
+      }
+    }
+    if (!question.trim()) {
+      return errorResult(
+        "Please provide a question. Usage: ai eval query <question>"
+      );
+    }
+    const apiClient = session.getAPIClient();
+    if (!apiClient) {
+      return errorResult(
+        "Not connected to API. Please configure connection first."
+      );
+    }
+    if (!session.isTokenValidated()) {
+      return errorResult(
+        "Not authenticated. Please check your API token."
+      );
+    }
+    try {
+      const client = getGenAIClient(apiClient);
+      const response = await client.evalQuery(namespace, question);
+      updateLastQueryState({
+        namespace,
+        lastQueryId: response.query_id,
+        lastQuery: question,
+        followUpQueries: response.follow_up_queries ?? [],
+        isActive: true
+      });
+      if (format === "none") {
+        return successResult([]);
+      }
+      if (format === "json" || format === "yaml" || format === "tsv") {
+        return successResult(
+          formatDomainOutput(response, { format, noColor })
+        );
+      }
+      const lines = ["[EVAL MODE]", "", ...renderResponse(response)];
+      return successResult(lines);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return errorResult(`Eval query failed: ${message}`);
+    }
+  }
+};
+function parseEvalFeedbackArgs(args, session) {
+  const { remainingArgs } = parseDomainOutputFlags(
+    args,
+    session.getOutputFormat()
+  );
+  let spec = false;
+  let namespace = session.getNamespace();
+  let positive = false;
+  let negativeType = null;
+  let comment = null;
+  let queryId = null;
+  let i = 0;
+  while (i < remainingArgs.length) {
+    const arg = remainingArgs[i];
+    if (arg === "--spec") {
+      spec = true;
+    } else if (arg === "--namespace" || arg === "-ns") {
+      if (i + 1 < remainingArgs.length) {
+        namespace = remainingArgs[i + 1] ?? namespace;
+        i++;
+      }
+    } else if (arg === "--positive" || arg === "-p") {
+      positive = true;
+    } else if (arg === "--negative" || arg === "-n") {
+      if (i + 1 < remainingArgs.length) {
+        const typeArg = remainingArgs[i + 1]?.toLowerCase();
+        if (typeArg && FEEDBACK_TYPE_MAP[typeArg]) {
+          negativeType = FEEDBACK_TYPE_MAP[typeArg] ?? null;
+          i++;
+        } else {
+          negativeType = "OTHER";
+        }
+      } else {
+        negativeType = "OTHER";
+      }
+    } else if (arg === "--comment" || arg === "-c") {
+      if (i + 1 < remainingArgs.length) {
+        comment = remainingArgs[i + 1] ?? null;
+        i++;
+      }
+    } else if (arg === "--query-id" || arg === "-q") {
+      if (i + 1 < remainingArgs.length) {
+        queryId = remainingArgs[i + 1] ?? null;
+        i++;
+      }
+    }
+    i++;
+  }
+  return {
+    spec,
+    namespace,
+    positive,
+    negativeType,
+    comment,
+    queryId
+  };
+}
+var evalFeedbackCommand = {
+  name: "feedback",
+  description: "Submit feedback for an eval mode query. Use this endpoint when providing feedback for queries made through the eval endpoint, ensuring proper RBAC testing analytics separation.",
+  descriptionShort: "Eval mode feedback submission",
+  descriptionMedium: "Submit feedback for eval mode AI queries, keeping RBAC testing analytics separate.",
+  usage: "--positive | --negative <type> [--comment <text>] [--query-id <id>]",
+  aliases: ["fb"],
+  async execute(args, session) {
+    const { spec, namespace, positive, negativeType, comment, queryId } = parseEvalFeedbackArgs(args, session);
+    if (spec) {
+      const cmdSpec = getCommandSpec("generative_ai eval feedback");
+      if (cmdSpec) {
+        return successResult([formatSpec(cmdSpec)]);
+      }
+    }
+    if (!positive && !negativeType) {
+      const validTypes = getValidFeedbackTypes().join(", ");
+      return errorResult(
+        `Please specify feedback type:
+  --positive (-p)       Rate the response positively
+  --negative (-n) <type> Rate negatively with reason
+
+Negative types: ${validTypes}`
+      );
+    }
+    const state = getLastQueryState();
+    const targetQueryId = queryId ?? state.lastQueryId;
+    const targetQuery = state.lastQuery;
+    if (!targetQueryId) {
+      return errorResult(
+        "No query to provide feedback for. Make an eval query first, or use --query-id to specify one."
+      );
+    }
+    const apiClient = session.getAPIClient();
+    if (!apiClient) {
+      return errorResult(
+        "Not connected to API. Please configure connection first."
+      );
+    }
+    if (!session.isTokenValidated()) {
+      return errorResult(
+        "Not authenticated. Please check your API token."
+      );
+    }
+    try {
+      const client = getGenAIClient(apiClient);
+      if (positive) {
+        await client.evalFeedback({
+          query: targetQuery ?? "",
+          query_id: targetQueryId,
+          namespace: state.namespace || namespace,
+          positive_feedback: {},
+          comment: comment ?? void 0
+        });
+        return successResult([
+          "[EVAL MODE] Positive feedback submitted successfully.",
+          `Query ID: ${targetQueryId}`
+        ]);
+      }
+      await client.evalFeedback({
+        query: targetQuery ?? "",
+        query_id: targetQueryId,
+        namespace: state.namespace || namespace,
+        negative_feedback: {
+          remarks: negativeType ? [negativeType] : ["OTHER"]
+        },
+        comment: comment ?? void 0
+      });
+      return successResult([
+        "[EVAL MODE] Negative feedback submitted successfully.",
+        `Query ID: ${targetQueryId}`,
+        `Reason: ${negativeType ?? "OTHER"}`,
+        ...comment ? [`Comment: ${comment}`] : []
+      ]);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return errorResult(`Eval feedback submission failed: ${message}`);
+    }
+  }
+};
+var evalSubcommands = {
+  name: "eval",
+  description: "Eval mode commands for RBAC testing and permission validation. Use these endpoints to test AI assistant queries and feedback without affecting production analytics. Useful for administrators validating access controls.",
+  descriptionShort: "RBAC testing mode commands",
+  descriptionMedium: "Query and provide feedback in eval mode for RBAC testing and permission validation.",
+  commands: /* @__PURE__ */ new Map([
+    ["query", evalQueryCommand],
+    ["feedback", evalFeedbackCommand]
+  ]),
+  defaultCommand: evalQueryCommand
+};
+
+// src/domains/generative_ai/index.ts
+var generativeAiDomain = {
+  name: "generative_ai",
+  description: "Interact with the F5 Distributed Cloud AI assistant for natural language queries about platform operations. Ask questions about load balancers, WAF configurations, site status, security events, or any platform topic. Supports single queries with follow-up suggestions, interactive multi-turn chat sessions, and feedback submission to improve AI responses.",
+  descriptionShort: "AI assistant queries and feedback",
+  descriptionMedium: "Query the AI assistant for help with F5 XC platform operations, configurations, security analysis, and troubleshooting.",
+  defaultCommand: queryCommand,
+  commands: /* @__PURE__ */ new Map([
+    ["query", queryCommand],
+    ["chat", chatCommand],
+    ["feedback", feedbackCommand]
+  ]),
+  subcommands: /* @__PURE__ */ new Map([["eval", evalSubcommands]])
+};
+var generativeAiAliases = ["ai", "genai", "assistant"];
+
 // src/domains/index.ts
 customDomains.register(loginDomain);
 customDomains.register(cloudstatusDomain);
 customDomains.register(completionDomain);
+customDomains.register(generativeAiDomain);
 for (const domain of customDomains.all()) {
   completionRegistry.registerDomain(fromCustomDomain(domain));
 }
@@ -147159,6 +148232,9 @@ var domainAliases = /* @__PURE__ */ new Map();
 for (const alias of cloudstatusAliases) {
   domainAliases.set(alias, "cloudstatus");
 }
+for (const alias of generativeAiAliases) {
+  domainAliases.set(alias, "generative_ai");
+}
 function resolveDomainAlias(name) {
   return domainAliases.get(name) ?? name;
 }
@@ -149927,7 +151003,7 @@ function App2({ initialSession } = {}) {
 }
 
 // src/headless/controller.ts
-import * as readline from "readline";
+import * as readline2 from "readline";
 
 // src/headless/protocol.ts
 function parseInput2(line) {
@@ -150202,7 +151278,7 @@ var HeadlessController = class {
    */
   async run() {
     await this.initialize();
-    this.rl = readline.createInterface({
+    this.rl = readline2.createInterface({
       input: process.stdin,
       output: process.stdout,
       terminal: false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robinmordasiewicz/f5xc-xcsh",
-  "version": "1.0.90-2601021717",
+  "version": "1.0.90-2601022257",
   "description": "F5 Distributed Cloud Shell - Interactive CLI for F5 XC",
   "type": "module",
   "bin": {