ServiceNow Integration

application/single_app/config.py

@@ -88,8 +88,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.237.007"
-
+VERSION = "0.237.008"
 
 SECRET_KEY = os.getenv('SECRET_KEY', 'dev-secret-key-change-in-production')
 

application/single_app/route_backend_plugins.py

@@ -458,6 +458,12 @@ def create_group_action_route():
     for key in ('group_id', 'last_updated', 'user_id', 'is_global', 'is_group', 'scope'):
         payload.pop(key, None)
 
+    # Merge with schema to ensure all required fields are present (same as global actions)
+    schema_dir = os.path.join(current_app.root_path, 'static', 'json', 'schemas')
+    merged = get_merged_plugin_settings(payload.get('type'), payload, schema_dir)
+    payload['metadata'] = merged.get('metadata', payload.get('metadata', {}))
+    payload['additionalFields'] = merged.get('additionalFields', payload.get('additionalFields', {}))
+
     try:
         saved = save_group_action(active_group, payload)
     except Exception as exc:
@@ -511,6 +517,12 @@ def update_group_action_route(action_id):
     except ValueError as exc:
         return jsonify({'error': str(exc)}), 400
 
+    # Merge with schema to ensure all required fields are present (same as global actions)
+    schema_dir = os.path.join(current_app.root_path, 'static', 'json', 'schemas')
+    schema_merged = get_merged_plugin_settings(merged.get('type'), merged, schema_dir)
+    merged['metadata'] = schema_merged.get('metadata', merged.get('metadata', {}))
+    merged['additionalFields'] = schema_merged.get('additionalFields', merged.get('additionalFields', {}))
+
     try:
         saved = save_group_action(active_group, merged)
     except Exception as exc:

application/single_app/semantic_kernel_loader.py

@@ -1,4 +1,4 @@
-# semantic_kernel_loader.py
+# semantic_kernel_loader.py
 """
 Loader for Semantic Kernel plugins/actions from app settings.
 - Loads plugin/action manifests from settings (CosmosDB)
@@ -1186,26 +1186,60 @@ def load_user_semantic_kernel(kernel: Kernel, settings, user_id: str, redis_clie
     for agent in agents_cfg:
         agent['is_global'] = False
 
+    # Load group agents for user's active group (if any)
+    try:
+        active_group_id = require_active_group(user_id)
+        group_agents = get_group_agents(active_group_id)
+        if group_agents:
+            print(f"[SK Loader] Found {len(group_agents)} group agents for active group '{active_group_id}'")
+            # Badge group agents with group metadata
+            for group_agent in group_agents:
+                group_agent['is_global'] = False
+                group_agent['is_group'] = True
+            agents_cfg.extend(group_agents)
+            print(f"[SK Loader] After merging group agents: {len(agents_cfg)} total agents")
+        else:
+            print(f"[SK Loader] No group agents found for active group '{active_group_id}'")
+    except ValueError:
+        # No active group set - this is fine, just means no group agents available
+        print(f"[SK Loader] User '{user_id}' has no active group - skipping group agent loading")
+
     # Append selected group agent (if any) to the candidate list so downstream selection logic can resolve it
     selected_agent_data = selected_agent if isinstance(selected_agent, dict) else {}
     selected_agent_is_group = selected_agent_data.get('is_group', False)
     if selected_agent_is_group:
         resolved_group_id = selected_agent_data.get('group_id')
+        active_group_id = None
+
+        # Group agent MUST have a group_id
+        if not resolved_group_id:
+            log_event(
+                "[SK Loader] Group agent selected but no group_id provided in selection data.",
+                level=logging.ERROR
+            )
+            load_core_plugins_only(kernel, settings)
+            return kernel, None
+
         try:
             active_group_id = require_active_group(user_id)
-            if not resolved_group_id:
-                resolved_group_id = active_group_id
-            elif resolved_group_id != active_group_id:
+            if resolved_group_id != active_group_id:
                 debug_print(
                     f"[SK Loader] Selected group agent references group {resolved_group_id}, active group is {active_group_id}."
                 )
-        except ValueError as err:
-            debug_print(f"[SK Loader] No active group available while loading group agent: {err}")
-            if not resolved_group_id:
                 log_event(
-                    "[SK Loader] Group agent selected but no active group in settings.",
-                    level=logging.WARNING
+                    "[SK Loader] Group agent selected from the non-active group.",
+                    level=logging.ERROR
                 )
+                load_core_plugins_only(kernel, settings)
+                return kernel, None
+        except ValueError as err:
+            debug_print(f"[SK Loader] No active group available while loading group agent: {err}")
+            log_event(
+                "[SK Loader] Group agent selected but no active group in settings.",
+                level=logging.ERROR
+            )
+            load_core_plugins_only(kernel, settings)
+            return kernel, None
 
         if resolved_group_id:
             agent_identifier = selected_agent_data.get('id') or selected_agent_data.get('name')
@@ -1234,11 +1268,6 @@ def load_user_semantic_kernel(kernel: Kernel, settings, user_id: str, redis_clie
                     f"[SK Loader] Selected group agent '{selected_agent_data.get('name')}' not found for group {resolved_group_id}.",
                     level=logging.WARNING
                 )
-        else:
-            log_event(
-                "[SK Loader] Unable to resolve group ID for selected group agent; skipping group agent load.",
-                level=logging.WARNING
-            )
 
     # PATCH: Merge global agents if enabled
     merge_global = settings.get('merge_global_semantic_kernel_with_workspace', False)

application/single_app/semantic_kernel_plugins/openapi_plugin_factory.py

@@ -12,6 +12,7 @@
 import tempfile
 from typing import Dict, Any, Optional
 from .openapi_plugin import OpenApiPlugin
+from functions_debug import debug_print
 
 
 class OpenApiPluginFactory:
@@ -130,10 +131,48 @@ def _extract_auth_config(cls, config: Dict[str, Any]) -> Dict[str, Any]:
             return {}
 
         auth_type = auth_config.get('type', 'none')
+        debug_print(f"[Factory] auth_type: {auth_type}")
 
         if auth_type == 'none':
             return {}
 
-        # Return the auth config as-is since the OpenApiPlugin already handles
-        # the different auth types
+        # Check if this is basic auth stored in the 'key' field format
+        # Simple Chat stores basic auth as: auth.type='key', auth.key='username:password', additionalFields.auth_method='basic'
+        additional_fields = config.get('additionalFields', {})
+        auth_method = additional_fields.get('auth_method', '')
+        debug_print(f"[Factory] additionalFields.auth_method: {auth_method}")
+
+        if auth_type == 'key' and auth_method == 'basic':
+            # Extract username and password from the combined key
+            key = auth_config.get('key', '')
+            debug_print(f"[Factory] Applying basic auth transformation")
+            if ':' in key:
+                username, password = key.split(':', 1)
+                return {
+                    'type': 'basic',
+                    'username': username,
+                    'password': password
+                }
+            else:
+                # Malformed basic auth key
+                return {}
+
+        # For bearer tokens stored as 'key' type
+        if auth_type == 'key' and auth_method == 'bearer':
+            token = auth_config.get('key', '')
+            debug_print(f"[Factory] Applying bearer auth transformation")
+            return {
+                'type': 'bearer',
+                'token': token
+            }
+
+        # For OAuth2 stored as 'key' type
+        if auth_type == 'key' and auth_method == 'oauth2':
+            debug_print(f"[Factory] Applying OAuth2 auth transformation")
+            return {
+                'type': 'bearer',  # OAuth2 tokens are typically bearer tokens
+                'token': auth_config.get('key', '')
+            }
+
+        # Return the auth config as-is for other auth types
         return auth_config